1 /* 2 * pmcraid.c -- driver for PMC Sierra MaxRAID controller adapters 3 * 4 * Written By: Anil Ravindranath<anil_ravindranath@pmc-sierra.com> 5 * PMC-Sierra Inc 6 * 7 * Copyright (C) 2008, 2009 PMC Sierra Inc 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, 22 * USA 23 * 24 */ 25 #include <linux/fs.h> 26 #include <linux/init.h> 27 #include <linux/types.h> 28 #include <linux/errno.h> 29 #include <linux/kernel.h> 30 #include <linux/ioport.h> 31 #include <linux/delay.h> 32 #include <linux/pci.h> 33 #include <linux/wait.h> 34 #include <linux/spinlock.h> 35 #include <linux/sched.h> 36 #include <linux/interrupt.h> 37 #include <linux/blkdev.h> 38 #include <linux/firmware.h> 39 #include <linux/module.h> 40 #include <linux/moduleparam.h> 41 #include <linux/hdreg.h> 42 #include <linux/io.h> 43 #include <linux/slab.h> 44 #include <asm/irq.h> 45 #include <asm/processor.h> 46 #include <linux/libata.h> 47 #include <linux/mutex.h> 48 #include <linux/ktime.h> 49 #include <scsi/scsi.h> 50 #include <scsi/scsi_host.h> 51 #include <scsi/scsi_device.h> 52 #include <scsi/scsi_tcq.h> 53 #include <scsi/scsi_eh.h> 54 #include <scsi/scsi_cmnd.h> 55 #include <scsi/scsicam.h> 56 57 #include "pmcraid.h" 58 59 /* 60 * Module configuration parameters 61 */ 62 static unsigned int pmcraid_debug_log; 63 static unsigned int pmcraid_disable_aen; 64 static unsigned int pmcraid_log_level = IOASC_LOG_LEVEL_MUST; 65 static unsigned int pmcraid_enable_msix; 66 67 /* 68 * Data structures to support multiple adapters by the LLD. 69 * pmcraid_adapter_count - count of configured adapters 70 */ 71 static atomic_t pmcraid_adapter_count = ATOMIC_INIT(0); 72 73 /* 74 * Supporting user-level control interface through IOCTL commands. 75 * pmcraid_major - major number to use 76 * pmcraid_minor - minor number(s) to use 77 */ 78 static unsigned int pmcraid_major; 79 static struct class *pmcraid_class; 80 static DECLARE_BITMAP(pmcraid_minor, PMCRAID_MAX_ADAPTERS); 81 82 /* 83 * Module parameters 84 */ 85 MODULE_AUTHOR("Anil Ravindranath<anil_ravindranath@pmc-sierra.com>"); 86 MODULE_DESCRIPTION("PMC Sierra MaxRAID Controller Driver"); 87 MODULE_LICENSE("GPL"); 88 MODULE_VERSION(PMCRAID_DRIVER_VERSION); 89 90 module_param_named(log_level, pmcraid_log_level, uint, (S_IRUGO | S_IWUSR)); 91 MODULE_PARM_DESC(log_level, 92 "Enables firmware error code logging, default :1 high-severity" 93 " errors, 2: all errors including high-severity errors," 94 " 0: disables logging"); 95 96 module_param_named(debug, pmcraid_debug_log, uint, (S_IRUGO | S_IWUSR)); 97 MODULE_PARM_DESC(debug, 98 "Enable driver verbose message logging. Set 1 to enable." 99 "(default: 0)"); 100 101 module_param_named(disable_aen, pmcraid_disable_aen, uint, (S_IRUGO | S_IWUSR)); 102 MODULE_PARM_DESC(disable_aen, 103 "Disable driver aen notifications to apps. Set 1 to disable." 104 "(default: 0)"); 105 106 /* chip specific constants for PMC MaxRAID controllers (same for 107 * 0x5220 and 0x8010 108 */ 109 static struct pmcraid_chip_details pmcraid_chip_cfg[] = { 110 { 111 .ioastatus = 0x0, 112 .ioarrin = 0x00040, 113 .mailbox = 0x7FC30, 114 .global_intr_mask = 0x00034, 115 .ioa_host_intr = 0x0009C, 116 .ioa_host_intr_clr = 0x000A0, 117 .ioa_host_msix_intr = 0x7FC40, 118 .ioa_host_mask = 0x7FC28, 119 .ioa_host_mask_clr = 0x7FC28, 120 .host_ioa_intr = 0x00020, 121 .host_ioa_intr_clr = 0x00020, 122 .transop_timeout = 300 123 } 124 }; 125 126 /* 127 * PCI device ids supported by pmcraid driver 128 */ 129 static struct pci_device_id pmcraid_pci_table[] = { 130 { PCI_DEVICE(PCI_VENDOR_ID_PMC, PCI_DEVICE_ID_PMC_MAXRAID), 131 0, 0, (kernel_ulong_t)&pmcraid_chip_cfg[0] 132 }, 133 {} 134 }; 135 136 MODULE_DEVICE_TABLE(pci, pmcraid_pci_table); 137 138 139 140 /** 141 * pmcraid_slave_alloc - Prepare for commands to a device 142 * @scsi_dev: scsi device struct 143 * 144 * This function is called by mid-layer prior to sending any command to the new 145 * device. Stores resource entry details of the device in scsi_device struct. 146 * Queuecommand uses the resource handle and other details to fill up IOARCB 147 * while sending commands to the device. 148 * 149 * Return value: 150 * 0 on success / -ENXIO if device does not exist 151 */ 152 static int pmcraid_slave_alloc(struct scsi_device *scsi_dev) 153 { 154 struct pmcraid_resource_entry *temp, *res = NULL; 155 struct pmcraid_instance *pinstance; 156 u8 target, bus, lun; 157 unsigned long lock_flags; 158 int rc = -ENXIO; 159 u16 fw_version; 160 161 pinstance = shost_priv(scsi_dev->host); 162 163 fw_version = be16_to_cpu(pinstance->inq_data->fw_version); 164 165 /* Driver exposes VSET and GSCSI resources only; all other device types 166 * are not exposed. Resource list is synchronized using resource lock 167 * so any traversal or modifications to the list should be done inside 168 * this lock 169 */ 170 spin_lock_irqsave(&pinstance->resource_lock, lock_flags); 171 list_for_each_entry(temp, &pinstance->used_res_q, queue) { 172 173 /* do not expose VSETs with order-ids > MAX_VSET_TARGETS */ 174 if (RES_IS_VSET(temp->cfg_entry)) { 175 if (fw_version <= PMCRAID_FW_VERSION_1) 176 target = temp->cfg_entry.unique_flags1; 177 else 178 target = le16_to_cpu(temp->cfg_entry.array_id) & 0xFF; 179 180 if (target > PMCRAID_MAX_VSET_TARGETS) 181 continue; 182 bus = PMCRAID_VSET_BUS_ID; 183 lun = 0; 184 } else if (RES_IS_GSCSI(temp->cfg_entry)) { 185 target = RES_TARGET(temp->cfg_entry.resource_address); 186 bus = PMCRAID_PHYS_BUS_ID; 187 lun = RES_LUN(temp->cfg_entry.resource_address); 188 } else { 189 continue; 190 } 191 192 if (bus == scsi_dev->channel && 193 target == scsi_dev->id && 194 lun == scsi_dev->lun) { 195 res = temp; 196 break; 197 } 198 } 199 200 if (res) { 201 res->scsi_dev = scsi_dev; 202 scsi_dev->hostdata = res; 203 res->change_detected = 0; 204 atomic_set(&res->read_failures, 0); 205 atomic_set(&res->write_failures, 0); 206 rc = 0; 207 } 208 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags); 209 return rc; 210 } 211 212 /** 213 * pmcraid_slave_configure - Configures a SCSI device 214 * @scsi_dev: scsi device struct 215 * 216 * This function is executed by SCSI mid layer just after a device is first 217 * scanned (i.e. it has responded to an INQUIRY). For VSET resources, the 218 * timeout value (default 30s) will be over-written to a higher value (60s) 219 * and max_sectors value will be over-written to 512. It also sets queue depth 220 * to host->cmd_per_lun value 221 * 222 * Return value: 223 * 0 on success 224 */ 225 static int pmcraid_slave_configure(struct scsi_device *scsi_dev) 226 { 227 struct pmcraid_resource_entry *res = scsi_dev->hostdata; 228 229 if (!res) 230 return 0; 231 232 /* LLD exposes VSETs and Enclosure devices only */ 233 if (RES_IS_GSCSI(res->cfg_entry) && 234 scsi_dev->type != TYPE_ENCLOSURE) 235 return -ENXIO; 236 237 pmcraid_info("configuring %x:%x:%x:%x\n", 238 scsi_dev->host->unique_id, 239 scsi_dev->channel, 240 scsi_dev->id, 241 (u8)scsi_dev->lun); 242 243 if (RES_IS_GSCSI(res->cfg_entry)) { 244 scsi_dev->allow_restart = 1; 245 } else if (RES_IS_VSET(res->cfg_entry)) { 246 scsi_dev->allow_restart = 1; 247 blk_queue_rq_timeout(scsi_dev->request_queue, 248 PMCRAID_VSET_IO_TIMEOUT); 249 blk_queue_max_hw_sectors(scsi_dev->request_queue, 250 PMCRAID_VSET_MAX_SECTORS); 251 } 252 253 /* 254 * We never want to report TCQ support for these types of devices. 255 */ 256 if (!RES_IS_GSCSI(res->cfg_entry) && !RES_IS_VSET(res->cfg_entry)) 257 scsi_dev->tagged_supported = 0; 258 259 return 0; 260 } 261 262 /** 263 * pmcraid_slave_destroy - Unconfigure a SCSI device before removing it 264 * 265 * @scsi_dev: scsi device struct 266 * 267 * This is called by mid-layer before removing a device. Pointer assignments 268 * done in pmcraid_slave_alloc will be reset to NULL here. 269 * 270 * Return value 271 * none 272 */ 273 static void pmcraid_slave_destroy(struct scsi_device *scsi_dev) 274 { 275 struct pmcraid_resource_entry *res; 276 277 res = (struct pmcraid_resource_entry *)scsi_dev->hostdata; 278 279 if (res) 280 res->scsi_dev = NULL; 281 282 scsi_dev->hostdata = NULL; 283 } 284 285 /** 286 * pmcraid_change_queue_depth - Change the device's queue depth 287 * @scsi_dev: scsi device struct 288 * @depth: depth to set 289 * 290 * Return value 291 * actual depth set 292 */ 293 static int pmcraid_change_queue_depth(struct scsi_device *scsi_dev, int depth) 294 { 295 if (depth > PMCRAID_MAX_CMD_PER_LUN) 296 depth = PMCRAID_MAX_CMD_PER_LUN; 297 return scsi_change_queue_depth(scsi_dev, depth); 298 } 299 300 /** 301 * pmcraid_init_cmdblk - initializes a command block 302 * 303 * @cmd: pointer to struct pmcraid_cmd to be initialized 304 * @index: if >=0 first time initialization; otherwise reinitialization 305 * 306 * Return Value 307 * None 308 */ 309 static void pmcraid_init_cmdblk(struct pmcraid_cmd *cmd, int index) 310 { 311 struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb); 312 dma_addr_t dma_addr = cmd->ioa_cb_bus_addr; 313 314 if (index >= 0) { 315 /* first time initialization (called from probe) */ 316 u32 ioasa_offset = 317 offsetof(struct pmcraid_control_block, ioasa); 318 319 cmd->index = index; 320 ioarcb->response_handle = cpu_to_le32(index << 2); 321 ioarcb->ioarcb_bus_addr = cpu_to_le64(dma_addr); 322 ioarcb->ioasa_bus_addr = cpu_to_le64(dma_addr + ioasa_offset); 323 ioarcb->ioasa_len = cpu_to_le16(sizeof(struct pmcraid_ioasa)); 324 } else { 325 /* re-initialization of various lengths, called once command is 326 * processed by IOA 327 */ 328 memset(&cmd->ioa_cb->ioarcb.cdb, 0, PMCRAID_MAX_CDB_LEN); 329 ioarcb->hrrq_id = 0; 330 ioarcb->request_flags0 = 0; 331 ioarcb->request_flags1 = 0; 332 ioarcb->cmd_timeout = 0; 333 ioarcb->ioarcb_bus_addr &= cpu_to_le64(~0x1FULL); 334 ioarcb->ioadl_bus_addr = 0; 335 ioarcb->ioadl_length = 0; 336 ioarcb->data_transfer_length = 0; 337 ioarcb->add_cmd_param_length = 0; 338 ioarcb->add_cmd_param_offset = 0; 339 cmd->ioa_cb->ioasa.ioasc = 0; 340 cmd->ioa_cb->ioasa.residual_data_length = 0; 341 cmd->time_left = 0; 342 } 343 344 cmd->cmd_done = NULL; 345 cmd->scsi_cmd = NULL; 346 cmd->release = 0; 347 cmd->completion_req = 0; 348 cmd->sense_buffer = NULL; 349 cmd->sense_buffer_dma = 0; 350 cmd->dma_handle = 0; 351 init_timer(&cmd->timer); 352 } 353 354 /** 355 * pmcraid_reinit_cmdblk - reinitialize a command block 356 * 357 * @cmd: pointer to struct pmcraid_cmd to be reinitialized 358 * 359 * Return Value 360 * None 361 */ 362 static void pmcraid_reinit_cmdblk(struct pmcraid_cmd *cmd) 363 { 364 pmcraid_init_cmdblk(cmd, -1); 365 } 366 367 /** 368 * pmcraid_get_free_cmd - get a free cmd block from command block pool 369 * @pinstance: adapter instance structure 370 * 371 * Return Value: 372 * returns pointer to cmd block or NULL if no blocks are available 373 */ 374 static struct pmcraid_cmd *pmcraid_get_free_cmd( 375 struct pmcraid_instance *pinstance 376 ) 377 { 378 struct pmcraid_cmd *cmd = NULL; 379 unsigned long lock_flags; 380 381 /* free cmd block list is protected by free_pool_lock */ 382 spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags); 383 384 if (!list_empty(&pinstance->free_cmd_pool)) { 385 cmd = list_entry(pinstance->free_cmd_pool.next, 386 struct pmcraid_cmd, free_list); 387 list_del(&cmd->free_list); 388 } 389 spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags); 390 391 /* Initialize the command block before giving it the caller */ 392 if (cmd != NULL) 393 pmcraid_reinit_cmdblk(cmd); 394 return cmd; 395 } 396 397 /** 398 * pmcraid_return_cmd - return a completed command block back into free pool 399 * @cmd: pointer to the command block 400 * 401 * Return Value: 402 * nothing 403 */ 404 static void pmcraid_return_cmd(struct pmcraid_cmd *cmd) 405 { 406 struct pmcraid_instance *pinstance = cmd->drv_inst; 407 unsigned long lock_flags; 408 409 spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags); 410 list_add_tail(&cmd->free_list, &pinstance->free_cmd_pool); 411 spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags); 412 } 413 414 /** 415 * pmcraid_read_interrupts - reads IOA interrupts 416 * 417 * @pinstance: pointer to adapter instance structure 418 * 419 * Return value 420 * interrupts read from IOA 421 */ 422 static u32 pmcraid_read_interrupts(struct pmcraid_instance *pinstance) 423 { 424 return (pinstance->interrupt_mode) ? 425 ioread32(pinstance->int_regs.ioa_host_msix_interrupt_reg) : 426 ioread32(pinstance->int_regs.ioa_host_interrupt_reg); 427 } 428 429 /** 430 * pmcraid_disable_interrupts - Masks and clears all specified interrupts 431 * 432 * @pinstance: pointer to per adapter instance structure 433 * @intrs: interrupts to disable 434 * 435 * Return Value 436 * None 437 */ 438 static void pmcraid_disable_interrupts( 439 struct pmcraid_instance *pinstance, 440 u32 intrs 441 ) 442 { 443 u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg); 444 u32 nmask = gmask | GLOBAL_INTERRUPT_MASK; 445 446 iowrite32(intrs, pinstance->int_regs.ioa_host_interrupt_clr_reg); 447 iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg); 448 ioread32(pinstance->int_regs.global_interrupt_mask_reg); 449 450 if (!pinstance->interrupt_mode) { 451 iowrite32(intrs, 452 pinstance->int_regs.ioa_host_interrupt_mask_reg); 453 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg); 454 } 455 } 456 457 /** 458 * pmcraid_enable_interrupts - Enables specified interrupts 459 * 460 * @pinstance: pointer to per adapter instance structure 461 * @intr: interrupts to enable 462 * 463 * Return Value 464 * None 465 */ 466 static void pmcraid_enable_interrupts( 467 struct pmcraid_instance *pinstance, 468 u32 intrs 469 ) 470 { 471 u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg); 472 u32 nmask = gmask & (~GLOBAL_INTERRUPT_MASK); 473 474 iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg); 475 476 if (!pinstance->interrupt_mode) { 477 iowrite32(~intrs, 478 pinstance->int_regs.ioa_host_interrupt_mask_reg); 479 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg); 480 } 481 482 pmcraid_info("enabled interrupts global mask = %x intr_mask = %x\n", 483 ioread32(pinstance->int_regs.global_interrupt_mask_reg), 484 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg)); 485 } 486 487 /** 488 * pmcraid_clr_trans_op - clear trans to op interrupt 489 * 490 * @pinstance: pointer to per adapter instance structure 491 * 492 * Return Value 493 * None 494 */ 495 static void pmcraid_clr_trans_op( 496 struct pmcraid_instance *pinstance 497 ) 498 { 499 unsigned long lock_flags; 500 501 if (!pinstance->interrupt_mode) { 502 iowrite32(INTRS_TRANSITION_TO_OPERATIONAL, 503 pinstance->int_regs.ioa_host_interrupt_mask_reg); 504 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg); 505 iowrite32(INTRS_TRANSITION_TO_OPERATIONAL, 506 pinstance->int_regs.ioa_host_interrupt_clr_reg); 507 ioread32(pinstance->int_regs.ioa_host_interrupt_clr_reg); 508 } 509 510 if (pinstance->reset_cmd != NULL) { 511 del_timer(&pinstance->reset_cmd->timer); 512 spin_lock_irqsave( 513 pinstance->host->host_lock, lock_flags); 514 pinstance->reset_cmd->cmd_done(pinstance->reset_cmd); 515 spin_unlock_irqrestore( 516 pinstance->host->host_lock, lock_flags); 517 } 518 } 519 520 /** 521 * pmcraid_reset_type - Determine the required reset type 522 * @pinstance: pointer to adapter instance structure 523 * 524 * IOA requires hard reset if any of the following conditions is true. 525 * 1. If HRRQ valid interrupt is not masked 526 * 2. IOA reset alert doorbell is set 527 * 3. If there are any error interrupts 528 */ 529 static void pmcraid_reset_type(struct pmcraid_instance *pinstance) 530 { 531 u32 mask; 532 u32 intrs; 533 u32 alerts; 534 535 mask = ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg); 536 intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg); 537 alerts = ioread32(pinstance->int_regs.host_ioa_interrupt_reg); 538 539 if ((mask & INTRS_HRRQ_VALID) == 0 || 540 (alerts & DOORBELL_IOA_RESET_ALERT) || 541 (intrs & PMCRAID_ERROR_INTERRUPTS)) { 542 pmcraid_info("IOA requires hard reset\n"); 543 pinstance->ioa_hard_reset = 1; 544 } 545 546 /* If unit check is active, trigger the dump */ 547 if (intrs & INTRS_IOA_UNIT_CHECK) 548 pinstance->ioa_unit_check = 1; 549 } 550 551 /** 552 * pmcraid_bist_done - completion function for PCI BIST 553 * @cmd: pointer to reset command 554 * Return Value 555 * none 556 */ 557 558 static void pmcraid_ioa_reset(struct pmcraid_cmd *); 559 560 static void pmcraid_bist_done(struct pmcraid_cmd *cmd) 561 { 562 struct pmcraid_instance *pinstance = cmd->drv_inst; 563 unsigned long lock_flags; 564 int rc; 565 u16 pci_reg; 566 567 rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg); 568 569 /* If PCI config space can't be accessed wait for another two secs */ 570 if ((rc != PCIBIOS_SUCCESSFUL || (!(pci_reg & PCI_COMMAND_MEMORY))) && 571 cmd->time_left > 0) { 572 pmcraid_info("BIST not complete, waiting another 2 secs\n"); 573 cmd->timer.expires = jiffies + cmd->time_left; 574 cmd->time_left = 0; 575 cmd->timer.data = (unsigned long)cmd; 576 cmd->timer.function = 577 (void (*)(unsigned long))pmcraid_bist_done; 578 add_timer(&cmd->timer); 579 } else { 580 cmd->time_left = 0; 581 pmcraid_info("BIST is complete, proceeding with reset\n"); 582 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 583 pmcraid_ioa_reset(cmd); 584 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 585 } 586 } 587 588 /** 589 * pmcraid_start_bist - starts BIST 590 * @cmd: pointer to reset cmd 591 * Return Value 592 * none 593 */ 594 static void pmcraid_start_bist(struct pmcraid_cmd *cmd) 595 { 596 struct pmcraid_instance *pinstance = cmd->drv_inst; 597 u32 doorbells, intrs; 598 599 /* proceed with bist and wait for 2 seconds */ 600 iowrite32(DOORBELL_IOA_START_BIST, 601 pinstance->int_regs.host_ioa_interrupt_reg); 602 doorbells = ioread32(pinstance->int_regs.host_ioa_interrupt_reg); 603 intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg); 604 pmcraid_info("doorbells after start bist: %x intrs: %x\n", 605 doorbells, intrs); 606 607 cmd->time_left = msecs_to_jiffies(PMCRAID_BIST_TIMEOUT); 608 cmd->timer.data = (unsigned long)cmd; 609 cmd->timer.expires = jiffies + msecs_to_jiffies(PMCRAID_BIST_TIMEOUT); 610 cmd->timer.function = (void (*)(unsigned long))pmcraid_bist_done; 611 add_timer(&cmd->timer); 612 } 613 614 /** 615 * pmcraid_reset_alert_done - completion routine for reset_alert 616 * @cmd: pointer to command block used in reset sequence 617 * Return value 618 * None 619 */ 620 static void pmcraid_reset_alert_done(struct pmcraid_cmd *cmd) 621 { 622 struct pmcraid_instance *pinstance = cmd->drv_inst; 623 u32 status = ioread32(pinstance->ioa_status); 624 unsigned long lock_flags; 625 626 /* if the critical operation in progress bit is set or the wait times 627 * out, invoke reset engine to proceed with hard reset. If there is 628 * some more time to wait, restart the timer 629 */ 630 if (((status & INTRS_CRITICAL_OP_IN_PROGRESS) == 0) || 631 cmd->time_left <= 0) { 632 pmcraid_info("critical op is reset proceeding with reset\n"); 633 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 634 pmcraid_ioa_reset(cmd); 635 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 636 } else { 637 pmcraid_info("critical op is not yet reset waiting again\n"); 638 /* restart timer if some more time is available to wait */ 639 cmd->time_left -= PMCRAID_CHECK_FOR_RESET_TIMEOUT; 640 cmd->timer.data = (unsigned long)cmd; 641 cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT; 642 cmd->timer.function = 643 (void (*)(unsigned long))pmcraid_reset_alert_done; 644 add_timer(&cmd->timer); 645 } 646 } 647 648 /** 649 * pmcraid_reset_alert - alerts IOA for a possible reset 650 * @cmd : command block to be used for reset sequence. 651 * 652 * Return Value 653 * returns 0 if pci config-space is accessible and RESET_DOORBELL is 654 * successfully written to IOA. Returns non-zero in case pci_config_space 655 * is not accessible 656 */ 657 static void pmcraid_notify_ioastate(struct pmcraid_instance *, u32); 658 static void pmcraid_reset_alert(struct pmcraid_cmd *cmd) 659 { 660 struct pmcraid_instance *pinstance = cmd->drv_inst; 661 u32 doorbells; 662 int rc; 663 u16 pci_reg; 664 665 /* If we are able to access IOA PCI config space, alert IOA that we are 666 * going to reset it soon. This enables IOA to preserv persistent error 667 * data if any. In case memory space is not accessible, proceed with 668 * BIST or slot_reset 669 */ 670 rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg); 671 if ((rc == PCIBIOS_SUCCESSFUL) && (pci_reg & PCI_COMMAND_MEMORY)) { 672 673 /* wait for IOA permission i.e until CRITICAL_OPERATION bit is 674 * reset IOA doesn't generate any interrupts when CRITICAL 675 * OPERATION bit is reset. A timer is started to wait for this 676 * bit to be reset. 677 */ 678 cmd->time_left = PMCRAID_RESET_TIMEOUT; 679 cmd->timer.data = (unsigned long)cmd; 680 cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT; 681 cmd->timer.function = 682 (void (*)(unsigned long))pmcraid_reset_alert_done; 683 add_timer(&cmd->timer); 684 685 iowrite32(DOORBELL_IOA_RESET_ALERT, 686 pinstance->int_regs.host_ioa_interrupt_reg); 687 doorbells = 688 ioread32(pinstance->int_regs.host_ioa_interrupt_reg); 689 pmcraid_info("doorbells after reset alert: %x\n", doorbells); 690 } else { 691 pmcraid_info("PCI config is not accessible starting BIST\n"); 692 pinstance->ioa_state = IOA_STATE_IN_HARD_RESET; 693 pmcraid_start_bist(cmd); 694 } 695 } 696 697 /** 698 * pmcraid_timeout_handler - Timeout handler for internally generated ops 699 * 700 * @cmd : pointer to command structure, that got timedout 701 * 702 * This function blocks host requests and initiates an adapter reset. 703 * 704 * Return value: 705 * None 706 */ 707 static void pmcraid_timeout_handler(struct pmcraid_cmd *cmd) 708 { 709 struct pmcraid_instance *pinstance = cmd->drv_inst; 710 unsigned long lock_flags; 711 712 dev_info(&pinstance->pdev->dev, 713 "Adapter being reset due to cmd(CDB[0] = %x) timeout\n", 714 cmd->ioa_cb->ioarcb.cdb[0]); 715 716 /* Command timeouts result in hard reset sequence. The command that got 717 * timed out may be the one used as part of reset sequence. In this 718 * case restart reset sequence using the same command block even if 719 * reset is in progress. Otherwise fail this command and get a free 720 * command block to restart the reset sequence. 721 */ 722 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 723 if (!pinstance->ioa_reset_in_progress) { 724 pinstance->ioa_reset_attempts = 0; 725 cmd = pmcraid_get_free_cmd(pinstance); 726 727 /* If we are out of command blocks, just return here itself. 728 * Some other command's timeout handler can do the reset job 729 */ 730 if (cmd == NULL) { 731 spin_unlock_irqrestore(pinstance->host->host_lock, 732 lock_flags); 733 pmcraid_err("no free cmnd block for timeout handler\n"); 734 return; 735 } 736 737 pinstance->reset_cmd = cmd; 738 pinstance->ioa_reset_in_progress = 1; 739 } else { 740 pmcraid_info("reset is already in progress\n"); 741 742 if (pinstance->reset_cmd != cmd) { 743 /* This command should have been given to IOA, this 744 * command will be completed by fail_outstanding_cmds 745 * anyway 746 */ 747 pmcraid_err("cmd is pending but reset in progress\n"); 748 } 749 750 /* If this command was being used as part of the reset 751 * sequence, set cmd_done pointer to pmcraid_ioa_reset. This 752 * causes fail_outstanding_commands not to return the command 753 * block back to free pool 754 */ 755 if (cmd == pinstance->reset_cmd) 756 cmd->cmd_done = pmcraid_ioa_reset; 757 } 758 759 /* Notify apps of important IOA bringup/bringdown sequences */ 760 if (pinstance->scn.ioa_state != PMC_DEVICE_EVENT_RESET_START && 761 pinstance->scn.ioa_state != PMC_DEVICE_EVENT_SHUTDOWN_START) 762 pmcraid_notify_ioastate(pinstance, 763 PMC_DEVICE_EVENT_RESET_START); 764 765 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT; 766 scsi_block_requests(pinstance->host); 767 pmcraid_reset_alert(cmd); 768 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 769 } 770 771 /** 772 * pmcraid_internal_done - completion routine for internally generated cmds 773 * 774 * @cmd: command that got response from IOA 775 * 776 * Return Value: 777 * none 778 */ 779 static void pmcraid_internal_done(struct pmcraid_cmd *cmd) 780 { 781 pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n", 782 cmd->ioa_cb->ioarcb.cdb[0], 783 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc)); 784 785 /* Some of the internal commands are sent with callers blocking for the 786 * response. Same will be indicated as part of cmd->completion_req 787 * field. Response path needs to wake up any waiters waiting for cmd 788 * completion if this flag is set. 789 */ 790 if (cmd->completion_req) { 791 cmd->completion_req = 0; 792 complete(&cmd->wait_for_completion); 793 } 794 795 /* most of the internal commands are completed by caller itself, so 796 * no need to return the command block back to free pool until we are 797 * required to do so (e.g once done with initialization). 798 */ 799 if (cmd->release) { 800 cmd->release = 0; 801 pmcraid_return_cmd(cmd); 802 } 803 } 804 805 /** 806 * pmcraid_reinit_cfgtable_done - done function for cfg table reinitialization 807 * 808 * @cmd: command that got response from IOA 809 * 810 * This routine is called after driver re-reads configuration table due to a 811 * lost CCN. It returns the command block back to free pool and schedules 812 * worker thread to add/delete devices into the system. 813 * 814 * Return Value: 815 * none 816 */ 817 static void pmcraid_reinit_cfgtable_done(struct pmcraid_cmd *cmd) 818 { 819 pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n", 820 cmd->ioa_cb->ioarcb.cdb[0], 821 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc)); 822 823 if (cmd->release) { 824 cmd->release = 0; 825 pmcraid_return_cmd(cmd); 826 } 827 pmcraid_info("scheduling worker for config table reinitialization\n"); 828 schedule_work(&cmd->drv_inst->worker_q); 829 } 830 831 /** 832 * pmcraid_erp_done - Process completion of SCSI error response from device 833 * @cmd: pmcraid_command 834 * 835 * This function copies the sense buffer into the scsi_cmd struct and completes 836 * scsi_cmd by calling scsi_done function. 837 * 838 * Return value: 839 * none 840 */ 841 static void pmcraid_erp_done(struct pmcraid_cmd *cmd) 842 { 843 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd; 844 struct pmcraid_instance *pinstance = cmd->drv_inst; 845 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc); 846 847 if (PMCRAID_IOASC_SENSE_KEY(ioasc) > 0) { 848 scsi_cmd->result |= (DID_ERROR << 16); 849 scmd_printk(KERN_INFO, scsi_cmd, 850 "command CDB[0] = %x failed with IOASC: 0x%08X\n", 851 cmd->ioa_cb->ioarcb.cdb[0], ioasc); 852 } 853 854 /* if we had allocated sense buffers for request sense, copy the sense 855 * release the buffers 856 */ 857 if (cmd->sense_buffer != NULL) { 858 memcpy(scsi_cmd->sense_buffer, 859 cmd->sense_buffer, 860 SCSI_SENSE_BUFFERSIZE); 861 pci_free_consistent(pinstance->pdev, 862 SCSI_SENSE_BUFFERSIZE, 863 cmd->sense_buffer, cmd->sense_buffer_dma); 864 cmd->sense_buffer = NULL; 865 cmd->sense_buffer_dma = 0; 866 } 867 868 scsi_dma_unmap(scsi_cmd); 869 pmcraid_return_cmd(cmd); 870 scsi_cmd->scsi_done(scsi_cmd); 871 } 872 873 /** 874 * pmcraid_fire_command - sends an IOA command to adapter 875 * 876 * This function adds the given block into pending command list 877 * and returns without waiting 878 * 879 * @cmd : command to be sent to the device 880 * 881 * Return Value 882 * None 883 */ 884 static void _pmcraid_fire_command(struct pmcraid_cmd *cmd) 885 { 886 struct pmcraid_instance *pinstance = cmd->drv_inst; 887 unsigned long lock_flags; 888 889 /* Add this command block to pending cmd pool. We do this prior to 890 * writting IOARCB to ioarrin because IOA might complete the command 891 * by the time we are about to add it to the list. Response handler 892 * (isr/tasklet) looks for cmd block in the pending pending list. 893 */ 894 spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags); 895 list_add_tail(&cmd->free_list, &pinstance->pending_cmd_pool); 896 spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags); 897 atomic_inc(&pinstance->outstanding_cmds); 898 899 /* driver writes lower 32-bit value of IOARCB address only */ 900 mb(); 901 iowrite32(le64_to_cpu(cmd->ioa_cb->ioarcb.ioarcb_bus_addr), pinstance->ioarrin); 902 } 903 904 /** 905 * pmcraid_send_cmd - fires a command to IOA 906 * 907 * This function also sets up timeout function, and command completion 908 * function 909 * 910 * @cmd: pointer to the command block to be fired to IOA 911 * @cmd_done: command completion function, called once IOA responds 912 * @timeout: timeout to wait for this command completion 913 * @timeout_func: timeout handler 914 * 915 * Return value 916 * none 917 */ 918 static void pmcraid_send_cmd( 919 struct pmcraid_cmd *cmd, 920 void (*cmd_done) (struct pmcraid_cmd *), 921 unsigned long timeout, 922 void (*timeout_func) (struct pmcraid_cmd *) 923 ) 924 { 925 /* initialize done function */ 926 cmd->cmd_done = cmd_done; 927 928 if (timeout_func) { 929 /* setup timeout handler */ 930 cmd->timer.data = (unsigned long)cmd; 931 cmd->timer.expires = jiffies + timeout; 932 cmd->timer.function = (void (*)(unsigned long))timeout_func; 933 add_timer(&cmd->timer); 934 } 935 936 /* fire the command to IOA */ 937 _pmcraid_fire_command(cmd); 938 } 939 940 /** 941 * pmcraid_ioa_shutdown_done - completion function for IOA shutdown command 942 * @cmd: pointer to the command block used for sending IOA shutdown command 943 * 944 * Return value 945 * None 946 */ 947 static void pmcraid_ioa_shutdown_done(struct pmcraid_cmd *cmd) 948 { 949 struct pmcraid_instance *pinstance = cmd->drv_inst; 950 unsigned long lock_flags; 951 952 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 953 pmcraid_ioa_reset(cmd); 954 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 955 } 956 957 /** 958 * pmcraid_ioa_shutdown - sends SHUTDOWN command to ioa 959 * 960 * @cmd: pointer to the command block used as part of reset sequence 961 * 962 * Return Value 963 * None 964 */ 965 static void pmcraid_ioa_shutdown(struct pmcraid_cmd *cmd) 966 { 967 pmcraid_info("response for Cancel CCN CDB[0] = %x ioasc = %x\n", 968 cmd->ioa_cb->ioarcb.cdb[0], 969 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc)); 970 971 /* Note that commands sent during reset require next command to be sent 972 * to IOA. Hence reinit the done function as well as timeout function 973 */ 974 pmcraid_reinit_cmdblk(cmd); 975 cmd->ioa_cb->ioarcb.request_type = REQ_TYPE_IOACMD; 976 cmd->ioa_cb->ioarcb.resource_handle = 977 cpu_to_le32(PMCRAID_IOA_RES_HANDLE); 978 cmd->ioa_cb->ioarcb.cdb[0] = PMCRAID_IOA_SHUTDOWN; 979 cmd->ioa_cb->ioarcb.cdb[1] = PMCRAID_SHUTDOWN_NORMAL; 980 981 /* fire shutdown command to hardware. */ 982 pmcraid_info("firing normal shutdown command (%d) to IOA\n", 983 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle)); 984 985 pmcraid_notify_ioastate(cmd->drv_inst, PMC_DEVICE_EVENT_SHUTDOWN_START); 986 987 pmcraid_send_cmd(cmd, pmcraid_ioa_shutdown_done, 988 PMCRAID_SHUTDOWN_TIMEOUT, 989 pmcraid_timeout_handler); 990 } 991 992 /** 993 * pmcraid_get_fwversion_done - completion function for get_fwversion 994 * 995 * @cmd: pointer to command block used to send INQUIRY command 996 * 997 * Return Value 998 * none 999 */ 1000 static void pmcraid_querycfg(struct pmcraid_cmd *); 1001 1002 static void pmcraid_get_fwversion_done(struct pmcraid_cmd *cmd) 1003 { 1004 struct pmcraid_instance *pinstance = cmd->drv_inst; 1005 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc); 1006 unsigned long lock_flags; 1007 1008 /* configuration table entry size depends on firmware version. If fw 1009 * version is not known, it is not possible to interpret IOA config 1010 * table 1011 */ 1012 if (ioasc) { 1013 pmcraid_err("IOA Inquiry failed with %x\n", ioasc); 1014 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 1015 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT; 1016 pmcraid_reset_alert(cmd); 1017 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 1018 } else { 1019 pmcraid_querycfg(cmd); 1020 } 1021 } 1022 1023 /** 1024 * pmcraid_get_fwversion - reads firmware version information 1025 * 1026 * @cmd: pointer to command block used to send INQUIRY command 1027 * 1028 * Return Value 1029 * none 1030 */ 1031 static void pmcraid_get_fwversion(struct pmcraid_cmd *cmd) 1032 { 1033 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 1034 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl; 1035 struct pmcraid_instance *pinstance = cmd->drv_inst; 1036 u16 data_size = sizeof(struct pmcraid_inquiry_data); 1037 1038 pmcraid_reinit_cmdblk(cmd); 1039 ioarcb->request_type = REQ_TYPE_SCSI; 1040 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE); 1041 ioarcb->cdb[0] = INQUIRY; 1042 ioarcb->cdb[1] = 1; 1043 ioarcb->cdb[2] = 0xD0; 1044 ioarcb->cdb[3] = (data_size >> 8) & 0xFF; 1045 ioarcb->cdb[4] = data_size & 0xFF; 1046 1047 /* Since entire inquiry data it can be part of IOARCB itself 1048 */ 1049 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) + 1050 offsetof(struct pmcraid_ioarcb, 1051 add_data.u.ioadl[0])); 1052 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc)); 1053 ioarcb->ioarcb_bus_addr &= cpu_to_le64(~(0x1FULL)); 1054 1055 ioarcb->request_flags0 |= NO_LINK_DESCS; 1056 ioarcb->data_transfer_length = cpu_to_le32(data_size); 1057 ioadl = &(ioarcb->add_data.u.ioadl[0]); 1058 ioadl->flags = IOADL_FLAGS_LAST_DESC; 1059 ioadl->address = cpu_to_le64(pinstance->inq_data_baddr); 1060 ioadl->data_len = cpu_to_le32(data_size); 1061 1062 pmcraid_send_cmd(cmd, pmcraid_get_fwversion_done, 1063 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler); 1064 } 1065 1066 /** 1067 * pmcraid_identify_hrrq - registers host rrq buffers with IOA 1068 * @cmd: pointer to command block to be used for identify hrrq 1069 * 1070 * Return Value 1071 * none 1072 */ 1073 static void pmcraid_identify_hrrq(struct pmcraid_cmd *cmd) 1074 { 1075 struct pmcraid_instance *pinstance = cmd->drv_inst; 1076 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 1077 int index = cmd->hrrq_index; 1078 __be64 hrrq_addr = cpu_to_be64(pinstance->hrrq_start_bus_addr[index]); 1079 __be32 hrrq_size = cpu_to_be32(sizeof(u32) * PMCRAID_MAX_CMD); 1080 void (*done_function)(struct pmcraid_cmd *); 1081 1082 pmcraid_reinit_cmdblk(cmd); 1083 cmd->hrrq_index = index + 1; 1084 1085 if (cmd->hrrq_index < pinstance->num_hrrq) { 1086 done_function = pmcraid_identify_hrrq; 1087 } else { 1088 cmd->hrrq_index = 0; 1089 done_function = pmcraid_get_fwversion; 1090 } 1091 1092 /* Initialize ioarcb */ 1093 ioarcb->request_type = REQ_TYPE_IOACMD; 1094 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE); 1095 1096 /* initialize the hrrq number where IOA will respond to this command */ 1097 ioarcb->hrrq_id = index; 1098 ioarcb->cdb[0] = PMCRAID_IDENTIFY_HRRQ; 1099 ioarcb->cdb[1] = index; 1100 1101 /* IOA expects 64-bit pci address to be written in B.E format 1102 * (i.e cdb[2]=MSByte..cdb[9]=LSB. 1103 */ 1104 pmcraid_info("HRRQ_IDENTIFY with hrrq:ioarcb:index => %llx:%llx:%x\n", 1105 hrrq_addr, ioarcb->ioarcb_bus_addr, index); 1106 1107 memcpy(&(ioarcb->cdb[2]), &hrrq_addr, sizeof(hrrq_addr)); 1108 memcpy(&(ioarcb->cdb[10]), &hrrq_size, sizeof(hrrq_size)); 1109 1110 /* Subsequent commands require HRRQ identification to be successful. 1111 * Note that this gets called even during reset from SCSI mid-layer 1112 * or tasklet 1113 */ 1114 pmcraid_send_cmd(cmd, done_function, 1115 PMCRAID_INTERNAL_TIMEOUT, 1116 pmcraid_timeout_handler); 1117 } 1118 1119 static void pmcraid_process_ccn(struct pmcraid_cmd *cmd); 1120 static void pmcraid_process_ldn(struct pmcraid_cmd *cmd); 1121 1122 /** 1123 * pmcraid_send_hcam_cmd - send an initialized command block(HCAM) to IOA 1124 * 1125 * @cmd: initialized command block pointer 1126 * 1127 * Return Value 1128 * none 1129 */ 1130 static void pmcraid_send_hcam_cmd(struct pmcraid_cmd *cmd) 1131 { 1132 if (cmd->ioa_cb->ioarcb.cdb[1] == PMCRAID_HCAM_CODE_CONFIG_CHANGE) 1133 atomic_set(&(cmd->drv_inst->ccn.ignore), 0); 1134 else 1135 atomic_set(&(cmd->drv_inst->ldn.ignore), 0); 1136 1137 pmcraid_send_cmd(cmd, cmd->cmd_done, 0, NULL); 1138 } 1139 1140 /** 1141 * pmcraid_init_hcam - send an initialized command block(HCAM) to IOA 1142 * 1143 * @pinstance: pointer to adapter instance structure 1144 * @type: HCAM type 1145 * 1146 * Return Value 1147 * pointer to initialized pmcraid_cmd structure or NULL 1148 */ 1149 static struct pmcraid_cmd *pmcraid_init_hcam 1150 ( 1151 struct pmcraid_instance *pinstance, 1152 u8 type 1153 ) 1154 { 1155 struct pmcraid_cmd *cmd; 1156 struct pmcraid_ioarcb *ioarcb; 1157 struct pmcraid_ioadl_desc *ioadl; 1158 struct pmcraid_hostrcb *hcam; 1159 void (*cmd_done) (struct pmcraid_cmd *); 1160 dma_addr_t dma; 1161 int rcb_size; 1162 1163 cmd = pmcraid_get_free_cmd(pinstance); 1164 1165 if (!cmd) { 1166 pmcraid_err("no free command blocks for hcam\n"); 1167 return cmd; 1168 } 1169 1170 if (type == PMCRAID_HCAM_CODE_CONFIG_CHANGE) { 1171 rcb_size = sizeof(struct pmcraid_hcam_ccn_ext); 1172 cmd_done = pmcraid_process_ccn; 1173 dma = pinstance->ccn.baddr + PMCRAID_AEN_HDR_SIZE; 1174 hcam = &pinstance->ccn; 1175 } else { 1176 rcb_size = sizeof(struct pmcraid_hcam_ldn); 1177 cmd_done = pmcraid_process_ldn; 1178 dma = pinstance->ldn.baddr + PMCRAID_AEN_HDR_SIZE; 1179 hcam = &pinstance->ldn; 1180 } 1181 1182 /* initialize command pointer used for HCAM registration */ 1183 hcam->cmd = cmd; 1184 1185 ioarcb = &cmd->ioa_cb->ioarcb; 1186 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) + 1187 offsetof(struct pmcraid_ioarcb, 1188 add_data.u.ioadl[0])); 1189 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc)); 1190 ioadl = ioarcb->add_data.u.ioadl; 1191 1192 /* Initialize ioarcb */ 1193 ioarcb->request_type = REQ_TYPE_HCAM; 1194 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE); 1195 ioarcb->cdb[0] = PMCRAID_HOST_CONTROLLED_ASYNC; 1196 ioarcb->cdb[1] = type; 1197 ioarcb->cdb[7] = (rcb_size >> 8) & 0xFF; 1198 ioarcb->cdb[8] = (rcb_size) & 0xFF; 1199 1200 ioarcb->data_transfer_length = cpu_to_le32(rcb_size); 1201 1202 ioadl[0].flags |= IOADL_FLAGS_READ_LAST; 1203 ioadl[0].data_len = cpu_to_le32(rcb_size); 1204 ioadl[0].address = cpu_to_le64(dma); 1205 1206 cmd->cmd_done = cmd_done; 1207 return cmd; 1208 } 1209 1210 /** 1211 * pmcraid_send_hcam - Send an HCAM to IOA 1212 * @pinstance: ioa config struct 1213 * @type: HCAM type 1214 * 1215 * This function will send a Host Controlled Async command to IOA. 1216 * 1217 * Return value: 1218 * none 1219 */ 1220 static void pmcraid_send_hcam(struct pmcraid_instance *pinstance, u8 type) 1221 { 1222 struct pmcraid_cmd *cmd = pmcraid_init_hcam(pinstance, type); 1223 pmcraid_send_hcam_cmd(cmd); 1224 } 1225 1226 1227 /** 1228 * pmcraid_prepare_cancel_cmd - prepares a command block to abort another 1229 * 1230 * @cmd: pointer to cmd that is used as cancelling command 1231 * @cmd_to_cancel: pointer to the command that needs to be cancelled 1232 */ 1233 static void pmcraid_prepare_cancel_cmd( 1234 struct pmcraid_cmd *cmd, 1235 struct pmcraid_cmd *cmd_to_cancel 1236 ) 1237 { 1238 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 1239 __be64 ioarcb_addr; 1240 1241 /* IOARCB address of the command to be cancelled is given in 1242 * cdb[2]..cdb[9] is Big-Endian format. Note that length bits in 1243 * IOARCB address are not masked. 1244 */ 1245 ioarcb_addr = cpu_to_be64(le64_to_cpu(cmd_to_cancel->ioa_cb->ioarcb.ioarcb_bus_addr)); 1246 1247 /* Get the resource handle to where the command to be aborted has been 1248 * sent. 1249 */ 1250 ioarcb->resource_handle = cmd_to_cancel->ioa_cb->ioarcb.resource_handle; 1251 ioarcb->request_type = REQ_TYPE_IOACMD; 1252 memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN); 1253 ioarcb->cdb[0] = PMCRAID_ABORT_CMD; 1254 1255 memcpy(&(ioarcb->cdb[2]), &ioarcb_addr, sizeof(ioarcb_addr)); 1256 } 1257 1258 /** 1259 * pmcraid_cancel_hcam - sends ABORT task to abort a given HCAM 1260 * 1261 * @cmd: command to be used as cancelling command 1262 * @type: HCAM type 1263 * @cmd_done: op done function for the cancelling command 1264 */ 1265 static void pmcraid_cancel_hcam( 1266 struct pmcraid_cmd *cmd, 1267 u8 type, 1268 void (*cmd_done) (struct pmcraid_cmd *) 1269 ) 1270 { 1271 struct pmcraid_instance *pinstance; 1272 struct pmcraid_hostrcb *hcam; 1273 1274 pinstance = cmd->drv_inst; 1275 hcam = (type == PMCRAID_HCAM_CODE_LOG_DATA) ? 1276 &pinstance->ldn : &pinstance->ccn; 1277 1278 /* prepare for cancelling previous hcam command. If the HCAM is 1279 * currently not pending with IOA, we would have hcam->cmd as non-null 1280 */ 1281 if (hcam->cmd == NULL) 1282 return; 1283 1284 pmcraid_prepare_cancel_cmd(cmd, hcam->cmd); 1285 1286 /* writing to IOARRIN must be protected by host_lock, as mid-layer 1287 * schedule queuecommand while we are doing this 1288 */ 1289 pmcraid_send_cmd(cmd, cmd_done, 1290 PMCRAID_INTERNAL_TIMEOUT, 1291 pmcraid_timeout_handler); 1292 } 1293 1294 /** 1295 * pmcraid_cancel_ccn - cancel CCN HCAM already registered with IOA 1296 * 1297 * @cmd: command block to be used for cancelling the HCAM 1298 */ 1299 static void pmcraid_cancel_ccn(struct pmcraid_cmd *cmd) 1300 { 1301 pmcraid_info("response for Cancel LDN CDB[0] = %x ioasc = %x\n", 1302 cmd->ioa_cb->ioarcb.cdb[0], 1303 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc)); 1304 1305 pmcraid_reinit_cmdblk(cmd); 1306 1307 pmcraid_cancel_hcam(cmd, 1308 PMCRAID_HCAM_CODE_CONFIG_CHANGE, 1309 pmcraid_ioa_shutdown); 1310 } 1311 1312 /** 1313 * pmcraid_cancel_ldn - cancel LDN HCAM already registered with IOA 1314 * 1315 * @cmd: command block to be used for cancelling the HCAM 1316 */ 1317 static void pmcraid_cancel_ldn(struct pmcraid_cmd *cmd) 1318 { 1319 pmcraid_cancel_hcam(cmd, 1320 PMCRAID_HCAM_CODE_LOG_DATA, 1321 pmcraid_cancel_ccn); 1322 } 1323 1324 /** 1325 * pmcraid_expose_resource - check if the resource can be exposed to OS 1326 * 1327 * @fw_version: firmware version code 1328 * @cfgte: pointer to configuration table entry of the resource 1329 * 1330 * Return value: 1331 * true if resource can be added to midlayer, false(0) otherwise 1332 */ 1333 static int pmcraid_expose_resource(u16 fw_version, 1334 struct pmcraid_config_table_entry *cfgte) 1335 { 1336 int retval = 0; 1337 1338 if (cfgte->resource_type == RES_TYPE_VSET) { 1339 if (fw_version <= PMCRAID_FW_VERSION_1) 1340 retval = ((cfgte->unique_flags1 & 0x80) == 0); 1341 else 1342 retval = ((cfgte->unique_flags0 & 0x80) == 0 && 1343 (cfgte->unique_flags1 & 0x80) == 0); 1344 1345 } else if (cfgte->resource_type == RES_TYPE_GSCSI) 1346 retval = (RES_BUS(cfgte->resource_address) != 1347 PMCRAID_VIRTUAL_ENCL_BUS_ID); 1348 return retval; 1349 } 1350 1351 /* attributes supported by pmcraid_event_family */ 1352 enum { 1353 PMCRAID_AEN_ATTR_UNSPEC, 1354 PMCRAID_AEN_ATTR_EVENT, 1355 __PMCRAID_AEN_ATTR_MAX, 1356 }; 1357 #define PMCRAID_AEN_ATTR_MAX (__PMCRAID_AEN_ATTR_MAX - 1) 1358 1359 /* commands supported by pmcraid_event_family */ 1360 enum { 1361 PMCRAID_AEN_CMD_UNSPEC, 1362 PMCRAID_AEN_CMD_EVENT, 1363 __PMCRAID_AEN_CMD_MAX, 1364 }; 1365 #define PMCRAID_AEN_CMD_MAX (__PMCRAID_AEN_CMD_MAX - 1) 1366 1367 static struct genl_multicast_group pmcraid_mcgrps[] = { 1368 { .name = "events", /* not really used - see ID discussion below */ }, 1369 }; 1370 1371 static struct genl_family pmcraid_event_family __ro_after_init = { 1372 .module = THIS_MODULE, 1373 .name = "pmcraid", 1374 .version = 1, 1375 .maxattr = PMCRAID_AEN_ATTR_MAX, 1376 .mcgrps = pmcraid_mcgrps, 1377 .n_mcgrps = ARRAY_SIZE(pmcraid_mcgrps), 1378 }; 1379 1380 /** 1381 * pmcraid_netlink_init - registers pmcraid_event_family 1382 * 1383 * Return value: 1384 * 0 if the pmcraid_event_family is successfully registered 1385 * with netlink generic, non-zero otherwise 1386 */ 1387 static int __init pmcraid_netlink_init(void) 1388 { 1389 int result; 1390 1391 result = genl_register_family(&pmcraid_event_family); 1392 1393 if (result) 1394 return result; 1395 1396 pmcraid_info("registered NETLINK GENERIC group: %d\n", 1397 pmcraid_event_family.id); 1398 1399 return result; 1400 } 1401 1402 /** 1403 * pmcraid_netlink_release - unregisters pmcraid_event_family 1404 * 1405 * Return value: 1406 * none 1407 */ 1408 static void pmcraid_netlink_release(void) 1409 { 1410 genl_unregister_family(&pmcraid_event_family); 1411 } 1412 1413 /** 1414 * pmcraid_notify_aen - sends event msg to user space application 1415 * @pinstance: pointer to adapter instance structure 1416 * @type: HCAM type 1417 * 1418 * Return value: 1419 * 0 if success, error value in case of any failure. 1420 */ 1421 static int pmcraid_notify_aen( 1422 struct pmcraid_instance *pinstance, 1423 struct pmcraid_aen_msg *aen_msg, 1424 u32 data_size 1425 ) 1426 { 1427 struct sk_buff *skb; 1428 void *msg_header; 1429 u32 total_size, nla_genl_hdr_total_size; 1430 int result; 1431 1432 aen_msg->hostno = (pinstance->host->unique_id << 16 | 1433 MINOR(pinstance->cdev.dev)); 1434 aen_msg->length = data_size; 1435 1436 data_size += sizeof(*aen_msg); 1437 1438 total_size = nla_total_size(data_size); 1439 /* Add GENL_HDR to total_size */ 1440 nla_genl_hdr_total_size = 1441 (total_size + (GENL_HDRLEN + 1442 ((struct genl_family *)&pmcraid_event_family)->hdrsize) 1443 + NLMSG_HDRLEN); 1444 skb = genlmsg_new(nla_genl_hdr_total_size, GFP_ATOMIC); 1445 1446 1447 if (!skb) { 1448 pmcraid_err("Failed to allocate aen data SKB of size: %x\n", 1449 total_size); 1450 return -ENOMEM; 1451 } 1452 1453 /* add the genetlink message header */ 1454 msg_header = genlmsg_put(skb, 0, 0, 1455 &pmcraid_event_family, 0, 1456 PMCRAID_AEN_CMD_EVENT); 1457 if (!msg_header) { 1458 pmcraid_err("failed to copy command details\n"); 1459 nlmsg_free(skb); 1460 return -ENOMEM; 1461 } 1462 1463 result = nla_put(skb, PMCRAID_AEN_ATTR_EVENT, data_size, aen_msg); 1464 1465 if (result) { 1466 pmcraid_err("failed to copy AEN attribute data\n"); 1467 nlmsg_free(skb); 1468 return -EINVAL; 1469 } 1470 1471 /* send genetlink multicast message to notify appplications */ 1472 genlmsg_end(skb, msg_header); 1473 1474 result = genlmsg_multicast(&pmcraid_event_family, skb, 1475 0, 0, GFP_ATOMIC); 1476 1477 /* If there are no listeners, genlmsg_multicast may return non-zero 1478 * value. 1479 */ 1480 if (result) 1481 pmcraid_info("error (%x) sending aen event message\n", result); 1482 return result; 1483 } 1484 1485 /** 1486 * pmcraid_notify_ccn - notifies about CCN event msg to user space 1487 * @pinstance: pointer adapter instance structure 1488 * 1489 * Return value: 1490 * 0 if success, error value in case of any failure 1491 */ 1492 static int pmcraid_notify_ccn(struct pmcraid_instance *pinstance) 1493 { 1494 return pmcraid_notify_aen(pinstance, 1495 pinstance->ccn.msg, 1496 le32_to_cpu(pinstance->ccn.hcam->data_len) + 1497 sizeof(struct pmcraid_hcam_hdr)); 1498 } 1499 1500 /** 1501 * pmcraid_notify_ldn - notifies about CCN event msg to user space 1502 * @pinstance: pointer adapter instance structure 1503 * 1504 * Return value: 1505 * 0 if success, error value in case of any failure 1506 */ 1507 static int pmcraid_notify_ldn(struct pmcraid_instance *pinstance) 1508 { 1509 return pmcraid_notify_aen(pinstance, 1510 pinstance->ldn.msg, 1511 le32_to_cpu(pinstance->ldn.hcam->data_len) + 1512 sizeof(struct pmcraid_hcam_hdr)); 1513 } 1514 1515 /** 1516 * pmcraid_notify_ioastate - sends IOA state event msg to user space 1517 * @pinstance: pointer adapter instance structure 1518 * @evt: controller state event to be sent 1519 * 1520 * Return value: 1521 * 0 if success, error value in case of any failure 1522 */ 1523 static void pmcraid_notify_ioastate(struct pmcraid_instance *pinstance, u32 evt) 1524 { 1525 pinstance->scn.ioa_state = evt; 1526 pmcraid_notify_aen(pinstance, 1527 &pinstance->scn.msg, 1528 sizeof(u32)); 1529 } 1530 1531 /** 1532 * pmcraid_handle_config_change - Handle a config change from the adapter 1533 * @pinstance: pointer to per adapter instance structure 1534 * 1535 * Return value: 1536 * none 1537 */ 1538 1539 static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance) 1540 { 1541 struct pmcraid_config_table_entry *cfg_entry; 1542 struct pmcraid_hcam_ccn *ccn_hcam; 1543 struct pmcraid_cmd *cmd; 1544 struct pmcraid_cmd *cfgcmd; 1545 struct pmcraid_resource_entry *res = NULL; 1546 unsigned long lock_flags; 1547 unsigned long host_lock_flags; 1548 u32 new_entry = 1; 1549 u32 hidden_entry = 0; 1550 u16 fw_version; 1551 int rc; 1552 1553 ccn_hcam = (struct pmcraid_hcam_ccn *)pinstance->ccn.hcam; 1554 cfg_entry = &ccn_hcam->cfg_entry; 1555 fw_version = be16_to_cpu(pinstance->inq_data->fw_version); 1556 1557 pmcraid_info("CCN(%x): %x timestamp: %llx type: %x lost: %x flags: %x \ 1558 res: %x:%x:%x:%x\n", 1559 le32_to_cpu(pinstance->ccn.hcam->ilid), 1560 pinstance->ccn.hcam->op_code, 1561 (le32_to_cpu(pinstance->ccn.hcam->timestamp1) | 1562 ((le32_to_cpu(pinstance->ccn.hcam->timestamp2) & 0xffffffffLL) << 32)), 1563 pinstance->ccn.hcam->notification_type, 1564 pinstance->ccn.hcam->notification_lost, 1565 pinstance->ccn.hcam->flags, 1566 pinstance->host->unique_id, 1567 RES_IS_VSET(*cfg_entry) ? PMCRAID_VSET_BUS_ID : 1568 (RES_IS_GSCSI(*cfg_entry) ? PMCRAID_PHYS_BUS_ID : 1569 RES_BUS(cfg_entry->resource_address)), 1570 RES_IS_VSET(*cfg_entry) ? 1571 (fw_version <= PMCRAID_FW_VERSION_1 ? 1572 cfg_entry->unique_flags1 : 1573 le16_to_cpu(cfg_entry->array_id) & 0xFF) : 1574 RES_TARGET(cfg_entry->resource_address), 1575 RES_LUN(cfg_entry->resource_address)); 1576 1577 1578 /* If this HCAM indicates a lost notification, read the config table */ 1579 if (pinstance->ccn.hcam->notification_lost) { 1580 cfgcmd = pmcraid_get_free_cmd(pinstance); 1581 if (cfgcmd) { 1582 pmcraid_info("lost CCN, reading config table\b"); 1583 pinstance->reinit_cfg_table = 1; 1584 pmcraid_querycfg(cfgcmd); 1585 } else { 1586 pmcraid_err("lost CCN, no free cmd for querycfg\n"); 1587 } 1588 goto out_notify_apps; 1589 } 1590 1591 /* If this resource is not going to be added to mid-layer, just notify 1592 * applications and return. If this notification is about hiding a VSET 1593 * resource, check if it was exposed already. 1594 */ 1595 if (pinstance->ccn.hcam->notification_type == 1596 NOTIFICATION_TYPE_ENTRY_CHANGED && 1597 cfg_entry->resource_type == RES_TYPE_VSET) { 1598 1599 if (fw_version <= PMCRAID_FW_VERSION_1) 1600 hidden_entry = (cfg_entry->unique_flags1 & 0x80) != 0; 1601 else 1602 hidden_entry = (cfg_entry->unique_flags1 & 0x80) != 0; 1603 1604 } else if (!pmcraid_expose_resource(fw_version, cfg_entry)) { 1605 goto out_notify_apps; 1606 } 1607 1608 spin_lock_irqsave(&pinstance->resource_lock, lock_flags); 1609 list_for_each_entry(res, &pinstance->used_res_q, queue) { 1610 rc = memcmp(&res->cfg_entry.resource_address, 1611 &cfg_entry->resource_address, 1612 sizeof(cfg_entry->resource_address)); 1613 if (!rc) { 1614 new_entry = 0; 1615 break; 1616 } 1617 } 1618 1619 if (new_entry) { 1620 1621 if (hidden_entry) { 1622 spin_unlock_irqrestore(&pinstance->resource_lock, 1623 lock_flags); 1624 goto out_notify_apps; 1625 } 1626 1627 /* If there are more number of resources than what driver can 1628 * manage, do not notify the applications about the CCN. Just 1629 * ignore this notifications and re-register the same HCAM 1630 */ 1631 if (list_empty(&pinstance->free_res_q)) { 1632 spin_unlock_irqrestore(&pinstance->resource_lock, 1633 lock_flags); 1634 pmcraid_err("too many resources attached\n"); 1635 spin_lock_irqsave(pinstance->host->host_lock, 1636 host_lock_flags); 1637 pmcraid_send_hcam(pinstance, 1638 PMCRAID_HCAM_CODE_CONFIG_CHANGE); 1639 spin_unlock_irqrestore(pinstance->host->host_lock, 1640 host_lock_flags); 1641 return; 1642 } 1643 1644 res = list_entry(pinstance->free_res_q.next, 1645 struct pmcraid_resource_entry, queue); 1646 1647 list_del(&res->queue); 1648 res->scsi_dev = NULL; 1649 res->reset_progress = 0; 1650 list_add_tail(&res->queue, &pinstance->used_res_q); 1651 } 1652 1653 memcpy(&res->cfg_entry, cfg_entry, pinstance->config_table_entry_size); 1654 1655 if (pinstance->ccn.hcam->notification_type == 1656 NOTIFICATION_TYPE_ENTRY_DELETED || hidden_entry) { 1657 if (res->scsi_dev) { 1658 if (fw_version <= PMCRAID_FW_VERSION_1) 1659 res->cfg_entry.unique_flags1 &= 0x7F; 1660 else 1661 res->cfg_entry.array_id &= cpu_to_le16(0xFF); 1662 res->change_detected = RES_CHANGE_DEL; 1663 res->cfg_entry.resource_handle = 1664 PMCRAID_INVALID_RES_HANDLE; 1665 schedule_work(&pinstance->worker_q); 1666 } else { 1667 /* This may be one of the non-exposed resources */ 1668 list_move_tail(&res->queue, &pinstance->free_res_q); 1669 } 1670 } else if (!res->scsi_dev) { 1671 res->change_detected = RES_CHANGE_ADD; 1672 schedule_work(&pinstance->worker_q); 1673 } 1674 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags); 1675 1676 out_notify_apps: 1677 1678 /* Notify configuration changes to registered applications.*/ 1679 if (!pmcraid_disable_aen) 1680 pmcraid_notify_ccn(pinstance); 1681 1682 cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE); 1683 if (cmd) 1684 pmcraid_send_hcam_cmd(cmd); 1685 } 1686 1687 /** 1688 * pmcraid_get_error_info - return error string for an ioasc 1689 * @ioasc: ioasc code 1690 * Return Value 1691 * none 1692 */ 1693 static struct pmcraid_ioasc_error *pmcraid_get_error_info(u32 ioasc) 1694 { 1695 int i; 1696 for (i = 0; i < ARRAY_SIZE(pmcraid_ioasc_error_table); i++) { 1697 if (pmcraid_ioasc_error_table[i].ioasc_code == ioasc) 1698 return &pmcraid_ioasc_error_table[i]; 1699 } 1700 return NULL; 1701 } 1702 1703 /** 1704 * pmcraid_ioasc_logger - log IOASC information based user-settings 1705 * @ioasc: ioasc code 1706 * @cmd: pointer to command that resulted in 'ioasc' 1707 */ 1708 static void pmcraid_ioasc_logger(u32 ioasc, struct pmcraid_cmd *cmd) 1709 { 1710 struct pmcraid_ioasc_error *error_info = pmcraid_get_error_info(ioasc); 1711 1712 if (error_info == NULL || 1713 cmd->drv_inst->current_log_level < error_info->log_level) 1714 return; 1715 1716 /* log the error string */ 1717 pmcraid_err("cmd [%x] for resource %x failed with %x(%s)\n", 1718 cmd->ioa_cb->ioarcb.cdb[0], 1719 le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle), 1720 ioasc, error_info->error_string); 1721 } 1722 1723 /** 1724 * pmcraid_handle_error_log - Handle a config change (error log) from the IOA 1725 * 1726 * @pinstance: pointer to per adapter instance structure 1727 * 1728 * Return value: 1729 * none 1730 */ 1731 static void pmcraid_handle_error_log(struct pmcraid_instance *pinstance) 1732 { 1733 struct pmcraid_hcam_ldn *hcam_ldn; 1734 u32 ioasc; 1735 1736 hcam_ldn = (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam; 1737 1738 pmcraid_info 1739 ("LDN(%x): %x type: %x lost: %x flags: %x overlay id: %x\n", 1740 pinstance->ldn.hcam->ilid, 1741 pinstance->ldn.hcam->op_code, 1742 pinstance->ldn.hcam->notification_type, 1743 pinstance->ldn.hcam->notification_lost, 1744 pinstance->ldn.hcam->flags, 1745 pinstance->ldn.hcam->overlay_id); 1746 1747 /* log only the errors, no need to log informational log entries */ 1748 if (pinstance->ldn.hcam->notification_type != 1749 NOTIFICATION_TYPE_ERROR_LOG) 1750 return; 1751 1752 if (pinstance->ldn.hcam->notification_lost == 1753 HOSTRCB_NOTIFICATIONS_LOST) 1754 dev_info(&pinstance->pdev->dev, "Error notifications lost\n"); 1755 1756 ioasc = le32_to_cpu(hcam_ldn->error_log.fd_ioasc); 1757 1758 if (ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET || 1759 ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET_BY_OTHER) { 1760 dev_info(&pinstance->pdev->dev, 1761 "UnitAttention due to IOA Bus Reset\n"); 1762 scsi_report_bus_reset( 1763 pinstance->host, 1764 RES_BUS(hcam_ldn->error_log.fd_ra)); 1765 } 1766 1767 return; 1768 } 1769 1770 /** 1771 * pmcraid_process_ccn - Op done function for a CCN. 1772 * @cmd: pointer to command struct 1773 * 1774 * This function is the op done function for a configuration 1775 * change notification 1776 * 1777 * Return value: 1778 * none 1779 */ 1780 static void pmcraid_process_ccn(struct pmcraid_cmd *cmd) 1781 { 1782 struct pmcraid_instance *pinstance = cmd->drv_inst; 1783 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc); 1784 unsigned long lock_flags; 1785 1786 pinstance->ccn.cmd = NULL; 1787 pmcraid_return_cmd(cmd); 1788 1789 /* If driver initiated IOA reset happened while this hcam was pending 1790 * with IOA, or IOA bringdown sequence is in progress, no need to 1791 * re-register the hcam 1792 */ 1793 if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET || 1794 atomic_read(&pinstance->ccn.ignore) == 1) { 1795 return; 1796 } else if (ioasc) { 1797 dev_info(&pinstance->pdev->dev, 1798 "Host RCB (CCN) failed with IOASC: 0x%08X\n", ioasc); 1799 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 1800 pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE); 1801 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 1802 } else { 1803 pmcraid_handle_config_change(pinstance); 1804 } 1805 } 1806 1807 /** 1808 * pmcraid_process_ldn - op done function for an LDN 1809 * @cmd: pointer to command block 1810 * 1811 * Return value 1812 * none 1813 */ 1814 static void pmcraid_initiate_reset(struct pmcraid_instance *); 1815 static void pmcraid_set_timestamp(struct pmcraid_cmd *cmd); 1816 1817 static void pmcraid_process_ldn(struct pmcraid_cmd *cmd) 1818 { 1819 struct pmcraid_instance *pinstance = cmd->drv_inst; 1820 struct pmcraid_hcam_ldn *ldn_hcam = 1821 (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam; 1822 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc); 1823 u32 fd_ioasc = le32_to_cpu(ldn_hcam->error_log.fd_ioasc); 1824 unsigned long lock_flags; 1825 1826 /* return the command block back to freepool */ 1827 pinstance->ldn.cmd = NULL; 1828 pmcraid_return_cmd(cmd); 1829 1830 /* If driver initiated IOA reset happened while this hcam was pending 1831 * with IOA, no need to re-register the hcam as reset engine will do it 1832 * once reset sequence is complete 1833 */ 1834 if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET || 1835 atomic_read(&pinstance->ccn.ignore) == 1) { 1836 return; 1837 } else if (!ioasc) { 1838 pmcraid_handle_error_log(pinstance); 1839 if (fd_ioasc == PMCRAID_IOASC_NR_IOA_RESET_REQUIRED) { 1840 spin_lock_irqsave(pinstance->host->host_lock, 1841 lock_flags); 1842 pmcraid_initiate_reset(pinstance); 1843 spin_unlock_irqrestore(pinstance->host->host_lock, 1844 lock_flags); 1845 return; 1846 } 1847 if (fd_ioasc == PMCRAID_IOASC_TIME_STAMP_OUT_OF_SYNC) { 1848 pinstance->timestamp_error = 1; 1849 pmcraid_set_timestamp(cmd); 1850 } 1851 } else { 1852 dev_info(&pinstance->pdev->dev, 1853 "Host RCB(LDN) failed with IOASC: 0x%08X\n", ioasc); 1854 } 1855 /* send netlink message for HCAM notification if enabled */ 1856 if (!pmcraid_disable_aen) 1857 pmcraid_notify_ldn(pinstance); 1858 1859 cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA); 1860 if (cmd) 1861 pmcraid_send_hcam_cmd(cmd); 1862 } 1863 1864 /** 1865 * pmcraid_register_hcams - register HCAMs for CCN and LDN 1866 * 1867 * @pinstance: pointer per adapter instance structure 1868 * 1869 * Return Value 1870 * none 1871 */ 1872 static void pmcraid_register_hcams(struct pmcraid_instance *pinstance) 1873 { 1874 pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE); 1875 pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA); 1876 } 1877 1878 /** 1879 * pmcraid_unregister_hcams - cancel HCAMs registered already 1880 * @cmd: pointer to command used as part of reset sequence 1881 */ 1882 static void pmcraid_unregister_hcams(struct pmcraid_cmd *cmd) 1883 { 1884 struct pmcraid_instance *pinstance = cmd->drv_inst; 1885 1886 /* During IOA bringdown, HCAM gets fired and tasklet proceeds with 1887 * handling hcam response though it is not necessary. In order to 1888 * prevent this, set 'ignore', so that bring-down sequence doesn't 1889 * re-send any more hcams 1890 */ 1891 atomic_set(&pinstance->ccn.ignore, 1); 1892 atomic_set(&pinstance->ldn.ignore, 1); 1893 1894 /* If adapter reset was forced as part of runtime reset sequence, 1895 * start the reset sequence. Reset will be triggered even in case 1896 * IOA unit_check. 1897 */ 1898 if ((pinstance->force_ioa_reset && !pinstance->ioa_bringdown) || 1899 pinstance->ioa_unit_check) { 1900 pinstance->force_ioa_reset = 0; 1901 pinstance->ioa_unit_check = 0; 1902 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT; 1903 pmcraid_reset_alert(cmd); 1904 return; 1905 } 1906 1907 /* Driver tries to cancel HCAMs by sending ABORT TASK for each HCAM 1908 * one after the other. So CCN cancellation will be triggered by 1909 * pmcraid_cancel_ldn itself. 1910 */ 1911 pmcraid_cancel_ldn(cmd); 1912 } 1913 1914 /** 1915 * pmcraid_reset_enable_ioa - re-enable IOA after a hard reset 1916 * @pinstance: pointer to adapter instance structure 1917 * Return Value 1918 * 1 if TRANSITION_TO_OPERATIONAL is active, otherwise 0 1919 */ 1920 static void pmcraid_reinit_buffers(struct pmcraid_instance *); 1921 1922 static int pmcraid_reset_enable_ioa(struct pmcraid_instance *pinstance) 1923 { 1924 u32 intrs; 1925 1926 pmcraid_reinit_buffers(pinstance); 1927 intrs = pmcraid_read_interrupts(pinstance); 1928 1929 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS); 1930 1931 if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) { 1932 if (!pinstance->interrupt_mode) { 1933 iowrite32(INTRS_TRANSITION_TO_OPERATIONAL, 1934 pinstance->int_regs. 1935 ioa_host_interrupt_mask_reg); 1936 iowrite32(INTRS_TRANSITION_TO_OPERATIONAL, 1937 pinstance->int_regs.ioa_host_interrupt_clr_reg); 1938 } 1939 return 1; 1940 } else { 1941 return 0; 1942 } 1943 } 1944 1945 /** 1946 * pmcraid_soft_reset - performs a soft reset and makes IOA become ready 1947 * @cmd : pointer to reset command block 1948 * 1949 * Return Value 1950 * none 1951 */ 1952 static void pmcraid_soft_reset(struct pmcraid_cmd *cmd) 1953 { 1954 struct pmcraid_instance *pinstance = cmd->drv_inst; 1955 u32 int_reg; 1956 u32 doorbell; 1957 1958 /* There will be an interrupt when Transition to Operational bit is 1959 * set so tasklet would execute next reset task. The timeout handler 1960 * would re-initiate a reset 1961 */ 1962 cmd->cmd_done = pmcraid_ioa_reset; 1963 cmd->timer.data = (unsigned long)cmd; 1964 cmd->timer.expires = jiffies + 1965 msecs_to_jiffies(PMCRAID_TRANSOP_TIMEOUT); 1966 cmd->timer.function = (void (*)(unsigned long))pmcraid_timeout_handler; 1967 1968 if (!timer_pending(&cmd->timer)) 1969 add_timer(&cmd->timer); 1970 1971 /* Enable destructive diagnostics on IOA if it is not yet in 1972 * operational state 1973 */ 1974 doorbell = DOORBELL_RUNTIME_RESET | 1975 DOORBELL_ENABLE_DESTRUCTIVE_DIAGS; 1976 1977 /* Since we do RESET_ALERT and Start BIST we have to again write 1978 * MSIX Doorbell to indicate the interrupt mode 1979 */ 1980 if (pinstance->interrupt_mode) { 1981 iowrite32(DOORBELL_INTR_MODE_MSIX, 1982 pinstance->int_regs.host_ioa_interrupt_reg); 1983 ioread32(pinstance->int_regs.host_ioa_interrupt_reg); 1984 } 1985 1986 iowrite32(doorbell, pinstance->int_regs.host_ioa_interrupt_reg); 1987 ioread32(pinstance->int_regs.host_ioa_interrupt_reg), 1988 int_reg = ioread32(pinstance->int_regs.ioa_host_interrupt_reg); 1989 1990 pmcraid_info("Waiting for IOA to become operational %x:%x\n", 1991 ioread32(pinstance->int_regs.host_ioa_interrupt_reg), 1992 int_reg); 1993 } 1994 1995 /** 1996 * pmcraid_get_dump - retrieves IOA dump in case of Unit Check interrupt 1997 * 1998 * @pinstance: pointer to adapter instance structure 1999 * 2000 * Return Value 2001 * none 2002 */ 2003 static void pmcraid_get_dump(struct pmcraid_instance *pinstance) 2004 { 2005 pmcraid_info("%s is not yet implemented\n", __func__); 2006 } 2007 2008 /** 2009 * pmcraid_fail_outstanding_cmds - Fails all outstanding ops. 2010 * @pinstance: pointer to adapter instance structure 2011 * 2012 * This function fails all outstanding ops. If they are submitted to IOA 2013 * already, it sends cancel all messages if IOA is still accepting IOARCBs, 2014 * otherwise just completes the commands and returns the cmd blocks to free 2015 * pool. 2016 * 2017 * Return value: 2018 * none 2019 */ 2020 static void pmcraid_fail_outstanding_cmds(struct pmcraid_instance *pinstance) 2021 { 2022 struct pmcraid_cmd *cmd, *temp; 2023 unsigned long lock_flags; 2024 2025 /* pending command list is protected by pending_pool_lock. Its 2026 * traversal must be done as within this lock 2027 */ 2028 spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags); 2029 list_for_each_entry_safe(cmd, temp, &pinstance->pending_cmd_pool, 2030 free_list) { 2031 list_del(&cmd->free_list); 2032 spin_unlock_irqrestore(&pinstance->pending_pool_lock, 2033 lock_flags); 2034 cmd->ioa_cb->ioasa.ioasc = 2035 cpu_to_le32(PMCRAID_IOASC_IOA_WAS_RESET); 2036 cmd->ioa_cb->ioasa.ilid = 2037 cpu_to_le32(PMCRAID_DRIVER_ILID); 2038 2039 /* In case the command timer is still running */ 2040 del_timer(&cmd->timer); 2041 2042 /* If this is an IO command, complete it by invoking scsi_done 2043 * function. If this is one of the internal commands other 2044 * than pmcraid_ioa_reset and HCAM commands invoke cmd_done to 2045 * complete it 2046 */ 2047 if (cmd->scsi_cmd) { 2048 2049 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd; 2050 __le32 resp = cmd->ioa_cb->ioarcb.response_handle; 2051 2052 scsi_cmd->result |= DID_ERROR << 16; 2053 2054 scsi_dma_unmap(scsi_cmd); 2055 pmcraid_return_cmd(cmd); 2056 2057 pmcraid_info("failing(%d) CDB[0] = %x result: %x\n", 2058 le32_to_cpu(resp) >> 2, 2059 cmd->ioa_cb->ioarcb.cdb[0], 2060 scsi_cmd->result); 2061 scsi_cmd->scsi_done(scsi_cmd); 2062 } else if (cmd->cmd_done == pmcraid_internal_done || 2063 cmd->cmd_done == pmcraid_erp_done) { 2064 cmd->cmd_done(cmd); 2065 } else if (cmd->cmd_done != pmcraid_ioa_reset && 2066 cmd->cmd_done != pmcraid_ioa_shutdown_done) { 2067 pmcraid_return_cmd(cmd); 2068 } 2069 2070 atomic_dec(&pinstance->outstanding_cmds); 2071 spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags); 2072 } 2073 2074 spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags); 2075 } 2076 2077 /** 2078 * pmcraid_ioa_reset - Implementation of IOA reset logic 2079 * 2080 * @cmd: pointer to the cmd block to be used for entire reset process 2081 * 2082 * This function executes most of the steps required for IOA reset. This gets 2083 * called by user threads (modprobe/insmod/rmmod) timer, tasklet and midlayer's 2084 * 'eh_' thread. Access to variables used for controlling the reset sequence is 2085 * synchronized using host lock. Various functions called during reset process 2086 * would make use of a single command block, pointer to which is also stored in 2087 * adapter instance structure. 2088 * 2089 * Return Value 2090 * None 2091 */ 2092 static void pmcraid_ioa_reset(struct pmcraid_cmd *cmd) 2093 { 2094 struct pmcraid_instance *pinstance = cmd->drv_inst; 2095 u8 reset_complete = 0; 2096 2097 pinstance->ioa_reset_in_progress = 1; 2098 2099 if (pinstance->reset_cmd != cmd) { 2100 pmcraid_err("reset is called with different command block\n"); 2101 pinstance->reset_cmd = cmd; 2102 } 2103 2104 pmcraid_info("reset_engine: state = %d, command = %p\n", 2105 pinstance->ioa_state, cmd); 2106 2107 switch (pinstance->ioa_state) { 2108 2109 case IOA_STATE_DEAD: 2110 /* If IOA is offline, whatever may be the reset reason, just 2111 * return. callers might be waiting on the reset wait_q, wake 2112 * up them 2113 */ 2114 pmcraid_err("IOA is offline no reset is possible\n"); 2115 reset_complete = 1; 2116 break; 2117 2118 case IOA_STATE_IN_BRINGDOWN: 2119 /* we enter here, once ioa shutdown command is processed by IOA 2120 * Alert IOA for a possible reset. If reset alert fails, IOA 2121 * goes through hard-reset 2122 */ 2123 pmcraid_disable_interrupts(pinstance, ~0); 2124 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT; 2125 pmcraid_reset_alert(cmd); 2126 break; 2127 2128 case IOA_STATE_UNKNOWN: 2129 /* We may be called during probe or resume. Some pre-processing 2130 * is required for prior to reset 2131 */ 2132 scsi_block_requests(pinstance->host); 2133 2134 /* If asked to reset while IOA was processing responses or 2135 * there are any error responses then IOA may require 2136 * hard-reset. 2137 */ 2138 if (pinstance->ioa_hard_reset == 0) { 2139 if (ioread32(pinstance->ioa_status) & 2140 INTRS_TRANSITION_TO_OPERATIONAL) { 2141 pmcraid_info("sticky bit set, bring-up\n"); 2142 pinstance->ioa_state = IOA_STATE_IN_BRINGUP; 2143 pmcraid_reinit_cmdblk(cmd); 2144 pmcraid_identify_hrrq(cmd); 2145 } else { 2146 pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET; 2147 pmcraid_soft_reset(cmd); 2148 } 2149 } else { 2150 /* Alert IOA of a possible reset and wait for critical 2151 * operation in progress bit to reset 2152 */ 2153 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT; 2154 pmcraid_reset_alert(cmd); 2155 } 2156 break; 2157 2158 case IOA_STATE_IN_RESET_ALERT: 2159 /* If critical operation in progress bit is reset or wait gets 2160 * timed out, reset proceeds with starting BIST on the IOA. 2161 * pmcraid_ioa_hard_reset keeps a count of reset attempts. If 2162 * they are 3 or more, reset engine marks IOA dead and returns 2163 */ 2164 pinstance->ioa_state = IOA_STATE_IN_HARD_RESET; 2165 pmcraid_start_bist(cmd); 2166 break; 2167 2168 case IOA_STATE_IN_HARD_RESET: 2169 pinstance->ioa_reset_attempts++; 2170 2171 /* retry reset if we haven't reached maximum allowed limit */ 2172 if (pinstance->ioa_reset_attempts > PMCRAID_RESET_ATTEMPTS) { 2173 pinstance->ioa_reset_attempts = 0; 2174 pmcraid_err("IOA didn't respond marking it as dead\n"); 2175 pinstance->ioa_state = IOA_STATE_DEAD; 2176 2177 if (pinstance->ioa_bringdown) 2178 pmcraid_notify_ioastate(pinstance, 2179 PMC_DEVICE_EVENT_SHUTDOWN_FAILED); 2180 else 2181 pmcraid_notify_ioastate(pinstance, 2182 PMC_DEVICE_EVENT_RESET_FAILED); 2183 reset_complete = 1; 2184 break; 2185 } 2186 2187 /* Once either bist or pci reset is done, restore PCI config 2188 * space. If this fails, proceed with hard reset again 2189 */ 2190 pci_restore_state(pinstance->pdev); 2191 2192 /* fail all pending commands */ 2193 pmcraid_fail_outstanding_cmds(pinstance); 2194 2195 /* check if unit check is active, if so extract dump */ 2196 if (pinstance->ioa_unit_check) { 2197 pmcraid_info("unit check is active\n"); 2198 pinstance->ioa_unit_check = 0; 2199 pmcraid_get_dump(pinstance); 2200 pinstance->ioa_reset_attempts--; 2201 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT; 2202 pmcraid_reset_alert(cmd); 2203 break; 2204 } 2205 2206 /* if the reset reason is to bring-down the ioa, we might be 2207 * done with the reset restore pci_config_space and complete 2208 * the reset 2209 */ 2210 if (pinstance->ioa_bringdown) { 2211 pmcraid_info("bringing down the adapter\n"); 2212 pinstance->ioa_shutdown_type = SHUTDOWN_NONE; 2213 pinstance->ioa_bringdown = 0; 2214 pinstance->ioa_state = IOA_STATE_UNKNOWN; 2215 pmcraid_notify_ioastate(pinstance, 2216 PMC_DEVICE_EVENT_SHUTDOWN_SUCCESS); 2217 reset_complete = 1; 2218 } else { 2219 /* bring-up IOA, so proceed with soft reset 2220 * Reinitialize hrrq_buffers and their indices also 2221 * enable interrupts after a pci_restore_state 2222 */ 2223 if (pmcraid_reset_enable_ioa(pinstance)) { 2224 pinstance->ioa_state = IOA_STATE_IN_BRINGUP; 2225 pmcraid_info("bringing up the adapter\n"); 2226 pmcraid_reinit_cmdblk(cmd); 2227 pmcraid_identify_hrrq(cmd); 2228 } else { 2229 pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET; 2230 pmcraid_soft_reset(cmd); 2231 } 2232 } 2233 break; 2234 2235 case IOA_STATE_IN_SOFT_RESET: 2236 /* TRANSITION TO OPERATIONAL is on so start initialization 2237 * sequence 2238 */ 2239 pmcraid_info("In softreset proceeding with bring-up\n"); 2240 pinstance->ioa_state = IOA_STATE_IN_BRINGUP; 2241 2242 /* Initialization commands start with HRRQ identification. From 2243 * now on tasklet completes most of the commands as IOA is up 2244 * and intrs are enabled 2245 */ 2246 pmcraid_identify_hrrq(cmd); 2247 break; 2248 2249 case IOA_STATE_IN_BRINGUP: 2250 /* we are done with bringing up of IOA, change the ioa_state to 2251 * operational and wake up any waiters 2252 */ 2253 pinstance->ioa_state = IOA_STATE_OPERATIONAL; 2254 reset_complete = 1; 2255 break; 2256 2257 case IOA_STATE_OPERATIONAL: 2258 default: 2259 /* When IOA is operational and a reset is requested, check for 2260 * the reset reason. If reset is to bring down IOA, unregister 2261 * HCAMs and initiate shutdown; if adapter reset is forced then 2262 * restart reset sequence again 2263 */ 2264 if (pinstance->ioa_shutdown_type == SHUTDOWN_NONE && 2265 pinstance->force_ioa_reset == 0) { 2266 pmcraid_notify_ioastate(pinstance, 2267 PMC_DEVICE_EVENT_RESET_SUCCESS); 2268 reset_complete = 1; 2269 } else { 2270 if (pinstance->ioa_shutdown_type != SHUTDOWN_NONE) 2271 pinstance->ioa_state = IOA_STATE_IN_BRINGDOWN; 2272 pmcraid_reinit_cmdblk(cmd); 2273 pmcraid_unregister_hcams(cmd); 2274 } 2275 break; 2276 } 2277 2278 /* reset will be completed if ioa_state is either DEAD or UNKNOWN or 2279 * OPERATIONAL. Reset all control variables used during reset, wake up 2280 * any waiting threads and let the SCSI mid-layer send commands. Note 2281 * that host_lock must be held before invoking scsi_report_bus_reset. 2282 */ 2283 if (reset_complete) { 2284 pinstance->ioa_reset_in_progress = 0; 2285 pinstance->ioa_reset_attempts = 0; 2286 pinstance->reset_cmd = NULL; 2287 pinstance->ioa_shutdown_type = SHUTDOWN_NONE; 2288 pinstance->ioa_bringdown = 0; 2289 pmcraid_return_cmd(cmd); 2290 2291 /* If target state is to bring up the adapter, proceed with 2292 * hcam registration and resource exposure to mid-layer. 2293 */ 2294 if (pinstance->ioa_state == IOA_STATE_OPERATIONAL) 2295 pmcraid_register_hcams(pinstance); 2296 2297 wake_up_all(&pinstance->reset_wait_q); 2298 } 2299 2300 return; 2301 } 2302 2303 /** 2304 * pmcraid_initiate_reset - initiates reset sequence. This is called from 2305 * ISR/tasklet during error interrupts including IOA unit check. If reset 2306 * is already in progress, it just returns, otherwise initiates IOA reset 2307 * to bring IOA up to operational state. 2308 * 2309 * @pinstance: pointer to adapter instance structure 2310 * 2311 * Return value 2312 * none 2313 */ 2314 static void pmcraid_initiate_reset(struct pmcraid_instance *pinstance) 2315 { 2316 struct pmcraid_cmd *cmd; 2317 2318 /* If the reset is already in progress, just return, otherwise start 2319 * reset sequence and return 2320 */ 2321 if (!pinstance->ioa_reset_in_progress) { 2322 scsi_block_requests(pinstance->host); 2323 cmd = pmcraid_get_free_cmd(pinstance); 2324 2325 if (cmd == NULL) { 2326 pmcraid_err("no cmnd blocks for initiate_reset\n"); 2327 return; 2328 } 2329 2330 pinstance->ioa_shutdown_type = SHUTDOWN_NONE; 2331 pinstance->reset_cmd = cmd; 2332 pinstance->force_ioa_reset = 1; 2333 pmcraid_notify_ioastate(pinstance, 2334 PMC_DEVICE_EVENT_RESET_START); 2335 pmcraid_ioa_reset(cmd); 2336 } 2337 } 2338 2339 /** 2340 * pmcraid_reset_reload - utility routine for doing IOA reset either to bringup 2341 * or bringdown IOA 2342 * @pinstance: pointer adapter instance structure 2343 * @shutdown_type: shutdown type to be used NONE, NORMAL or ABRREV 2344 * @target_state: expected target state after reset 2345 * 2346 * Note: This command initiates reset and waits for its completion. Hence this 2347 * should not be called from isr/timer/tasklet functions (timeout handlers, 2348 * error response handlers and interrupt handlers). 2349 * 2350 * Return Value 2351 * 1 in case ioa_state is not target_state, 0 otherwise. 2352 */ 2353 static int pmcraid_reset_reload( 2354 struct pmcraid_instance *pinstance, 2355 u8 shutdown_type, 2356 u8 target_state 2357 ) 2358 { 2359 struct pmcraid_cmd *reset_cmd = NULL; 2360 unsigned long lock_flags; 2361 int reset = 1; 2362 2363 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 2364 2365 if (pinstance->ioa_reset_in_progress) { 2366 pmcraid_info("reset_reload: reset is already in progress\n"); 2367 2368 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 2369 2370 wait_event(pinstance->reset_wait_q, 2371 !pinstance->ioa_reset_in_progress); 2372 2373 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 2374 2375 if (pinstance->ioa_state == IOA_STATE_DEAD) { 2376 pmcraid_info("reset_reload: IOA is dead\n"); 2377 goto out_unlock; 2378 } 2379 2380 if (pinstance->ioa_state == target_state) { 2381 reset = 0; 2382 goto out_unlock; 2383 } 2384 } 2385 2386 pmcraid_info("reset_reload: proceeding with reset\n"); 2387 scsi_block_requests(pinstance->host); 2388 reset_cmd = pmcraid_get_free_cmd(pinstance); 2389 if (reset_cmd == NULL) { 2390 pmcraid_err("no free cmnd for reset_reload\n"); 2391 goto out_unlock; 2392 } 2393 2394 if (shutdown_type == SHUTDOWN_NORMAL) 2395 pinstance->ioa_bringdown = 1; 2396 2397 pinstance->ioa_shutdown_type = shutdown_type; 2398 pinstance->reset_cmd = reset_cmd; 2399 pinstance->force_ioa_reset = reset; 2400 pmcraid_info("reset_reload: initiating reset\n"); 2401 pmcraid_ioa_reset(reset_cmd); 2402 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 2403 pmcraid_info("reset_reload: waiting for reset to complete\n"); 2404 wait_event(pinstance->reset_wait_q, 2405 !pinstance->ioa_reset_in_progress); 2406 2407 pmcraid_info("reset_reload: reset is complete !!\n"); 2408 scsi_unblock_requests(pinstance->host); 2409 return pinstance->ioa_state != target_state; 2410 2411 out_unlock: 2412 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 2413 return reset; 2414 } 2415 2416 /** 2417 * pmcraid_reset_bringdown - wrapper over pmcraid_reset_reload to bringdown IOA 2418 * 2419 * @pinstance: pointer to adapter instance structure 2420 * 2421 * Return Value 2422 * whatever is returned from pmcraid_reset_reload 2423 */ 2424 static int pmcraid_reset_bringdown(struct pmcraid_instance *pinstance) 2425 { 2426 return pmcraid_reset_reload(pinstance, 2427 SHUTDOWN_NORMAL, 2428 IOA_STATE_UNKNOWN); 2429 } 2430 2431 /** 2432 * pmcraid_reset_bringup - wrapper over pmcraid_reset_reload to bring up IOA 2433 * 2434 * @pinstance: pointer to adapter instance structure 2435 * 2436 * Return Value 2437 * whatever is returned from pmcraid_reset_reload 2438 */ 2439 static int pmcraid_reset_bringup(struct pmcraid_instance *pinstance) 2440 { 2441 pmcraid_notify_ioastate(pinstance, PMC_DEVICE_EVENT_RESET_START); 2442 2443 return pmcraid_reset_reload(pinstance, 2444 SHUTDOWN_NONE, 2445 IOA_STATE_OPERATIONAL); 2446 } 2447 2448 /** 2449 * pmcraid_request_sense - Send request sense to a device 2450 * @cmd: pmcraid command struct 2451 * 2452 * This function sends a request sense to a device as a result of a check 2453 * condition. This method re-uses the same command block that failed earlier. 2454 */ 2455 static void pmcraid_request_sense(struct pmcraid_cmd *cmd) 2456 { 2457 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 2458 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl; 2459 2460 /* allocate DMAable memory for sense buffers */ 2461 cmd->sense_buffer = pci_alloc_consistent(cmd->drv_inst->pdev, 2462 SCSI_SENSE_BUFFERSIZE, 2463 &cmd->sense_buffer_dma); 2464 2465 if (cmd->sense_buffer == NULL) { 2466 pmcraid_err 2467 ("couldn't allocate sense buffer for request sense\n"); 2468 pmcraid_erp_done(cmd); 2469 return; 2470 } 2471 2472 /* re-use the command block */ 2473 memset(&cmd->ioa_cb->ioasa, 0, sizeof(struct pmcraid_ioasa)); 2474 memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN); 2475 ioarcb->request_flags0 = (SYNC_COMPLETE | 2476 NO_LINK_DESCS | 2477 INHIBIT_UL_CHECK); 2478 ioarcb->request_type = REQ_TYPE_SCSI; 2479 ioarcb->cdb[0] = REQUEST_SENSE; 2480 ioarcb->cdb[4] = SCSI_SENSE_BUFFERSIZE; 2481 2482 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) + 2483 offsetof(struct pmcraid_ioarcb, 2484 add_data.u.ioadl[0])); 2485 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc)); 2486 2487 ioarcb->data_transfer_length = cpu_to_le32(SCSI_SENSE_BUFFERSIZE); 2488 2489 ioadl->address = cpu_to_le64(cmd->sense_buffer_dma); 2490 ioadl->data_len = cpu_to_le32(SCSI_SENSE_BUFFERSIZE); 2491 ioadl->flags = IOADL_FLAGS_LAST_DESC; 2492 2493 /* request sense might be called as part of error response processing 2494 * which runs in tasklets context. It is possible that mid-layer might 2495 * schedule queuecommand during this time, hence, writting to IOARRIN 2496 * must be protect by host_lock 2497 */ 2498 pmcraid_send_cmd(cmd, pmcraid_erp_done, 2499 PMCRAID_REQUEST_SENSE_TIMEOUT, 2500 pmcraid_timeout_handler); 2501 } 2502 2503 /** 2504 * pmcraid_cancel_all - cancel all outstanding IOARCBs as part of error recovery 2505 * @cmd: command that failed 2506 * @sense: true if request_sense is required after cancel all 2507 * 2508 * This function sends a cancel all to a device to clear the queue. 2509 */ 2510 static void pmcraid_cancel_all(struct pmcraid_cmd *cmd, u32 sense) 2511 { 2512 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd; 2513 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 2514 struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata; 2515 void (*cmd_done) (struct pmcraid_cmd *) = sense ? pmcraid_erp_done 2516 : pmcraid_request_sense; 2517 2518 memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN); 2519 ioarcb->request_flags0 = SYNC_OVERRIDE; 2520 ioarcb->request_type = REQ_TYPE_IOACMD; 2521 ioarcb->cdb[0] = PMCRAID_CANCEL_ALL_REQUESTS; 2522 2523 if (RES_IS_GSCSI(res->cfg_entry)) 2524 ioarcb->cdb[1] = PMCRAID_SYNC_COMPLETE_AFTER_CANCEL; 2525 2526 ioarcb->ioadl_bus_addr = 0; 2527 ioarcb->ioadl_length = 0; 2528 ioarcb->data_transfer_length = 0; 2529 ioarcb->ioarcb_bus_addr &= cpu_to_le64((~0x1FULL)); 2530 2531 /* writing to IOARRIN must be protected by host_lock, as mid-layer 2532 * schedule queuecommand while we are doing this 2533 */ 2534 pmcraid_send_cmd(cmd, cmd_done, 2535 PMCRAID_REQUEST_SENSE_TIMEOUT, 2536 pmcraid_timeout_handler); 2537 } 2538 2539 /** 2540 * pmcraid_frame_auto_sense: frame fixed format sense information 2541 * 2542 * @cmd: pointer to failing command block 2543 * 2544 * Return value 2545 * none 2546 */ 2547 static void pmcraid_frame_auto_sense(struct pmcraid_cmd *cmd) 2548 { 2549 u8 *sense_buf = cmd->scsi_cmd->sense_buffer; 2550 struct pmcraid_resource_entry *res = cmd->scsi_cmd->device->hostdata; 2551 struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa; 2552 u32 ioasc = le32_to_cpu(ioasa->ioasc); 2553 u32 failing_lba = 0; 2554 2555 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE); 2556 cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION; 2557 2558 if (RES_IS_VSET(res->cfg_entry) && 2559 ioasc == PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC && 2560 ioasa->u.vset.failing_lba_hi != 0) { 2561 2562 sense_buf[0] = 0x72; 2563 sense_buf[1] = PMCRAID_IOASC_SENSE_KEY(ioasc); 2564 sense_buf[2] = PMCRAID_IOASC_SENSE_CODE(ioasc); 2565 sense_buf[3] = PMCRAID_IOASC_SENSE_QUAL(ioasc); 2566 2567 sense_buf[7] = 12; 2568 sense_buf[8] = 0; 2569 sense_buf[9] = 0x0A; 2570 sense_buf[10] = 0x80; 2571 2572 failing_lba = le32_to_cpu(ioasa->u.vset.failing_lba_hi); 2573 2574 sense_buf[12] = (failing_lba & 0xff000000) >> 24; 2575 sense_buf[13] = (failing_lba & 0x00ff0000) >> 16; 2576 sense_buf[14] = (failing_lba & 0x0000ff00) >> 8; 2577 sense_buf[15] = failing_lba & 0x000000ff; 2578 2579 failing_lba = le32_to_cpu(ioasa->u.vset.failing_lba_lo); 2580 2581 sense_buf[16] = (failing_lba & 0xff000000) >> 24; 2582 sense_buf[17] = (failing_lba & 0x00ff0000) >> 16; 2583 sense_buf[18] = (failing_lba & 0x0000ff00) >> 8; 2584 sense_buf[19] = failing_lba & 0x000000ff; 2585 } else { 2586 sense_buf[0] = 0x70; 2587 sense_buf[2] = PMCRAID_IOASC_SENSE_KEY(ioasc); 2588 sense_buf[12] = PMCRAID_IOASC_SENSE_CODE(ioasc); 2589 sense_buf[13] = PMCRAID_IOASC_SENSE_QUAL(ioasc); 2590 2591 if (ioasc == PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC) { 2592 if (RES_IS_VSET(res->cfg_entry)) 2593 failing_lba = 2594 le32_to_cpu(ioasa->u. 2595 vset.failing_lba_lo); 2596 sense_buf[0] |= 0x80; 2597 sense_buf[3] = (failing_lba >> 24) & 0xff; 2598 sense_buf[4] = (failing_lba >> 16) & 0xff; 2599 sense_buf[5] = (failing_lba >> 8) & 0xff; 2600 sense_buf[6] = failing_lba & 0xff; 2601 } 2602 2603 sense_buf[7] = 6; /* additional length */ 2604 } 2605 } 2606 2607 /** 2608 * pmcraid_error_handler - Error response handlers for a SCSI op 2609 * @cmd: pointer to pmcraid_cmd that has failed 2610 * 2611 * This function determines whether or not to initiate ERP on the affected 2612 * device. This is called from a tasklet, which doesn't hold any locks. 2613 * 2614 * Return value: 2615 * 0 it caller can complete the request, otherwise 1 where in error 2616 * handler itself completes the request and returns the command block 2617 * back to free-pool 2618 */ 2619 static int pmcraid_error_handler(struct pmcraid_cmd *cmd) 2620 { 2621 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd; 2622 struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata; 2623 struct pmcraid_instance *pinstance = cmd->drv_inst; 2624 struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa; 2625 u32 ioasc = le32_to_cpu(ioasa->ioasc); 2626 u32 masked_ioasc = ioasc & PMCRAID_IOASC_SENSE_MASK; 2627 u32 sense_copied = 0; 2628 2629 if (!res) { 2630 pmcraid_info("resource pointer is NULL\n"); 2631 return 0; 2632 } 2633 2634 /* If this was a SCSI read/write command keep count of errors */ 2635 if (SCSI_CMD_TYPE(scsi_cmd->cmnd[0]) == SCSI_READ_CMD) 2636 atomic_inc(&res->read_failures); 2637 else if (SCSI_CMD_TYPE(scsi_cmd->cmnd[0]) == SCSI_WRITE_CMD) 2638 atomic_inc(&res->write_failures); 2639 2640 if (!RES_IS_GSCSI(res->cfg_entry) && 2641 masked_ioasc != PMCRAID_IOASC_HW_DEVICE_BUS_STATUS_ERROR) { 2642 pmcraid_frame_auto_sense(cmd); 2643 } 2644 2645 /* Log IOASC/IOASA information based on user settings */ 2646 pmcraid_ioasc_logger(ioasc, cmd); 2647 2648 switch (masked_ioasc) { 2649 2650 case PMCRAID_IOASC_AC_TERMINATED_BY_HOST: 2651 scsi_cmd->result |= (DID_ABORT << 16); 2652 break; 2653 2654 case PMCRAID_IOASC_IR_INVALID_RESOURCE_HANDLE: 2655 case PMCRAID_IOASC_HW_CANNOT_COMMUNICATE: 2656 scsi_cmd->result |= (DID_NO_CONNECT << 16); 2657 break; 2658 2659 case PMCRAID_IOASC_NR_SYNC_REQUIRED: 2660 res->sync_reqd = 1; 2661 scsi_cmd->result |= (DID_IMM_RETRY << 16); 2662 break; 2663 2664 case PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC: 2665 scsi_cmd->result |= (DID_PASSTHROUGH << 16); 2666 break; 2667 2668 case PMCRAID_IOASC_UA_BUS_WAS_RESET: 2669 case PMCRAID_IOASC_UA_BUS_WAS_RESET_BY_OTHER: 2670 if (!res->reset_progress) 2671 scsi_report_bus_reset(pinstance->host, 2672 scsi_cmd->device->channel); 2673 scsi_cmd->result |= (DID_ERROR << 16); 2674 break; 2675 2676 case PMCRAID_IOASC_HW_DEVICE_BUS_STATUS_ERROR: 2677 scsi_cmd->result |= PMCRAID_IOASC_SENSE_STATUS(ioasc); 2678 res->sync_reqd = 1; 2679 2680 /* if check_condition is not active return with error otherwise 2681 * get/frame the sense buffer 2682 */ 2683 if (PMCRAID_IOASC_SENSE_STATUS(ioasc) != 2684 SAM_STAT_CHECK_CONDITION && 2685 PMCRAID_IOASC_SENSE_STATUS(ioasc) != SAM_STAT_ACA_ACTIVE) 2686 return 0; 2687 2688 /* If we have auto sense data as part of IOASA pass it to 2689 * mid-layer 2690 */ 2691 if (ioasa->auto_sense_length != 0) { 2692 short sense_len = le16_to_cpu(ioasa->auto_sense_length); 2693 int data_size = min_t(u16, sense_len, 2694 SCSI_SENSE_BUFFERSIZE); 2695 2696 memcpy(scsi_cmd->sense_buffer, 2697 ioasa->sense_data, 2698 data_size); 2699 sense_copied = 1; 2700 } 2701 2702 if (RES_IS_GSCSI(res->cfg_entry)) 2703 pmcraid_cancel_all(cmd, sense_copied); 2704 else if (sense_copied) 2705 pmcraid_erp_done(cmd); 2706 else 2707 pmcraid_request_sense(cmd); 2708 2709 return 1; 2710 2711 case PMCRAID_IOASC_NR_INIT_CMD_REQUIRED: 2712 break; 2713 2714 default: 2715 if (PMCRAID_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR) 2716 scsi_cmd->result |= (DID_ERROR << 16); 2717 break; 2718 } 2719 return 0; 2720 } 2721 2722 /** 2723 * pmcraid_reset_device - device reset handler functions 2724 * 2725 * @scsi_cmd: scsi command struct 2726 * @modifier: reset modifier indicating the reset sequence to be performed 2727 * 2728 * This function issues a device reset to the affected device. 2729 * A LUN reset will be sent to the device first. If that does 2730 * not work, a target reset will be sent. 2731 * 2732 * Return value: 2733 * SUCCESS / FAILED 2734 */ 2735 static int pmcraid_reset_device( 2736 struct scsi_cmnd *scsi_cmd, 2737 unsigned long timeout, 2738 u8 modifier 2739 ) 2740 { 2741 struct pmcraid_cmd *cmd; 2742 struct pmcraid_instance *pinstance; 2743 struct pmcraid_resource_entry *res; 2744 struct pmcraid_ioarcb *ioarcb; 2745 unsigned long lock_flags; 2746 u32 ioasc; 2747 2748 pinstance = 2749 (struct pmcraid_instance *)scsi_cmd->device->host->hostdata; 2750 res = scsi_cmd->device->hostdata; 2751 2752 if (!res) { 2753 sdev_printk(KERN_ERR, scsi_cmd->device, 2754 "reset_device: NULL resource pointer\n"); 2755 return FAILED; 2756 } 2757 2758 /* If adapter is currently going through reset/reload, return failed. 2759 * This will force the mid-layer to call _eh_bus/host reset, which 2760 * will then go to sleep and wait for the reset to complete 2761 */ 2762 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 2763 if (pinstance->ioa_reset_in_progress || 2764 pinstance->ioa_state == IOA_STATE_DEAD) { 2765 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 2766 return FAILED; 2767 } 2768 2769 res->reset_progress = 1; 2770 pmcraid_info("Resetting %s resource with addr %x\n", 2771 ((modifier & RESET_DEVICE_LUN) ? "LUN" : 2772 ((modifier & RESET_DEVICE_TARGET) ? "TARGET" : "BUS")), 2773 le32_to_cpu(res->cfg_entry.resource_address)); 2774 2775 /* get a free cmd block */ 2776 cmd = pmcraid_get_free_cmd(pinstance); 2777 2778 if (cmd == NULL) { 2779 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 2780 pmcraid_err("%s: no cmd blocks are available\n", __func__); 2781 return FAILED; 2782 } 2783 2784 ioarcb = &cmd->ioa_cb->ioarcb; 2785 ioarcb->resource_handle = res->cfg_entry.resource_handle; 2786 ioarcb->request_type = REQ_TYPE_IOACMD; 2787 ioarcb->cdb[0] = PMCRAID_RESET_DEVICE; 2788 2789 /* Initialize reset modifier bits */ 2790 if (modifier) 2791 modifier = ENABLE_RESET_MODIFIER | modifier; 2792 2793 ioarcb->cdb[1] = modifier; 2794 2795 init_completion(&cmd->wait_for_completion); 2796 cmd->completion_req = 1; 2797 2798 pmcraid_info("cmd(CDB[0] = %x) for %x with index = %d\n", 2799 cmd->ioa_cb->ioarcb.cdb[0], 2800 le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle), 2801 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2); 2802 2803 pmcraid_send_cmd(cmd, 2804 pmcraid_internal_done, 2805 timeout, 2806 pmcraid_timeout_handler); 2807 2808 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 2809 2810 /* RESET_DEVICE command completes after all pending IOARCBs are 2811 * completed. Once this command is completed, pmcraind_internal_done 2812 * will wake up the 'completion' queue. 2813 */ 2814 wait_for_completion(&cmd->wait_for_completion); 2815 2816 /* complete the command here itself and return the command block 2817 * to free list 2818 */ 2819 pmcraid_return_cmd(cmd); 2820 res->reset_progress = 0; 2821 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc); 2822 2823 /* set the return value based on the returned ioasc */ 2824 return PMCRAID_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS; 2825 } 2826 2827 /** 2828 * _pmcraid_io_done - helper for pmcraid_io_done function 2829 * 2830 * @cmd: pointer to pmcraid command struct 2831 * @reslen: residual data length to be set in the ioasa 2832 * @ioasc: ioasc either returned by IOA or set by driver itself. 2833 * 2834 * This function is invoked by pmcraid_io_done to complete mid-layer 2835 * scsi ops. 2836 * 2837 * Return value: 2838 * 0 if caller is required to return it to free_pool. Returns 1 if 2839 * caller need not worry about freeing command block as error handler 2840 * will take care of that. 2841 */ 2842 2843 static int _pmcraid_io_done(struct pmcraid_cmd *cmd, int reslen, int ioasc) 2844 { 2845 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd; 2846 int rc = 0; 2847 2848 scsi_set_resid(scsi_cmd, reslen); 2849 2850 pmcraid_info("response(%d) CDB[0] = %x ioasc:result: %x:%x\n", 2851 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2, 2852 cmd->ioa_cb->ioarcb.cdb[0], 2853 ioasc, scsi_cmd->result); 2854 2855 if (PMCRAID_IOASC_SENSE_KEY(ioasc) != 0) 2856 rc = pmcraid_error_handler(cmd); 2857 2858 if (rc == 0) { 2859 scsi_dma_unmap(scsi_cmd); 2860 scsi_cmd->scsi_done(scsi_cmd); 2861 } 2862 2863 return rc; 2864 } 2865 2866 /** 2867 * pmcraid_io_done - SCSI completion function 2868 * 2869 * @cmd: pointer to pmcraid command struct 2870 * 2871 * This function is invoked by tasklet/mid-layer error handler to completing 2872 * the SCSI ops sent from mid-layer. 2873 * 2874 * Return value 2875 * none 2876 */ 2877 2878 static void pmcraid_io_done(struct pmcraid_cmd *cmd) 2879 { 2880 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc); 2881 u32 reslen = le32_to_cpu(cmd->ioa_cb->ioasa.residual_data_length); 2882 2883 if (_pmcraid_io_done(cmd, reslen, ioasc) == 0) 2884 pmcraid_return_cmd(cmd); 2885 } 2886 2887 /** 2888 * pmcraid_abort_cmd - Aborts a single IOARCB already submitted to IOA 2889 * 2890 * @cmd: command block of the command to be aborted 2891 * 2892 * Return Value: 2893 * returns pointer to command structure used as cancelling cmd 2894 */ 2895 static struct pmcraid_cmd *pmcraid_abort_cmd(struct pmcraid_cmd *cmd) 2896 { 2897 struct pmcraid_cmd *cancel_cmd; 2898 struct pmcraid_instance *pinstance; 2899 struct pmcraid_resource_entry *res; 2900 2901 pinstance = (struct pmcraid_instance *)cmd->drv_inst; 2902 res = cmd->scsi_cmd->device->hostdata; 2903 2904 cancel_cmd = pmcraid_get_free_cmd(pinstance); 2905 2906 if (cancel_cmd == NULL) { 2907 pmcraid_err("%s: no cmd blocks are available\n", __func__); 2908 return NULL; 2909 } 2910 2911 pmcraid_prepare_cancel_cmd(cancel_cmd, cmd); 2912 2913 pmcraid_info("aborting command CDB[0]= %x with index = %d\n", 2914 cmd->ioa_cb->ioarcb.cdb[0], 2915 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2); 2916 2917 init_completion(&cancel_cmd->wait_for_completion); 2918 cancel_cmd->completion_req = 1; 2919 2920 pmcraid_info("command (%d) CDB[0] = %x for %x\n", 2921 le32_to_cpu(cancel_cmd->ioa_cb->ioarcb.response_handle) >> 2, 2922 cancel_cmd->ioa_cb->ioarcb.cdb[0], 2923 le32_to_cpu(cancel_cmd->ioa_cb->ioarcb.resource_handle)); 2924 2925 pmcraid_send_cmd(cancel_cmd, 2926 pmcraid_internal_done, 2927 PMCRAID_INTERNAL_TIMEOUT, 2928 pmcraid_timeout_handler); 2929 return cancel_cmd; 2930 } 2931 2932 /** 2933 * pmcraid_abort_complete - Waits for ABORT TASK completion 2934 * 2935 * @cancel_cmd: command block use as cancelling command 2936 * 2937 * Return Value: 2938 * returns SUCCESS if ABORT TASK has good completion 2939 * otherwise FAILED 2940 */ 2941 static int pmcraid_abort_complete(struct pmcraid_cmd *cancel_cmd) 2942 { 2943 struct pmcraid_resource_entry *res; 2944 u32 ioasc; 2945 2946 wait_for_completion(&cancel_cmd->wait_for_completion); 2947 res = cancel_cmd->res; 2948 cancel_cmd->res = NULL; 2949 ioasc = le32_to_cpu(cancel_cmd->ioa_cb->ioasa.ioasc); 2950 2951 /* If the abort task is not timed out we will get a Good completion 2952 * as sense_key, otherwise we may get one the following responses 2953 * due to subsequent bus reset or device reset. In case IOASC is 2954 * NR_SYNC_REQUIRED, set sync_reqd flag for the corresponding resource 2955 */ 2956 if (ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET || 2957 ioasc == PMCRAID_IOASC_NR_SYNC_REQUIRED) { 2958 if (ioasc == PMCRAID_IOASC_NR_SYNC_REQUIRED) 2959 res->sync_reqd = 1; 2960 ioasc = 0; 2961 } 2962 2963 /* complete the command here itself */ 2964 pmcraid_return_cmd(cancel_cmd); 2965 return PMCRAID_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS; 2966 } 2967 2968 /** 2969 * pmcraid_eh_abort_handler - entry point for aborting a single task on errors 2970 * 2971 * @scsi_cmd: scsi command struct given by mid-layer. When this is called 2972 * mid-layer ensures that no other commands are queued. This 2973 * never gets called under interrupt, but a separate eh thread. 2974 * 2975 * Return value: 2976 * SUCCESS / FAILED 2977 */ 2978 static int pmcraid_eh_abort_handler(struct scsi_cmnd *scsi_cmd) 2979 { 2980 struct pmcraid_instance *pinstance; 2981 struct pmcraid_cmd *cmd; 2982 struct pmcraid_resource_entry *res; 2983 unsigned long host_lock_flags; 2984 unsigned long pending_lock_flags; 2985 struct pmcraid_cmd *cancel_cmd = NULL; 2986 int cmd_found = 0; 2987 int rc = FAILED; 2988 2989 pinstance = 2990 (struct pmcraid_instance *)scsi_cmd->device->host->hostdata; 2991 2992 scmd_printk(KERN_INFO, scsi_cmd, 2993 "I/O command timed out, aborting it.\n"); 2994 2995 res = scsi_cmd->device->hostdata; 2996 2997 if (res == NULL) 2998 return rc; 2999 3000 /* If we are currently going through reset/reload, return failed. 3001 * This will force the mid-layer to eventually call 3002 * pmcraid_eh_host_reset which will then go to sleep and wait for the 3003 * reset to complete 3004 */ 3005 spin_lock_irqsave(pinstance->host->host_lock, host_lock_flags); 3006 3007 if (pinstance->ioa_reset_in_progress || 3008 pinstance->ioa_state == IOA_STATE_DEAD) { 3009 spin_unlock_irqrestore(pinstance->host->host_lock, 3010 host_lock_flags); 3011 return rc; 3012 } 3013 3014 /* loop over pending cmd list to find cmd corresponding to this 3015 * scsi_cmd. Note that this command might not have been completed 3016 * already. locking: all pending commands are protected with 3017 * pending_pool_lock. 3018 */ 3019 spin_lock_irqsave(&pinstance->pending_pool_lock, pending_lock_flags); 3020 list_for_each_entry(cmd, &pinstance->pending_cmd_pool, free_list) { 3021 3022 if (cmd->scsi_cmd == scsi_cmd) { 3023 cmd_found = 1; 3024 break; 3025 } 3026 } 3027 3028 spin_unlock_irqrestore(&pinstance->pending_pool_lock, 3029 pending_lock_flags); 3030 3031 /* If the command to be aborted was given to IOA and still pending with 3032 * it, send ABORT_TASK to abort this and wait for its completion 3033 */ 3034 if (cmd_found) 3035 cancel_cmd = pmcraid_abort_cmd(cmd); 3036 3037 spin_unlock_irqrestore(pinstance->host->host_lock, 3038 host_lock_flags); 3039 3040 if (cancel_cmd) { 3041 cancel_cmd->res = cmd->scsi_cmd->device->hostdata; 3042 rc = pmcraid_abort_complete(cancel_cmd); 3043 } 3044 3045 return cmd_found ? rc : SUCCESS; 3046 } 3047 3048 /** 3049 * pmcraid_eh_xxxx_reset_handler - bus/target/device reset handler callbacks 3050 * 3051 * @scmd: pointer to scsi_cmd that was sent to the resource to be reset. 3052 * 3053 * All these routines invokve pmcraid_reset_device with appropriate parameters. 3054 * Since these are called from mid-layer EH thread, no other IO will be queued 3055 * to the resource being reset. However, control path (IOCTL) may be active so 3056 * it is necessary to synchronize IOARRIN writes which pmcraid_reset_device 3057 * takes care by locking/unlocking host_lock. 3058 * 3059 * Return value 3060 * SUCCESS or FAILED 3061 */ 3062 static int pmcraid_eh_device_reset_handler(struct scsi_cmnd *scmd) 3063 { 3064 scmd_printk(KERN_INFO, scmd, 3065 "resetting device due to an I/O command timeout.\n"); 3066 return pmcraid_reset_device(scmd, 3067 PMCRAID_INTERNAL_TIMEOUT, 3068 RESET_DEVICE_LUN); 3069 } 3070 3071 static int pmcraid_eh_bus_reset_handler(struct scsi_cmnd *scmd) 3072 { 3073 scmd_printk(KERN_INFO, scmd, 3074 "Doing bus reset due to an I/O command timeout.\n"); 3075 return pmcraid_reset_device(scmd, 3076 PMCRAID_RESET_BUS_TIMEOUT, 3077 RESET_DEVICE_BUS); 3078 } 3079 3080 static int pmcraid_eh_target_reset_handler(struct scsi_cmnd *scmd) 3081 { 3082 scmd_printk(KERN_INFO, scmd, 3083 "Doing target reset due to an I/O command timeout.\n"); 3084 return pmcraid_reset_device(scmd, 3085 PMCRAID_INTERNAL_TIMEOUT, 3086 RESET_DEVICE_TARGET); 3087 } 3088 3089 /** 3090 * pmcraid_eh_host_reset_handler - adapter reset handler callback 3091 * 3092 * @scmd: pointer to scsi_cmd that was sent to a resource of adapter 3093 * 3094 * Initiates adapter reset to bring it up to operational state 3095 * 3096 * Return value 3097 * SUCCESS or FAILED 3098 */ 3099 static int pmcraid_eh_host_reset_handler(struct scsi_cmnd *scmd) 3100 { 3101 unsigned long interval = 10000; /* 10 seconds interval */ 3102 int waits = jiffies_to_msecs(PMCRAID_RESET_HOST_TIMEOUT) / interval; 3103 struct pmcraid_instance *pinstance = 3104 (struct pmcraid_instance *)(scmd->device->host->hostdata); 3105 3106 3107 /* wait for an additional 150 seconds just in case firmware could come 3108 * up and if it could complete all the pending commands excluding the 3109 * two HCAM (CCN and LDN). 3110 */ 3111 while (waits--) { 3112 if (atomic_read(&pinstance->outstanding_cmds) <= 3113 PMCRAID_MAX_HCAM_CMD) 3114 return SUCCESS; 3115 msleep(interval); 3116 } 3117 3118 dev_err(&pinstance->pdev->dev, 3119 "Adapter being reset due to an I/O command timeout.\n"); 3120 return pmcraid_reset_bringup(pinstance) == 0 ? SUCCESS : FAILED; 3121 } 3122 3123 /** 3124 * pmcraid_init_ioadls - initializes IOADL related fields in IOARCB 3125 * @cmd: pmcraid command struct 3126 * @sgcount: count of scatter-gather elements 3127 * 3128 * Return value 3129 * returns pointer pmcraid_ioadl_desc, initialized to point to internal 3130 * or external IOADLs 3131 */ 3132 static struct pmcraid_ioadl_desc * 3133 pmcraid_init_ioadls(struct pmcraid_cmd *cmd, int sgcount) 3134 { 3135 struct pmcraid_ioadl_desc *ioadl; 3136 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 3137 int ioadl_count = 0; 3138 3139 if (ioarcb->add_cmd_param_length) 3140 ioadl_count = DIV_ROUND_UP(le16_to_cpu(ioarcb->add_cmd_param_length), 16); 3141 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc) * sgcount); 3142 3143 if ((sgcount + ioadl_count) > (ARRAY_SIZE(ioarcb->add_data.u.ioadl))) { 3144 /* external ioadls start at offset 0x80 from control_block 3145 * structure, re-using 24 out of 27 ioadls part of IOARCB. 3146 * It is necessary to indicate to firmware that driver is 3147 * using ioadls to be treated as external to IOARCB. 3148 */ 3149 ioarcb->ioarcb_bus_addr &= cpu_to_le64(~(0x1FULL)); 3150 ioarcb->ioadl_bus_addr = 3151 cpu_to_le64((cmd->ioa_cb_bus_addr) + 3152 offsetof(struct pmcraid_ioarcb, 3153 add_data.u.ioadl[3])); 3154 ioadl = &ioarcb->add_data.u.ioadl[3]; 3155 } else { 3156 ioarcb->ioadl_bus_addr = 3157 cpu_to_le64((cmd->ioa_cb_bus_addr) + 3158 offsetof(struct pmcraid_ioarcb, 3159 add_data.u.ioadl[ioadl_count])); 3160 3161 ioadl = &ioarcb->add_data.u.ioadl[ioadl_count]; 3162 ioarcb->ioarcb_bus_addr |= 3163 cpu_to_le64(DIV_ROUND_CLOSEST(sgcount + ioadl_count, 8)); 3164 } 3165 3166 return ioadl; 3167 } 3168 3169 /** 3170 * pmcraid_build_ioadl - Build a scatter/gather list and map the buffer 3171 * @pinstance: pointer to adapter instance structure 3172 * @cmd: pmcraid command struct 3173 * 3174 * This function is invoked by queuecommand entry point while sending a command 3175 * to firmware. This builds ioadl descriptors and sets up ioarcb fields. 3176 * 3177 * Return value: 3178 * 0 on success or -1 on failure 3179 */ 3180 static int pmcraid_build_ioadl( 3181 struct pmcraid_instance *pinstance, 3182 struct pmcraid_cmd *cmd 3183 ) 3184 { 3185 int i, nseg; 3186 struct scatterlist *sglist; 3187 3188 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd; 3189 struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb); 3190 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl; 3191 3192 u32 length = scsi_bufflen(scsi_cmd); 3193 3194 if (!length) 3195 return 0; 3196 3197 nseg = scsi_dma_map(scsi_cmd); 3198 3199 if (nseg < 0) { 3200 scmd_printk(KERN_ERR, scsi_cmd, "scsi_map_dma failed!\n"); 3201 return -1; 3202 } else if (nseg > PMCRAID_MAX_IOADLS) { 3203 scsi_dma_unmap(scsi_cmd); 3204 scmd_printk(KERN_ERR, scsi_cmd, 3205 "sg count is (%d) more than allowed!\n", nseg); 3206 return -1; 3207 } 3208 3209 /* Initialize IOARCB data transfer length fields */ 3210 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) 3211 ioarcb->request_flags0 |= TRANSFER_DIR_WRITE; 3212 3213 ioarcb->request_flags0 |= NO_LINK_DESCS; 3214 ioarcb->data_transfer_length = cpu_to_le32(length); 3215 ioadl = pmcraid_init_ioadls(cmd, nseg); 3216 3217 /* Initialize IOADL descriptor addresses */ 3218 scsi_for_each_sg(scsi_cmd, sglist, nseg, i) { 3219 ioadl[i].data_len = cpu_to_le32(sg_dma_len(sglist)); 3220 ioadl[i].address = cpu_to_le64(sg_dma_address(sglist)); 3221 ioadl[i].flags = 0; 3222 } 3223 /* setup last descriptor */ 3224 ioadl[i - 1].flags = IOADL_FLAGS_LAST_DESC; 3225 3226 return 0; 3227 } 3228 3229 /** 3230 * pmcraid_free_sglist - Frees an allocated SG buffer list 3231 * @sglist: scatter/gather list pointer 3232 * 3233 * Free a DMA'able memory previously allocated with pmcraid_alloc_sglist 3234 * 3235 * Return value: 3236 * none 3237 */ 3238 static void pmcraid_free_sglist(struct pmcraid_sglist *sglist) 3239 { 3240 int i; 3241 3242 for (i = 0; i < sglist->num_sg; i++) 3243 __free_pages(sg_page(&(sglist->scatterlist[i])), 3244 sglist->order); 3245 3246 kfree(sglist); 3247 } 3248 3249 /** 3250 * pmcraid_alloc_sglist - Allocates memory for a SG list 3251 * @buflen: buffer length 3252 * 3253 * Allocates a DMA'able buffer in chunks and assembles a scatter/gather 3254 * list. 3255 * 3256 * Return value 3257 * pointer to sglist / NULL on failure 3258 */ 3259 static struct pmcraid_sglist *pmcraid_alloc_sglist(int buflen) 3260 { 3261 struct pmcraid_sglist *sglist; 3262 struct scatterlist *scatterlist; 3263 struct page *page; 3264 int num_elem, i, j; 3265 int sg_size; 3266 int order; 3267 int bsize_elem; 3268 3269 sg_size = buflen / (PMCRAID_MAX_IOADLS - 1); 3270 order = (sg_size > 0) ? get_order(sg_size) : 0; 3271 bsize_elem = PAGE_SIZE * (1 << order); 3272 3273 /* Determine the actual number of sg entries needed */ 3274 if (buflen % bsize_elem) 3275 num_elem = (buflen / bsize_elem) + 1; 3276 else 3277 num_elem = buflen / bsize_elem; 3278 3279 /* Allocate a scatter/gather list for the DMA */ 3280 sglist = kzalloc(sizeof(struct pmcraid_sglist) + 3281 (sizeof(struct scatterlist) * (num_elem - 1)), 3282 GFP_KERNEL); 3283 3284 if (sglist == NULL) 3285 return NULL; 3286 3287 scatterlist = sglist->scatterlist; 3288 sg_init_table(scatterlist, num_elem); 3289 sglist->order = order; 3290 sglist->num_sg = num_elem; 3291 sg_size = buflen; 3292 3293 for (i = 0; i < num_elem; i++) { 3294 page = alloc_pages(GFP_KERNEL|GFP_DMA|__GFP_ZERO, order); 3295 if (!page) { 3296 for (j = i - 1; j >= 0; j--) 3297 __free_pages(sg_page(&scatterlist[j]), order); 3298 kfree(sglist); 3299 return NULL; 3300 } 3301 3302 sg_set_page(&scatterlist[i], page, 3303 sg_size < bsize_elem ? sg_size : bsize_elem, 0); 3304 sg_size -= bsize_elem; 3305 } 3306 3307 return sglist; 3308 } 3309 3310 /** 3311 * pmcraid_copy_sglist - Copy user buffer to kernel buffer's SG list 3312 * @sglist: scatter/gather list pointer 3313 * @buffer: buffer pointer 3314 * @len: buffer length 3315 * @direction: data transfer direction 3316 * 3317 * Copy a user buffer into a buffer allocated by pmcraid_alloc_sglist 3318 * 3319 * Return value: 3320 * 0 on success / other on failure 3321 */ 3322 static int pmcraid_copy_sglist( 3323 struct pmcraid_sglist *sglist, 3324 void __user *buffer, 3325 u32 len, 3326 int direction 3327 ) 3328 { 3329 struct scatterlist *scatterlist; 3330 void *kaddr; 3331 int bsize_elem; 3332 int i; 3333 int rc = 0; 3334 3335 /* Determine the actual number of bytes per element */ 3336 bsize_elem = PAGE_SIZE * (1 << sglist->order); 3337 3338 scatterlist = sglist->scatterlist; 3339 3340 for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) { 3341 struct page *page = sg_page(&scatterlist[i]); 3342 3343 kaddr = kmap(page); 3344 if (direction == DMA_TO_DEVICE) 3345 rc = copy_from_user(kaddr, buffer, bsize_elem); 3346 else 3347 rc = copy_to_user(buffer, kaddr, bsize_elem); 3348 3349 kunmap(page); 3350 3351 if (rc) { 3352 pmcraid_err("failed to copy user data into sg list\n"); 3353 return -EFAULT; 3354 } 3355 3356 scatterlist[i].length = bsize_elem; 3357 } 3358 3359 if (len % bsize_elem) { 3360 struct page *page = sg_page(&scatterlist[i]); 3361 3362 kaddr = kmap(page); 3363 3364 if (direction == DMA_TO_DEVICE) 3365 rc = copy_from_user(kaddr, buffer, len % bsize_elem); 3366 else 3367 rc = copy_to_user(buffer, kaddr, len % bsize_elem); 3368 3369 kunmap(page); 3370 3371 scatterlist[i].length = len % bsize_elem; 3372 } 3373 3374 if (rc) { 3375 pmcraid_err("failed to copy user data into sg list\n"); 3376 rc = -EFAULT; 3377 } 3378 3379 return rc; 3380 } 3381 3382 /** 3383 * pmcraid_queuecommand - Queue a mid-layer request 3384 * @scsi_cmd: scsi command struct 3385 * @done: done function 3386 * 3387 * This function queues a request generated by the mid-layer. Midlayer calls 3388 * this routine within host->lock. Some of the functions called by queuecommand 3389 * would use cmd block queue locks (free_pool_lock and pending_pool_lock) 3390 * 3391 * Return value: 3392 * 0 on success 3393 * SCSI_MLQUEUE_DEVICE_BUSY if device is busy 3394 * SCSI_MLQUEUE_HOST_BUSY if host is busy 3395 */ 3396 static int pmcraid_queuecommand_lck( 3397 struct scsi_cmnd *scsi_cmd, 3398 void (*done) (struct scsi_cmnd *) 3399 ) 3400 { 3401 struct pmcraid_instance *pinstance; 3402 struct pmcraid_resource_entry *res; 3403 struct pmcraid_ioarcb *ioarcb; 3404 struct pmcraid_cmd *cmd; 3405 u32 fw_version; 3406 int rc = 0; 3407 3408 pinstance = 3409 (struct pmcraid_instance *)scsi_cmd->device->host->hostdata; 3410 fw_version = be16_to_cpu(pinstance->inq_data->fw_version); 3411 scsi_cmd->scsi_done = done; 3412 res = scsi_cmd->device->hostdata; 3413 scsi_cmd->result = (DID_OK << 16); 3414 3415 /* if adapter is marked as dead, set result to DID_NO_CONNECT complete 3416 * the command 3417 */ 3418 if (pinstance->ioa_state == IOA_STATE_DEAD) { 3419 pmcraid_info("IOA is dead, but queuecommand is scheduled\n"); 3420 scsi_cmd->result = (DID_NO_CONNECT << 16); 3421 scsi_cmd->scsi_done(scsi_cmd); 3422 return 0; 3423 } 3424 3425 /* If IOA reset is in progress, can't queue the commands */ 3426 if (pinstance->ioa_reset_in_progress) 3427 return SCSI_MLQUEUE_HOST_BUSY; 3428 3429 /* Firmware doesn't support SYNCHRONIZE_CACHE command (0x35), complete 3430 * the command here itself with success return 3431 */ 3432 if (scsi_cmd->cmnd[0] == SYNCHRONIZE_CACHE) { 3433 pmcraid_info("SYNC_CACHE(0x35), completing in driver itself\n"); 3434 scsi_cmd->scsi_done(scsi_cmd); 3435 return 0; 3436 } 3437 3438 /* initialize the command and IOARCB to be sent to IOA */ 3439 cmd = pmcraid_get_free_cmd(pinstance); 3440 3441 if (cmd == NULL) { 3442 pmcraid_err("free command block is not available\n"); 3443 return SCSI_MLQUEUE_HOST_BUSY; 3444 } 3445 3446 cmd->scsi_cmd = scsi_cmd; 3447 ioarcb = &(cmd->ioa_cb->ioarcb); 3448 memcpy(ioarcb->cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len); 3449 ioarcb->resource_handle = res->cfg_entry.resource_handle; 3450 ioarcb->request_type = REQ_TYPE_SCSI; 3451 3452 /* set hrrq number where the IOA should respond to. Note that all cmds 3453 * generated internally uses hrrq_id 0, exception to this is the cmd 3454 * block of scsi_cmd which is re-used (e.g. cancel/abort), which uses 3455 * hrrq_id assigned here in queuecommand 3456 */ 3457 ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) % 3458 pinstance->num_hrrq; 3459 cmd->cmd_done = pmcraid_io_done; 3460 3461 if (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry)) { 3462 if (scsi_cmd->underflow == 0) 3463 ioarcb->request_flags0 |= INHIBIT_UL_CHECK; 3464 3465 if (res->sync_reqd) { 3466 ioarcb->request_flags0 |= SYNC_COMPLETE; 3467 res->sync_reqd = 0; 3468 } 3469 3470 ioarcb->request_flags0 |= NO_LINK_DESCS; 3471 3472 if (scsi_cmd->flags & SCMD_TAGGED) 3473 ioarcb->request_flags1 |= TASK_TAG_SIMPLE; 3474 3475 if (RES_IS_GSCSI(res->cfg_entry)) 3476 ioarcb->request_flags1 |= DELAY_AFTER_RESET; 3477 } 3478 3479 rc = pmcraid_build_ioadl(pinstance, cmd); 3480 3481 pmcraid_info("command (%d) CDB[0] = %x for %x:%x:%x:%x\n", 3482 le32_to_cpu(ioarcb->response_handle) >> 2, 3483 scsi_cmd->cmnd[0], pinstance->host->unique_id, 3484 RES_IS_VSET(res->cfg_entry) ? PMCRAID_VSET_BUS_ID : 3485 PMCRAID_PHYS_BUS_ID, 3486 RES_IS_VSET(res->cfg_entry) ? 3487 (fw_version <= PMCRAID_FW_VERSION_1 ? 3488 res->cfg_entry.unique_flags1 : 3489 le16_to_cpu(res->cfg_entry.array_id) & 0xFF) : 3490 RES_TARGET(res->cfg_entry.resource_address), 3491 RES_LUN(res->cfg_entry.resource_address)); 3492 3493 if (likely(rc == 0)) { 3494 _pmcraid_fire_command(cmd); 3495 } else { 3496 pmcraid_err("queuecommand could not build ioadl\n"); 3497 pmcraid_return_cmd(cmd); 3498 rc = SCSI_MLQUEUE_HOST_BUSY; 3499 } 3500 3501 return rc; 3502 } 3503 3504 static DEF_SCSI_QCMD(pmcraid_queuecommand) 3505 3506 /** 3507 * pmcraid_open -char node "open" entry, allowed only users with admin access 3508 */ 3509 static int pmcraid_chr_open(struct inode *inode, struct file *filep) 3510 { 3511 struct pmcraid_instance *pinstance; 3512 3513 if (!capable(CAP_SYS_ADMIN)) 3514 return -EACCES; 3515 3516 /* Populate adapter instance * pointer for use by ioctl */ 3517 pinstance = container_of(inode->i_cdev, struct pmcraid_instance, cdev); 3518 filep->private_data = pinstance; 3519 3520 return 0; 3521 } 3522 3523 /** 3524 * pmcraid_fasync - Async notifier registration from applications 3525 * 3526 * This function adds the calling process to a driver global queue. When an 3527 * event occurs, SIGIO will be sent to all processes in this queue. 3528 */ 3529 static int pmcraid_chr_fasync(int fd, struct file *filep, int mode) 3530 { 3531 struct pmcraid_instance *pinstance; 3532 int rc; 3533 3534 pinstance = filep->private_data; 3535 mutex_lock(&pinstance->aen_queue_lock); 3536 rc = fasync_helper(fd, filep, mode, &pinstance->aen_queue); 3537 mutex_unlock(&pinstance->aen_queue_lock); 3538 3539 return rc; 3540 } 3541 3542 3543 /** 3544 * pmcraid_build_passthrough_ioadls - builds SG elements for passthrough 3545 * commands sent over IOCTL interface 3546 * 3547 * @cmd : pointer to struct pmcraid_cmd 3548 * @buflen : length of the request buffer 3549 * @direction : data transfer direction 3550 * 3551 * Return value 3552 * 0 on success, non-zero error code on failure 3553 */ 3554 static int pmcraid_build_passthrough_ioadls( 3555 struct pmcraid_cmd *cmd, 3556 int buflen, 3557 int direction 3558 ) 3559 { 3560 struct pmcraid_sglist *sglist = NULL; 3561 struct scatterlist *sg = NULL; 3562 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 3563 struct pmcraid_ioadl_desc *ioadl; 3564 int i; 3565 3566 sglist = pmcraid_alloc_sglist(buflen); 3567 3568 if (!sglist) { 3569 pmcraid_err("can't allocate memory for passthrough SGls\n"); 3570 return -ENOMEM; 3571 } 3572 3573 sglist->num_dma_sg = pci_map_sg(cmd->drv_inst->pdev, 3574 sglist->scatterlist, 3575 sglist->num_sg, direction); 3576 3577 if (!sglist->num_dma_sg || sglist->num_dma_sg > PMCRAID_MAX_IOADLS) { 3578 dev_err(&cmd->drv_inst->pdev->dev, 3579 "Failed to map passthrough buffer!\n"); 3580 pmcraid_free_sglist(sglist); 3581 return -EIO; 3582 } 3583 3584 cmd->sglist = sglist; 3585 ioarcb->request_flags0 |= NO_LINK_DESCS; 3586 3587 ioadl = pmcraid_init_ioadls(cmd, sglist->num_dma_sg); 3588 3589 /* Initialize IOADL descriptor addresses */ 3590 for_each_sg(sglist->scatterlist, sg, sglist->num_dma_sg, i) { 3591 ioadl[i].data_len = cpu_to_le32(sg_dma_len(sg)); 3592 ioadl[i].address = cpu_to_le64(sg_dma_address(sg)); 3593 ioadl[i].flags = 0; 3594 } 3595 3596 /* setup the last descriptor */ 3597 ioadl[i - 1].flags = IOADL_FLAGS_LAST_DESC; 3598 3599 return 0; 3600 } 3601 3602 3603 /** 3604 * pmcraid_release_passthrough_ioadls - release passthrough ioadls 3605 * 3606 * @cmd: pointer to struct pmcraid_cmd for which ioadls were allocated 3607 * @buflen: size of the request buffer 3608 * @direction: data transfer direction 3609 * 3610 * Return value 3611 * 0 on success, non-zero error code on failure 3612 */ 3613 static void pmcraid_release_passthrough_ioadls( 3614 struct pmcraid_cmd *cmd, 3615 int buflen, 3616 int direction 3617 ) 3618 { 3619 struct pmcraid_sglist *sglist = cmd->sglist; 3620 3621 if (buflen > 0) { 3622 pci_unmap_sg(cmd->drv_inst->pdev, 3623 sglist->scatterlist, 3624 sglist->num_sg, 3625 direction); 3626 pmcraid_free_sglist(sglist); 3627 cmd->sglist = NULL; 3628 } 3629 } 3630 3631 /** 3632 * pmcraid_ioctl_passthrough - handling passthrough IOCTL commands 3633 * 3634 * @pinstance: pointer to adapter instance structure 3635 * @cmd: ioctl code 3636 * @arg: pointer to pmcraid_passthrough_buffer user buffer 3637 * 3638 * Return value 3639 * 0 on success, non-zero error code on failure 3640 */ 3641 static long pmcraid_ioctl_passthrough( 3642 struct pmcraid_instance *pinstance, 3643 unsigned int ioctl_cmd, 3644 unsigned int buflen, 3645 void __user *arg 3646 ) 3647 { 3648 struct pmcraid_passthrough_ioctl_buffer *buffer; 3649 struct pmcraid_ioarcb *ioarcb; 3650 struct pmcraid_cmd *cmd; 3651 struct pmcraid_cmd *cancel_cmd; 3652 void __user *request_buffer; 3653 unsigned long request_offset; 3654 unsigned long lock_flags; 3655 void __user *ioasa; 3656 u32 ioasc; 3657 int request_size; 3658 int buffer_size; 3659 u8 access, direction; 3660 int rc = 0; 3661 3662 /* If IOA reset is in progress, wait 10 secs for reset to complete */ 3663 if (pinstance->ioa_reset_in_progress) { 3664 rc = wait_event_interruptible_timeout( 3665 pinstance->reset_wait_q, 3666 !pinstance->ioa_reset_in_progress, 3667 msecs_to_jiffies(10000)); 3668 3669 if (!rc) 3670 return -ETIMEDOUT; 3671 else if (rc < 0) 3672 return -ERESTARTSYS; 3673 } 3674 3675 /* If adapter is not in operational state, return error */ 3676 if (pinstance->ioa_state != IOA_STATE_OPERATIONAL) { 3677 pmcraid_err("IOA is not operational\n"); 3678 return -ENOTTY; 3679 } 3680 3681 buffer_size = sizeof(struct pmcraid_passthrough_ioctl_buffer); 3682 buffer = kmalloc(buffer_size, GFP_KERNEL); 3683 3684 if (!buffer) { 3685 pmcraid_err("no memory for passthrough buffer\n"); 3686 return -ENOMEM; 3687 } 3688 3689 request_offset = 3690 offsetof(struct pmcraid_passthrough_ioctl_buffer, request_buffer); 3691 3692 request_buffer = arg + request_offset; 3693 3694 rc = copy_from_user(buffer, arg, 3695 sizeof(struct pmcraid_passthrough_ioctl_buffer)); 3696 3697 ioasa = arg + offsetof(struct pmcraid_passthrough_ioctl_buffer, ioasa); 3698 3699 if (rc) { 3700 pmcraid_err("ioctl: can't copy passthrough buffer\n"); 3701 rc = -EFAULT; 3702 goto out_free_buffer; 3703 } 3704 3705 request_size = le32_to_cpu(buffer->ioarcb.data_transfer_length); 3706 3707 if (buffer->ioarcb.request_flags0 & TRANSFER_DIR_WRITE) { 3708 access = VERIFY_READ; 3709 direction = DMA_TO_DEVICE; 3710 } else { 3711 access = VERIFY_WRITE; 3712 direction = DMA_FROM_DEVICE; 3713 } 3714 3715 if (request_size < 0) { 3716 rc = -EINVAL; 3717 goto out_free_buffer; 3718 } 3719 3720 /* check if we have any additional command parameters */ 3721 if (le16_to_cpu(buffer->ioarcb.add_cmd_param_length) 3722 > PMCRAID_ADD_CMD_PARAM_LEN) { 3723 rc = -EINVAL; 3724 goto out_free_buffer; 3725 } 3726 3727 cmd = pmcraid_get_free_cmd(pinstance); 3728 3729 if (!cmd) { 3730 pmcraid_err("free command block is not available\n"); 3731 rc = -ENOMEM; 3732 goto out_free_buffer; 3733 } 3734 3735 cmd->scsi_cmd = NULL; 3736 ioarcb = &(cmd->ioa_cb->ioarcb); 3737 3738 /* Copy the user-provided IOARCB stuff field by field */ 3739 ioarcb->resource_handle = buffer->ioarcb.resource_handle; 3740 ioarcb->data_transfer_length = buffer->ioarcb.data_transfer_length; 3741 ioarcb->cmd_timeout = buffer->ioarcb.cmd_timeout; 3742 ioarcb->request_type = buffer->ioarcb.request_type; 3743 ioarcb->request_flags0 = buffer->ioarcb.request_flags0; 3744 ioarcb->request_flags1 = buffer->ioarcb.request_flags1; 3745 memcpy(ioarcb->cdb, buffer->ioarcb.cdb, PMCRAID_MAX_CDB_LEN); 3746 3747 if (buffer->ioarcb.add_cmd_param_length) { 3748 ioarcb->add_cmd_param_length = 3749 buffer->ioarcb.add_cmd_param_length; 3750 ioarcb->add_cmd_param_offset = 3751 buffer->ioarcb.add_cmd_param_offset; 3752 memcpy(ioarcb->add_data.u.add_cmd_params, 3753 buffer->ioarcb.add_data.u.add_cmd_params, 3754 le16_to_cpu(buffer->ioarcb.add_cmd_param_length)); 3755 } 3756 3757 /* set hrrq number where the IOA should respond to. Note that all cmds 3758 * generated internally uses hrrq_id 0, exception to this is the cmd 3759 * block of scsi_cmd which is re-used (e.g. cancel/abort), which uses 3760 * hrrq_id assigned here in queuecommand 3761 */ 3762 ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) % 3763 pinstance->num_hrrq; 3764 3765 if (request_size) { 3766 rc = pmcraid_build_passthrough_ioadls(cmd, 3767 request_size, 3768 direction); 3769 if (rc) { 3770 pmcraid_err("couldn't build passthrough ioadls\n"); 3771 goto out_free_cmd; 3772 } 3773 } else if (request_size < 0) { 3774 rc = -EINVAL; 3775 goto out_free_cmd; 3776 } 3777 3778 /* If data is being written into the device, copy the data from user 3779 * buffers 3780 */ 3781 if (direction == DMA_TO_DEVICE && request_size > 0) { 3782 rc = pmcraid_copy_sglist(cmd->sglist, 3783 request_buffer, 3784 request_size, 3785 direction); 3786 if (rc) { 3787 pmcraid_err("failed to copy user buffer\n"); 3788 goto out_free_sglist; 3789 } 3790 } 3791 3792 /* passthrough ioctl is a blocking command so, put the user to sleep 3793 * until timeout. Note that a timeout value of 0 means, do timeout. 3794 */ 3795 cmd->cmd_done = pmcraid_internal_done; 3796 init_completion(&cmd->wait_for_completion); 3797 cmd->completion_req = 1; 3798 3799 pmcraid_info("command(%d) (CDB[0] = %x) for %x\n", 3800 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2, 3801 cmd->ioa_cb->ioarcb.cdb[0], 3802 le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle)); 3803 3804 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 3805 _pmcraid_fire_command(cmd); 3806 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 3807 3808 /* NOTE ! Remove the below line once abort_task is implemented 3809 * in firmware. This line disables ioctl command timeout handling logic 3810 * similar to IO command timeout handling, making ioctl commands to wait 3811 * until the command completion regardless of timeout value specified in 3812 * ioarcb 3813 */ 3814 buffer->ioarcb.cmd_timeout = 0; 3815 3816 /* If command timeout is specified put caller to wait till that time, 3817 * otherwise it would be blocking wait. If command gets timed out, it 3818 * will be aborted. 3819 */ 3820 if (buffer->ioarcb.cmd_timeout == 0) { 3821 wait_for_completion(&cmd->wait_for_completion); 3822 } else if (!wait_for_completion_timeout( 3823 &cmd->wait_for_completion, 3824 msecs_to_jiffies(le16_to_cpu(buffer->ioarcb.cmd_timeout) * 1000))) { 3825 3826 pmcraid_info("aborting cmd %d (CDB[0] = %x) due to timeout\n", 3827 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2, 3828 cmd->ioa_cb->ioarcb.cdb[0]); 3829 3830 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 3831 cancel_cmd = pmcraid_abort_cmd(cmd); 3832 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 3833 3834 if (cancel_cmd) { 3835 wait_for_completion(&cancel_cmd->wait_for_completion); 3836 ioasc = le32_to_cpu(cancel_cmd->ioa_cb->ioasa.ioasc); 3837 pmcraid_return_cmd(cancel_cmd); 3838 3839 /* if abort task couldn't find the command i.e it got 3840 * completed prior to aborting, return good completion. 3841 * if command got aborted successfully or there was IOA 3842 * reset due to abort task itself getting timedout then 3843 * return -ETIMEDOUT 3844 */ 3845 if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET || 3846 PMCRAID_IOASC_SENSE_KEY(ioasc) == 0x00) { 3847 if (ioasc != PMCRAID_IOASC_GC_IOARCB_NOTFOUND) 3848 rc = -ETIMEDOUT; 3849 goto out_handle_response; 3850 } 3851 } 3852 3853 /* no command block for abort task or abort task failed to abort 3854 * the IOARCB, then wait for 150 more seconds and initiate reset 3855 * sequence after timeout 3856 */ 3857 if (!wait_for_completion_timeout( 3858 &cmd->wait_for_completion, 3859 msecs_to_jiffies(150 * 1000))) { 3860 pmcraid_reset_bringup(cmd->drv_inst); 3861 rc = -ETIMEDOUT; 3862 } 3863 } 3864 3865 out_handle_response: 3866 /* copy entire IOASA buffer and return IOCTL success. 3867 * If copying IOASA to user-buffer fails, return 3868 * EFAULT 3869 */ 3870 if (copy_to_user(ioasa, &cmd->ioa_cb->ioasa, 3871 sizeof(struct pmcraid_ioasa))) { 3872 pmcraid_err("failed to copy ioasa buffer to user\n"); 3873 rc = -EFAULT; 3874 } 3875 3876 /* If the data transfer was from device, copy the data onto user 3877 * buffers 3878 */ 3879 else if (direction == DMA_FROM_DEVICE && request_size > 0) { 3880 rc = pmcraid_copy_sglist(cmd->sglist, 3881 request_buffer, 3882 request_size, 3883 direction); 3884 if (rc) { 3885 pmcraid_err("failed to copy user buffer\n"); 3886 rc = -EFAULT; 3887 } 3888 } 3889 3890 out_free_sglist: 3891 pmcraid_release_passthrough_ioadls(cmd, request_size, direction); 3892 3893 out_free_cmd: 3894 pmcraid_return_cmd(cmd); 3895 3896 out_free_buffer: 3897 kfree(buffer); 3898 3899 return rc; 3900 } 3901 3902 3903 3904 3905 /** 3906 * pmcraid_ioctl_driver - ioctl handler for commands handled by driver itself 3907 * 3908 * @pinstance: pointer to adapter instance structure 3909 * @cmd: ioctl command passed in 3910 * @buflen: length of user_buffer 3911 * @user_buffer: user buffer pointer 3912 * 3913 * Return Value 3914 * 0 in case of success, otherwise appropriate error code 3915 */ 3916 static long pmcraid_ioctl_driver( 3917 struct pmcraid_instance *pinstance, 3918 unsigned int cmd, 3919 unsigned int buflen, 3920 void __user *user_buffer 3921 ) 3922 { 3923 int rc = -ENOSYS; 3924 3925 switch (cmd) { 3926 case PMCRAID_IOCTL_RESET_ADAPTER: 3927 pmcraid_reset_bringup(pinstance); 3928 rc = 0; 3929 break; 3930 3931 default: 3932 break; 3933 } 3934 3935 return rc; 3936 } 3937 3938 /** 3939 * pmcraid_check_ioctl_buffer - check for proper access to user buffer 3940 * 3941 * @cmd: ioctl command 3942 * @arg: user buffer 3943 * @hdr: pointer to kernel memory for pmcraid_ioctl_header 3944 * 3945 * Return Value 3946 * negetive error code if there are access issues, otherwise zero. 3947 * Upon success, returns ioctl header copied out of user buffer. 3948 */ 3949 3950 static int pmcraid_check_ioctl_buffer( 3951 int cmd, 3952 void __user *arg, 3953 struct pmcraid_ioctl_header *hdr 3954 ) 3955 { 3956 int rc; 3957 3958 if (copy_from_user(hdr, arg, sizeof(struct pmcraid_ioctl_header))) { 3959 pmcraid_err("couldn't copy ioctl header from user buffer\n"); 3960 return -EFAULT; 3961 } 3962 3963 /* check for valid driver signature */ 3964 rc = memcmp(hdr->signature, 3965 PMCRAID_IOCTL_SIGNATURE, 3966 sizeof(hdr->signature)); 3967 if (rc) { 3968 pmcraid_err("signature verification failed\n"); 3969 return -EINVAL; 3970 } 3971 3972 return 0; 3973 } 3974 3975 /** 3976 * pmcraid_ioctl - char node ioctl entry point 3977 */ 3978 static long pmcraid_chr_ioctl( 3979 struct file *filep, 3980 unsigned int cmd, 3981 unsigned long arg 3982 ) 3983 { 3984 struct pmcraid_instance *pinstance = NULL; 3985 struct pmcraid_ioctl_header *hdr = NULL; 3986 void __user *argp = (void __user *)arg; 3987 int retval = -ENOTTY; 3988 3989 hdr = kmalloc(sizeof(struct pmcraid_ioctl_header), GFP_KERNEL); 3990 3991 if (!hdr) { 3992 pmcraid_err("failed to allocate memory for ioctl header\n"); 3993 return -ENOMEM; 3994 } 3995 3996 retval = pmcraid_check_ioctl_buffer(cmd, argp, hdr); 3997 3998 if (retval) { 3999 pmcraid_info("chr_ioctl: header check failed\n"); 4000 kfree(hdr); 4001 return retval; 4002 } 4003 4004 pinstance = filep->private_data; 4005 4006 if (!pinstance) { 4007 pmcraid_info("adapter instance is not found\n"); 4008 kfree(hdr); 4009 return -ENOTTY; 4010 } 4011 4012 switch (_IOC_TYPE(cmd)) { 4013 4014 case PMCRAID_PASSTHROUGH_IOCTL: 4015 /* If ioctl code is to download microcode, we need to block 4016 * mid-layer requests. 4017 */ 4018 if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE) 4019 scsi_block_requests(pinstance->host); 4020 4021 retval = pmcraid_ioctl_passthrough(pinstance, cmd, 4022 hdr->buffer_length, argp); 4023 4024 if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE) 4025 scsi_unblock_requests(pinstance->host); 4026 break; 4027 4028 case PMCRAID_DRIVER_IOCTL: 4029 arg += sizeof(struct pmcraid_ioctl_header); 4030 retval = pmcraid_ioctl_driver(pinstance, cmd, 4031 hdr->buffer_length, argp); 4032 break; 4033 4034 default: 4035 retval = -ENOTTY; 4036 break; 4037 } 4038 4039 kfree(hdr); 4040 4041 return retval; 4042 } 4043 4044 /** 4045 * File operations structure for management interface 4046 */ 4047 static const struct file_operations pmcraid_fops = { 4048 .owner = THIS_MODULE, 4049 .open = pmcraid_chr_open, 4050 .fasync = pmcraid_chr_fasync, 4051 .unlocked_ioctl = pmcraid_chr_ioctl, 4052 #ifdef CONFIG_COMPAT 4053 .compat_ioctl = pmcraid_chr_ioctl, 4054 #endif 4055 .llseek = noop_llseek, 4056 }; 4057 4058 4059 4060 4061 /** 4062 * pmcraid_show_log_level - Display adapter's error logging level 4063 * @dev: class device struct 4064 * @buf: buffer 4065 * 4066 * Return value: 4067 * number of bytes printed to buffer 4068 */ 4069 static ssize_t pmcraid_show_log_level( 4070 struct device *dev, 4071 struct device_attribute *attr, 4072 char *buf) 4073 { 4074 struct Scsi_Host *shost = class_to_shost(dev); 4075 struct pmcraid_instance *pinstance = 4076 (struct pmcraid_instance *)shost->hostdata; 4077 return snprintf(buf, PAGE_SIZE, "%d\n", pinstance->current_log_level); 4078 } 4079 4080 /** 4081 * pmcraid_store_log_level - Change the adapter's error logging level 4082 * @dev: class device struct 4083 * @buf: buffer 4084 * @count: not used 4085 * 4086 * Return value: 4087 * number of bytes printed to buffer 4088 */ 4089 static ssize_t pmcraid_store_log_level( 4090 struct device *dev, 4091 struct device_attribute *attr, 4092 const char *buf, 4093 size_t count 4094 ) 4095 { 4096 struct Scsi_Host *shost; 4097 struct pmcraid_instance *pinstance; 4098 u8 val; 4099 4100 if (kstrtou8(buf, 10, &val)) 4101 return -EINVAL; 4102 /* log-level should be from 0 to 2 */ 4103 if (val > 2) 4104 return -EINVAL; 4105 4106 shost = class_to_shost(dev); 4107 pinstance = (struct pmcraid_instance *)shost->hostdata; 4108 pinstance->current_log_level = val; 4109 4110 return strlen(buf); 4111 } 4112 4113 static struct device_attribute pmcraid_log_level_attr = { 4114 .attr = { 4115 .name = "log_level", 4116 .mode = S_IRUGO | S_IWUSR, 4117 }, 4118 .show = pmcraid_show_log_level, 4119 .store = pmcraid_store_log_level, 4120 }; 4121 4122 /** 4123 * pmcraid_show_drv_version - Display driver version 4124 * @dev: class device struct 4125 * @buf: buffer 4126 * 4127 * Return value: 4128 * number of bytes printed to buffer 4129 */ 4130 static ssize_t pmcraid_show_drv_version( 4131 struct device *dev, 4132 struct device_attribute *attr, 4133 char *buf 4134 ) 4135 { 4136 return snprintf(buf, PAGE_SIZE, "version: %s\n", 4137 PMCRAID_DRIVER_VERSION); 4138 } 4139 4140 static struct device_attribute pmcraid_driver_version_attr = { 4141 .attr = { 4142 .name = "drv_version", 4143 .mode = S_IRUGO, 4144 }, 4145 .show = pmcraid_show_drv_version, 4146 }; 4147 4148 /** 4149 * pmcraid_show_io_adapter_id - Display driver assigned adapter id 4150 * @dev: class device struct 4151 * @buf: buffer 4152 * 4153 * Return value: 4154 * number of bytes printed to buffer 4155 */ 4156 static ssize_t pmcraid_show_adapter_id( 4157 struct device *dev, 4158 struct device_attribute *attr, 4159 char *buf 4160 ) 4161 { 4162 struct Scsi_Host *shost = class_to_shost(dev); 4163 struct pmcraid_instance *pinstance = 4164 (struct pmcraid_instance *)shost->hostdata; 4165 u32 adapter_id = (pinstance->pdev->bus->number << 8) | 4166 pinstance->pdev->devfn; 4167 u32 aen_group = pmcraid_event_family.id; 4168 4169 return snprintf(buf, PAGE_SIZE, 4170 "adapter id: %d\nminor: %d\naen group: %d\n", 4171 adapter_id, MINOR(pinstance->cdev.dev), aen_group); 4172 } 4173 4174 static struct device_attribute pmcraid_adapter_id_attr = { 4175 .attr = { 4176 .name = "adapter_id", 4177 .mode = S_IRUGO, 4178 }, 4179 .show = pmcraid_show_adapter_id, 4180 }; 4181 4182 static struct device_attribute *pmcraid_host_attrs[] = { 4183 &pmcraid_log_level_attr, 4184 &pmcraid_driver_version_attr, 4185 &pmcraid_adapter_id_attr, 4186 NULL, 4187 }; 4188 4189 4190 /* host template structure for pmcraid driver */ 4191 static struct scsi_host_template pmcraid_host_template = { 4192 .module = THIS_MODULE, 4193 .name = PMCRAID_DRIVER_NAME, 4194 .queuecommand = pmcraid_queuecommand, 4195 .eh_abort_handler = pmcraid_eh_abort_handler, 4196 .eh_bus_reset_handler = pmcraid_eh_bus_reset_handler, 4197 .eh_target_reset_handler = pmcraid_eh_target_reset_handler, 4198 .eh_device_reset_handler = pmcraid_eh_device_reset_handler, 4199 .eh_host_reset_handler = pmcraid_eh_host_reset_handler, 4200 4201 .slave_alloc = pmcraid_slave_alloc, 4202 .slave_configure = pmcraid_slave_configure, 4203 .slave_destroy = pmcraid_slave_destroy, 4204 .change_queue_depth = pmcraid_change_queue_depth, 4205 .can_queue = PMCRAID_MAX_IO_CMD, 4206 .this_id = -1, 4207 .sg_tablesize = PMCRAID_MAX_IOADLS, 4208 .max_sectors = PMCRAID_IOA_MAX_SECTORS, 4209 .no_write_same = 1, 4210 .cmd_per_lun = PMCRAID_MAX_CMD_PER_LUN, 4211 .use_clustering = ENABLE_CLUSTERING, 4212 .shost_attrs = pmcraid_host_attrs, 4213 .proc_name = PMCRAID_DRIVER_NAME, 4214 }; 4215 4216 /* 4217 * pmcraid_isr_msix - implements MSI-X interrupt handling routine 4218 * @irq: interrupt vector number 4219 * @dev_id: pointer hrrq_vector 4220 * 4221 * Return Value 4222 * IRQ_HANDLED if interrupt is handled or IRQ_NONE if ignored 4223 */ 4224 4225 static irqreturn_t pmcraid_isr_msix(int irq, void *dev_id) 4226 { 4227 struct pmcraid_isr_param *hrrq_vector; 4228 struct pmcraid_instance *pinstance; 4229 unsigned long lock_flags; 4230 u32 intrs_val; 4231 int hrrq_id; 4232 4233 hrrq_vector = (struct pmcraid_isr_param *)dev_id; 4234 hrrq_id = hrrq_vector->hrrq_id; 4235 pinstance = hrrq_vector->drv_inst; 4236 4237 if (!hrrq_id) { 4238 /* Read the interrupt */ 4239 intrs_val = pmcraid_read_interrupts(pinstance); 4240 if (intrs_val && 4241 ((ioread32(pinstance->int_regs.host_ioa_interrupt_reg) 4242 & DOORBELL_INTR_MSIX_CLR) == 0)) { 4243 /* Any error interrupts including unit_check, 4244 * initiate IOA reset.In case of unit check indicate 4245 * to reset_sequence that IOA unit checked and prepare 4246 * for a dump during reset sequence 4247 */ 4248 if (intrs_val & PMCRAID_ERROR_INTERRUPTS) { 4249 if (intrs_val & INTRS_IOA_UNIT_CHECK) 4250 pinstance->ioa_unit_check = 1; 4251 4252 pmcraid_err("ISR: error interrupts: %x \ 4253 initiating reset\n", intrs_val); 4254 spin_lock_irqsave(pinstance->host->host_lock, 4255 lock_flags); 4256 pmcraid_initiate_reset(pinstance); 4257 spin_unlock_irqrestore( 4258 pinstance->host->host_lock, 4259 lock_flags); 4260 } 4261 /* If interrupt was as part of the ioa initialization, 4262 * clear it. Delete the timer and wakeup the 4263 * reset engine to proceed with reset sequence 4264 */ 4265 if (intrs_val & INTRS_TRANSITION_TO_OPERATIONAL) 4266 pmcraid_clr_trans_op(pinstance); 4267 4268 /* Clear the interrupt register by writing 4269 * to host to ioa doorbell. Once done 4270 * FW will clear the interrupt. 4271 */ 4272 iowrite32(DOORBELL_INTR_MSIX_CLR, 4273 pinstance->int_regs.host_ioa_interrupt_reg); 4274 ioread32(pinstance->int_regs.host_ioa_interrupt_reg); 4275 4276 4277 } 4278 } 4279 4280 tasklet_schedule(&(pinstance->isr_tasklet[hrrq_id])); 4281 4282 return IRQ_HANDLED; 4283 } 4284 4285 /** 4286 * pmcraid_isr - implements legacy interrupt handling routine 4287 * 4288 * @irq: interrupt vector number 4289 * @dev_id: pointer hrrq_vector 4290 * 4291 * Return Value 4292 * IRQ_HANDLED if interrupt is handled or IRQ_NONE if ignored 4293 */ 4294 static irqreturn_t pmcraid_isr(int irq, void *dev_id) 4295 { 4296 struct pmcraid_isr_param *hrrq_vector; 4297 struct pmcraid_instance *pinstance; 4298 u32 intrs; 4299 unsigned long lock_flags; 4300 int hrrq_id = 0; 4301 4302 /* In case of legacy interrupt mode where interrupts are shared across 4303 * isrs, it may be possible that the current interrupt is not from IOA 4304 */ 4305 if (!dev_id) { 4306 printk(KERN_INFO "%s(): NULL host pointer\n", __func__); 4307 return IRQ_NONE; 4308 } 4309 hrrq_vector = (struct pmcraid_isr_param *)dev_id; 4310 pinstance = hrrq_vector->drv_inst; 4311 4312 intrs = pmcraid_read_interrupts(pinstance); 4313 4314 if (unlikely((intrs & PMCRAID_PCI_INTERRUPTS) == 0)) 4315 return IRQ_NONE; 4316 4317 /* Any error interrupts including unit_check, initiate IOA reset. 4318 * In case of unit check indicate to reset_sequence that IOA unit 4319 * checked and prepare for a dump during reset sequence 4320 */ 4321 if (intrs & PMCRAID_ERROR_INTERRUPTS) { 4322 4323 if (intrs & INTRS_IOA_UNIT_CHECK) 4324 pinstance->ioa_unit_check = 1; 4325 4326 iowrite32(intrs, 4327 pinstance->int_regs.ioa_host_interrupt_clr_reg); 4328 pmcraid_err("ISR: error interrupts: %x initiating reset\n", 4329 intrs); 4330 intrs = ioread32( 4331 pinstance->int_regs.ioa_host_interrupt_clr_reg); 4332 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 4333 pmcraid_initiate_reset(pinstance); 4334 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 4335 } else { 4336 /* If interrupt was as part of the ioa initialization, 4337 * clear. Delete the timer and wakeup the 4338 * reset engine to proceed with reset sequence 4339 */ 4340 if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) { 4341 pmcraid_clr_trans_op(pinstance); 4342 } else { 4343 iowrite32(intrs, 4344 pinstance->int_regs.ioa_host_interrupt_clr_reg); 4345 ioread32( 4346 pinstance->int_regs.ioa_host_interrupt_clr_reg); 4347 4348 tasklet_schedule( 4349 &(pinstance->isr_tasklet[hrrq_id])); 4350 } 4351 } 4352 4353 return IRQ_HANDLED; 4354 } 4355 4356 4357 /** 4358 * pmcraid_worker_function - worker thread function 4359 * 4360 * @workp: pointer to struct work queue 4361 * 4362 * Return Value 4363 * None 4364 */ 4365 4366 static void pmcraid_worker_function(struct work_struct *workp) 4367 { 4368 struct pmcraid_instance *pinstance; 4369 struct pmcraid_resource_entry *res; 4370 struct pmcraid_resource_entry *temp; 4371 struct scsi_device *sdev; 4372 unsigned long lock_flags; 4373 unsigned long host_lock_flags; 4374 u16 fw_version; 4375 u8 bus, target, lun; 4376 4377 pinstance = container_of(workp, struct pmcraid_instance, worker_q); 4378 /* add resources only after host is added into system */ 4379 if (!atomic_read(&pinstance->expose_resources)) 4380 return; 4381 4382 fw_version = be16_to_cpu(pinstance->inq_data->fw_version); 4383 4384 spin_lock_irqsave(&pinstance->resource_lock, lock_flags); 4385 list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue) { 4386 4387 if (res->change_detected == RES_CHANGE_DEL && res->scsi_dev) { 4388 sdev = res->scsi_dev; 4389 4390 /* host_lock must be held before calling 4391 * scsi_device_get 4392 */ 4393 spin_lock_irqsave(pinstance->host->host_lock, 4394 host_lock_flags); 4395 if (!scsi_device_get(sdev)) { 4396 spin_unlock_irqrestore( 4397 pinstance->host->host_lock, 4398 host_lock_flags); 4399 pmcraid_info("deleting %x from midlayer\n", 4400 res->cfg_entry.resource_address); 4401 list_move_tail(&res->queue, 4402 &pinstance->free_res_q); 4403 spin_unlock_irqrestore( 4404 &pinstance->resource_lock, 4405 lock_flags); 4406 scsi_remove_device(sdev); 4407 scsi_device_put(sdev); 4408 spin_lock_irqsave(&pinstance->resource_lock, 4409 lock_flags); 4410 res->change_detected = 0; 4411 } else { 4412 spin_unlock_irqrestore( 4413 pinstance->host->host_lock, 4414 host_lock_flags); 4415 } 4416 } 4417 } 4418 4419 list_for_each_entry(res, &pinstance->used_res_q, queue) { 4420 4421 if (res->change_detected == RES_CHANGE_ADD) { 4422 4423 if (!pmcraid_expose_resource(fw_version, 4424 &res->cfg_entry)) 4425 continue; 4426 4427 if (RES_IS_VSET(res->cfg_entry)) { 4428 bus = PMCRAID_VSET_BUS_ID; 4429 if (fw_version <= PMCRAID_FW_VERSION_1) 4430 target = res->cfg_entry.unique_flags1; 4431 else 4432 target = le16_to_cpu(res->cfg_entry.array_id) & 0xFF; 4433 lun = PMCRAID_VSET_LUN_ID; 4434 } else { 4435 bus = PMCRAID_PHYS_BUS_ID; 4436 target = 4437 RES_TARGET( 4438 res->cfg_entry.resource_address); 4439 lun = RES_LUN(res->cfg_entry.resource_address); 4440 } 4441 4442 res->change_detected = 0; 4443 spin_unlock_irqrestore(&pinstance->resource_lock, 4444 lock_flags); 4445 scsi_add_device(pinstance->host, bus, target, lun); 4446 spin_lock_irqsave(&pinstance->resource_lock, 4447 lock_flags); 4448 } 4449 } 4450 4451 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags); 4452 } 4453 4454 /** 4455 * pmcraid_tasklet_function - Tasklet function 4456 * 4457 * @instance: pointer to msix param structure 4458 * 4459 * Return Value 4460 * None 4461 */ 4462 static void pmcraid_tasklet_function(unsigned long instance) 4463 { 4464 struct pmcraid_isr_param *hrrq_vector; 4465 struct pmcraid_instance *pinstance; 4466 unsigned long hrrq_lock_flags; 4467 unsigned long pending_lock_flags; 4468 unsigned long host_lock_flags; 4469 spinlock_t *lockp; /* hrrq buffer lock */ 4470 int id; 4471 u32 resp; 4472 4473 hrrq_vector = (struct pmcraid_isr_param *)instance; 4474 pinstance = hrrq_vector->drv_inst; 4475 id = hrrq_vector->hrrq_id; 4476 lockp = &(pinstance->hrrq_lock[id]); 4477 4478 /* loop through each of the commands responded by IOA. Each HRRQ buf is 4479 * protected by its own lock. Traversals must be done within this lock 4480 * as there may be multiple tasklets running on multiple CPUs. Note 4481 * that the lock is held just for picking up the response handle and 4482 * manipulating hrrq_curr/toggle_bit values. 4483 */ 4484 spin_lock_irqsave(lockp, hrrq_lock_flags); 4485 4486 resp = le32_to_cpu(*(pinstance->hrrq_curr[id])); 4487 4488 while ((resp & HRRQ_TOGGLE_BIT) == 4489 pinstance->host_toggle_bit[id]) { 4490 4491 int cmd_index = resp >> 2; 4492 struct pmcraid_cmd *cmd = NULL; 4493 4494 if (pinstance->hrrq_curr[id] < pinstance->hrrq_end[id]) { 4495 pinstance->hrrq_curr[id]++; 4496 } else { 4497 pinstance->hrrq_curr[id] = pinstance->hrrq_start[id]; 4498 pinstance->host_toggle_bit[id] ^= 1u; 4499 } 4500 4501 if (cmd_index >= PMCRAID_MAX_CMD) { 4502 /* In case of invalid response handle, log message */ 4503 pmcraid_err("Invalid response handle %d\n", cmd_index); 4504 resp = le32_to_cpu(*(pinstance->hrrq_curr[id])); 4505 continue; 4506 } 4507 4508 cmd = pinstance->cmd_list[cmd_index]; 4509 spin_unlock_irqrestore(lockp, hrrq_lock_flags); 4510 4511 spin_lock_irqsave(&pinstance->pending_pool_lock, 4512 pending_lock_flags); 4513 list_del(&cmd->free_list); 4514 spin_unlock_irqrestore(&pinstance->pending_pool_lock, 4515 pending_lock_flags); 4516 del_timer(&cmd->timer); 4517 atomic_dec(&pinstance->outstanding_cmds); 4518 4519 if (cmd->cmd_done == pmcraid_ioa_reset) { 4520 spin_lock_irqsave(pinstance->host->host_lock, 4521 host_lock_flags); 4522 cmd->cmd_done(cmd); 4523 spin_unlock_irqrestore(pinstance->host->host_lock, 4524 host_lock_flags); 4525 } else if (cmd->cmd_done != NULL) { 4526 cmd->cmd_done(cmd); 4527 } 4528 /* loop over until we are done with all responses */ 4529 spin_lock_irqsave(lockp, hrrq_lock_flags); 4530 resp = le32_to_cpu(*(pinstance->hrrq_curr[id])); 4531 } 4532 4533 spin_unlock_irqrestore(lockp, hrrq_lock_flags); 4534 } 4535 4536 /** 4537 * pmcraid_unregister_interrupt_handler - de-register interrupts handlers 4538 * @pinstance: pointer to adapter instance structure 4539 * 4540 * This routine un-registers registered interrupt handler and 4541 * also frees irqs/vectors. 4542 * 4543 * Retun Value 4544 * None 4545 */ 4546 static 4547 void pmcraid_unregister_interrupt_handler(struct pmcraid_instance *pinstance) 4548 { 4549 struct pci_dev *pdev = pinstance->pdev; 4550 int i; 4551 4552 for (i = 0; i < pinstance->num_hrrq; i++) 4553 free_irq(pci_irq_vector(pdev, i), &pinstance->hrrq_vector[i]); 4554 4555 pinstance->interrupt_mode = 0; 4556 pci_free_irq_vectors(pdev); 4557 } 4558 4559 /** 4560 * pmcraid_register_interrupt_handler - registers interrupt handler 4561 * @pinstance: pointer to per-adapter instance structure 4562 * 4563 * Return Value 4564 * 0 on success, non-zero error code otherwise. 4565 */ 4566 static int 4567 pmcraid_register_interrupt_handler(struct pmcraid_instance *pinstance) 4568 { 4569 struct pci_dev *pdev = pinstance->pdev; 4570 unsigned int irq_flag = PCI_IRQ_LEGACY, flag; 4571 int num_hrrq, rc, i; 4572 irq_handler_t isr; 4573 4574 if (pmcraid_enable_msix) 4575 irq_flag |= PCI_IRQ_MSIX; 4576 4577 num_hrrq = pci_alloc_irq_vectors(pdev, 1, PMCRAID_NUM_MSIX_VECTORS, 4578 irq_flag); 4579 if (num_hrrq < 0) 4580 return num_hrrq; 4581 4582 if (pdev->msix_enabled) { 4583 flag = 0; 4584 isr = pmcraid_isr_msix; 4585 } else { 4586 flag = IRQF_SHARED; 4587 isr = pmcraid_isr; 4588 } 4589 4590 for (i = 0; i < num_hrrq; i++) { 4591 struct pmcraid_isr_param *vec = &pinstance->hrrq_vector[i]; 4592 4593 vec->hrrq_id = i; 4594 vec->drv_inst = pinstance; 4595 rc = request_irq(pci_irq_vector(pdev, i), isr, flag, 4596 PMCRAID_DRIVER_NAME, vec); 4597 if (rc) 4598 goto out_unwind; 4599 } 4600 4601 pinstance->num_hrrq = num_hrrq; 4602 if (pdev->msix_enabled) { 4603 pinstance->interrupt_mode = 1; 4604 iowrite32(DOORBELL_INTR_MODE_MSIX, 4605 pinstance->int_regs.host_ioa_interrupt_reg); 4606 ioread32(pinstance->int_regs.host_ioa_interrupt_reg); 4607 } 4608 4609 return 0; 4610 4611 out_unwind: 4612 while (--i > 0) 4613 free_irq(pci_irq_vector(pdev, i), &pinstance->hrrq_vector[i]); 4614 pci_free_irq_vectors(pdev); 4615 return rc; 4616 } 4617 4618 /** 4619 * pmcraid_release_cmd_blocks - release buufers allocated for command blocks 4620 * @pinstance: per adapter instance structure pointer 4621 * @max_index: number of buffer blocks to release 4622 * 4623 * Return Value 4624 * None 4625 */ 4626 static void 4627 pmcraid_release_cmd_blocks(struct pmcraid_instance *pinstance, int max_index) 4628 { 4629 int i; 4630 for (i = 0; i < max_index; i++) { 4631 kmem_cache_free(pinstance->cmd_cachep, pinstance->cmd_list[i]); 4632 pinstance->cmd_list[i] = NULL; 4633 } 4634 kmem_cache_destroy(pinstance->cmd_cachep); 4635 pinstance->cmd_cachep = NULL; 4636 } 4637 4638 /** 4639 * pmcraid_release_control_blocks - releases buffers alloced for control blocks 4640 * @pinstance: pointer to per adapter instance structure 4641 * @max_index: number of buffers (from 0 onwards) to release 4642 * 4643 * This function assumes that the command blocks for which control blocks are 4644 * linked are not released. 4645 * 4646 * Return Value 4647 * None 4648 */ 4649 static void 4650 pmcraid_release_control_blocks( 4651 struct pmcraid_instance *pinstance, 4652 int max_index 4653 ) 4654 { 4655 int i; 4656 4657 if (pinstance->control_pool == NULL) 4658 return; 4659 4660 for (i = 0; i < max_index; i++) { 4661 pci_pool_free(pinstance->control_pool, 4662 pinstance->cmd_list[i]->ioa_cb, 4663 pinstance->cmd_list[i]->ioa_cb_bus_addr); 4664 pinstance->cmd_list[i]->ioa_cb = NULL; 4665 pinstance->cmd_list[i]->ioa_cb_bus_addr = 0; 4666 } 4667 pci_pool_destroy(pinstance->control_pool); 4668 pinstance->control_pool = NULL; 4669 } 4670 4671 /** 4672 * pmcraid_allocate_cmd_blocks - allocate memory for cmd block structures 4673 * @pinstance - pointer to per adapter instance structure 4674 * 4675 * Allocates memory for command blocks using kernel slab allocator. 4676 * 4677 * Return Value 4678 * 0 in case of success; -ENOMEM in case of failure 4679 */ 4680 static int pmcraid_allocate_cmd_blocks(struct pmcraid_instance *pinstance) 4681 { 4682 int i; 4683 4684 sprintf(pinstance->cmd_pool_name, "pmcraid_cmd_pool_%d", 4685 pinstance->host->unique_id); 4686 4687 4688 pinstance->cmd_cachep = kmem_cache_create( 4689 pinstance->cmd_pool_name, 4690 sizeof(struct pmcraid_cmd), 0, 4691 SLAB_HWCACHE_ALIGN, NULL); 4692 if (!pinstance->cmd_cachep) 4693 return -ENOMEM; 4694 4695 for (i = 0; i < PMCRAID_MAX_CMD; i++) { 4696 pinstance->cmd_list[i] = 4697 kmem_cache_alloc(pinstance->cmd_cachep, GFP_KERNEL); 4698 if (!pinstance->cmd_list[i]) { 4699 pmcraid_release_cmd_blocks(pinstance, i); 4700 return -ENOMEM; 4701 } 4702 } 4703 return 0; 4704 } 4705 4706 /** 4707 * pmcraid_allocate_control_blocks - allocates memory control blocks 4708 * @pinstance : pointer to per adapter instance structure 4709 * 4710 * This function allocates PCI memory for DMAable buffers like IOARCB, IOADLs 4711 * and IOASAs. This is called after command blocks are already allocated. 4712 * 4713 * Return Value 4714 * 0 in case it can allocate all control blocks, otherwise -ENOMEM 4715 */ 4716 static int pmcraid_allocate_control_blocks(struct pmcraid_instance *pinstance) 4717 { 4718 int i; 4719 4720 sprintf(pinstance->ctl_pool_name, "pmcraid_control_pool_%d", 4721 pinstance->host->unique_id); 4722 4723 pinstance->control_pool = 4724 pci_pool_create(pinstance->ctl_pool_name, 4725 pinstance->pdev, 4726 sizeof(struct pmcraid_control_block), 4727 PMCRAID_IOARCB_ALIGNMENT, 0); 4728 4729 if (!pinstance->control_pool) 4730 return -ENOMEM; 4731 4732 for (i = 0; i < PMCRAID_MAX_CMD; i++) { 4733 pinstance->cmd_list[i]->ioa_cb = 4734 pci_pool_alloc( 4735 pinstance->control_pool, 4736 GFP_KERNEL, 4737 &(pinstance->cmd_list[i]->ioa_cb_bus_addr)); 4738 4739 if (!pinstance->cmd_list[i]->ioa_cb) { 4740 pmcraid_release_control_blocks(pinstance, i); 4741 return -ENOMEM; 4742 } 4743 memset(pinstance->cmd_list[i]->ioa_cb, 0, 4744 sizeof(struct pmcraid_control_block)); 4745 } 4746 return 0; 4747 } 4748 4749 /** 4750 * pmcraid_release_host_rrqs - release memory allocated for hrrq buffer(s) 4751 * @pinstance: pointer to per adapter instance structure 4752 * @maxindex: size of hrrq buffer pointer array 4753 * 4754 * Return Value 4755 * None 4756 */ 4757 static void 4758 pmcraid_release_host_rrqs(struct pmcraid_instance *pinstance, int maxindex) 4759 { 4760 int i; 4761 for (i = 0; i < maxindex; i++) { 4762 4763 pci_free_consistent(pinstance->pdev, 4764 HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD, 4765 pinstance->hrrq_start[i], 4766 pinstance->hrrq_start_bus_addr[i]); 4767 4768 /* reset pointers and toggle bit to zeros */ 4769 pinstance->hrrq_start[i] = NULL; 4770 pinstance->hrrq_start_bus_addr[i] = 0; 4771 pinstance->host_toggle_bit[i] = 0; 4772 } 4773 } 4774 4775 /** 4776 * pmcraid_allocate_host_rrqs - Allocate and initialize host RRQ buffers 4777 * @pinstance: pointer to per adapter instance structure 4778 * 4779 * Return value 4780 * 0 hrrq buffers are allocated, -ENOMEM otherwise. 4781 */ 4782 static int pmcraid_allocate_host_rrqs(struct pmcraid_instance *pinstance) 4783 { 4784 int i, buffer_size; 4785 4786 buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD; 4787 4788 for (i = 0; i < pinstance->num_hrrq; i++) { 4789 pinstance->hrrq_start[i] = 4790 pci_alloc_consistent( 4791 pinstance->pdev, 4792 buffer_size, 4793 &(pinstance->hrrq_start_bus_addr[i])); 4794 4795 if (!pinstance->hrrq_start[i]) { 4796 pmcraid_err("pci_alloc failed for hrrq vector : %d\n", 4797 i); 4798 pmcraid_release_host_rrqs(pinstance, i); 4799 return -ENOMEM; 4800 } 4801 4802 memset(pinstance->hrrq_start[i], 0, buffer_size); 4803 pinstance->hrrq_curr[i] = pinstance->hrrq_start[i]; 4804 pinstance->hrrq_end[i] = 4805 pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1; 4806 pinstance->host_toggle_bit[i] = 1; 4807 spin_lock_init(&pinstance->hrrq_lock[i]); 4808 } 4809 return 0; 4810 } 4811 4812 /** 4813 * pmcraid_release_hcams - release HCAM buffers 4814 * 4815 * @pinstance: pointer to per adapter instance structure 4816 * 4817 * Return value 4818 * none 4819 */ 4820 static void pmcraid_release_hcams(struct pmcraid_instance *pinstance) 4821 { 4822 if (pinstance->ccn.msg != NULL) { 4823 pci_free_consistent(pinstance->pdev, 4824 PMCRAID_AEN_HDR_SIZE + 4825 sizeof(struct pmcraid_hcam_ccn_ext), 4826 pinstance->ccn.msg, 4827 pinstance->ccn.baddr); 4828 4829 pinstance->ccn.msg = NULL; 4830 pinstance->ccn.hcam = NULL; 4831 pinstance->ccn.baddr = 0; 4832 } 4833 4834 if (pinstance->ldn.msg != NULL) { 4835 pci_free_consistent(pinstance->pdev, 4836 PMCRAID_AEN_HDR_SIZE + 4837 sizeof(struct pmcraid_hcam_ldn), 4838 pinstance->ldn.msg, 4839 pinstance->ldn.baddr); 4840 4841 pinstance->ldn.msg = NULL; 4842 pinstance->ldn.hcam = NULL; 4843 pinstance->ldn.baddr = 0; 4844 } 4845 } 4846 4847 /** 4848 * pmcraid_allocate_hcams - allocates HCAM buffers 4849 * @pinstance : pointer to per adapter instance structure 4850 * 4851 * Return Value: 4852 * 0 in case of successful allocation, non-zero otherwise 4853 */ 4854 static int pmcraid_allocate_hcams(struct pmcraid_instance *pinstance) 4855 { 4856 pinstance->ccn.msg = pci_alloc_consistent( 4857 pinstance->pdev, 4858 PMCRAID_AEN_HDR_SIZE + 4859 sizeof(struct pmcraid_hcam_ccn_ext), 4860 &(pinstance->ccn.baddr)); 4861 4862 pinstance->ldn.msg = pci_alloc_consistent( 4863 pinstance->pdev, 4864 PMCRAID_AEN_HDR_SIZE + 4865 sizeof(struct pmcraid_hcam_ldn), 4866 &(pinstance->ldn.baddr)); 4867 4868 if (pinstance->ldn.msg == NULL || pinstance->ccn.msg == NULL) { 4869 pmcraid_release_hcams(pinstance); 4870 } else { 4871 pinstance->ccn.hcam = 4872 (void *)pinstance->ccn.msg + PMCRAID_AEN_HDR_SIZE; 4873 pinstance->ldn.hcam = 4874 (void *)pinstance->ldn.msg + PMCRAID_AEN_HDR_SIZE; 4875 4876 atomic_set(&pinstance->ccn.ignore, 0); 4877 atomic_set(&pinstance->ldn.ignore, 0); 4878 } 4879 4880 return (pinstance->ldn.msg == NULL) ? -ENOMEM : 0; 4881 } 4882 4883 /** 4884 * pmcraid_release_config_buffers - release config.table buffers 4885 * @pinstance: pointer to per adapter instance structure 4886 * 4887 * Return Value 4888 * none 4889 */ 4890 static void pmcraid_release_config_buffers(struct pmcraid_instance *pinstance) 4891 { 4892 if (pinstance->cfg_table != NULL && 4893 pinstance->cfg_table_bus_addr != 0) { 4894 pci_free_consistent(pinstance->pdev, 4895 sizeof(struct pmcraid_config_table), 4896 pinstance->cfg_table, 4897 pinstance->cfg_table_bus_addr); 4898 pinstance->cfg_table = NULL; 4899 pinstance->cfg_table_bus_addr = 0; 4900 } 4901 4902 if (pinstance->res_entries != NULL) { 4903 int i; 4904 4905 for (i = 0; i < PMCRAID_MAX_RESOURCES; i++) 4906 list_del(&pinstance->res_entries[i].queue); 4907 kfree(pinstance->res_entries); 4908 pinstance->res_entries = NULL; 4909 } 4910 4911 pmcraid_release_hcams(pinstance); 4912 } 4913 4914 /** 4915 * pmcraid_allocate_config_buffers - allocates DMAable memory for config table 4916 * @pinstance : pointer to per adapter instance structure 4917 * 4918 * Return Value 4919 * 0 for successful allocation, -ENOMEM for any failure 4920 */ 4921 static int pmcraid_allocate_config_buffers(struct pmcraid_instance *pinstance) 4922 { 4923 int i; 4924 4925 pinstance->res_entries = 4926 kzalloc(sizeof(struct pmcraid_resource_entry) * 4927 PMCRAID_MAX_RESOURCES, GFP_KERNEL); 4928 4929 if (NULL == pinstance->res_entries) { 4930 pmcraid_err("failed to allocate memory for resource table\n"); 4931 return -ENOMEM; 4932 } 4933 4934 for (i = 0; i < PMCRAID_MAX_RESOURCES; i++) 4935 list_add_tail(&pinstance->res_entries[i].queue, 4936 &pinstance->free_res_q); 4937 4938 pinstance->cfg_table = 4939 pci_alloc_consistent(pinstance->pdev, 4940 sizeof(struct pmcraid_config_table), 4941 &pinstance->cfg_table_bus_addr); 4942 4943 if (NULL == pinstance->cfg_table) { 4944 pmcraid_err("couldn't alloc DMA memory for config table\n"); 4945 pmcraid_release_config_buffers(pinstance); 4946 return -ENOMEM; 4947 } 4948 4949 if (pmcraid_allocate_hcams(pinstance)) { 4950 pmcraid_err("could not alloc DMA memory for HCAMS\n"); 4951 pmcraid_release_config_buffers(pinstance); 4952 return -ENOMEM; 4953 } 4954 4955 return 0; 4956 } 4957 4958 /** 4959 * pmcraid_init_tasklets - registers tasklets for response handling 4960 * 4961 * @pinstance: pointer adapter instance structure 4962 * 4963 * Return value 4964 * none 4965 */ 4966 static void pmcraid_init_tasklets(struct pmcraid_instance *pinstance) 4967 { 4968 int i; 4969 for (i = 0; i < pinstance->num_hrrq; i++) 4970 tasklet_init(&pinstance->isr_tasklet[i], 4971 pmcraid_tasklet_function, 4972 (unsigned long)&pinstance->hrrq_vector[i]); 4973 } 4974 4975 /** 4976 * pmcraid_kill_tasklets - destroys tasklets registered for response handling 4977 * 4978 * @pinstance: pointer to adapter instance structure 4979 * 4980 * Return value 4981 * none 4982 */ 4983 static void pmcraid_kill_tasklets(struct pmcraid_instance *pinstance) 4984 { 4985 int i; 4986 for (i = 0; i < pinstance->num_hrrq; i++) 4987 tasklet_kill(&pinstance->isr_tasklet[i]); 4988 } 4989 4990 /** 4991 * pmcraid_release_buffers - release per-adapter buffers allocated 4992 * 4993 * @pinstance: pointer to adapter soft state 4994 * 4995 * Return Value 4996 * none 4997 */ 4998 static void pmcraid_release_buffers(struct pmcraid_instance *pinstance) 4999 { 5000 pmcraid_release_config_buffers(pinstance); 5001 pmcraid_release_control_blocks(pinstance, PMCRAID_MAX_CMD); 5002 pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD); 5003 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq); 5004 5005 if (pinstance->inq_data != NULL) { 5006 pci_free_consistent(pinstance->pdev, 5007 sizeof(struct pmcraid_inquiry_data), 5008 pinstance->inq_data, 5009 pinstance->inq_data_baddr); 5010 5011 pinstance->inq_data = NULL; 5012 pinstance->inq_data_baddr = 0; 5013 } 5014 5015 if (pinstance->timestamp_data != NULL) { 5016 pci_free_consistent(pinstance->pdev, 5017 sizeof(struct pmcraid_timestamp_data), 5018 pinstance->timestamp_data, 5019 pinstance->timestamp_data_baddr); 5020 5021 pinstance->timestamp_data = NULL; 5022 pinstance->timestamp_data_baddr = 0; 5023 } 5024 } 5025 5026 /** 5027 * pmcraid_init_buffers - allocates memory and initializes various structures 5028 * @pinstance: pointer to per adapter instance structure 5029 * 5030 * This routine pre-allocates memory based on the type of block as below: 5031 * cmdblocks(PMCRAID_MAX_CMD): kernel memory using kernel's slab_allocator, 5032 * IOARCBs(PMCRAID_MAX_CMD) : DMAable memory, using pci pool allocator 5033 * config-table entries : DMAable memory using pci_alloc_consistent 5034 * HostRRQs : DMAable memory, using pci_alloc_consistent 5035 * 5036 * Return Value 5037 * 0 in case all of the blocks are allocated, -ENOMEM otherwise. 5038 */ 5039 static int pmcraid_init_buffers(struct pmcraid_instance *pinstance) 5040 { 5041 int i; 5042 5043 if (pmcraid_allocate_host_rrqs(pinstance)) { 5044 pmcraid_err("couldn't allocate memory for %d host rrqs\n", 5045 pinstance->num_hrrq); 5046 return -ENOMEM; 5047 } 5048 5049 if (pmcraid_allocate_config_buffers(pinstance)) { 5050 pmcraid_err("couldn't allocate memory for config buffers\n"); 5051 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq); 5052 return -ENOMEM; 5053 } 5054 5055 if (pmcraid_allocate_cmd_blocks(pinstance)) { 5056 pmcraid_err("couldn't allocate memory for cmd blocks\n"); 5057 pmcraid_release_config_buffers(pinstance); 5058 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq); 5059 return -ENOMEM; 5060 } 5061 5062 if (pmcraid_allocate_control_blocks(pinstance)) { 5063 pmcraid_err("couldn't allocate memory control blocks\n"); 5064 pmcraid_release_config_buffers(pinstance); 5065 pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD); 5066 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq); 5067 return -ENOMEM; 5068 } 5069 5070 /* allocate DMAable memory for page D0 INQUIRY buffer */ 5071 pinstance->inq_data = pci_alloc_consistent( 5072 pinstance->pdev, 5073 sizeof(struct pmcraid_inquiry_data), 5074 &pinstance->inq_data_baddr); 5075 5076 if (pinstance->inq_data == NULL) { 5077 pmcraid_err("couldn't allocate DMA memory for INQUIRY\n"); 5078 pmcraid_release_buffers(pinstance); 5079 return -ENOMEM; 5080 } 5081 5082 /* allocate DMAable memory for set timestamp data buffer */ 5083 pinstance->timestamp_data = pci_alloc_consistent( 5084 pinstance->pdev, 5085 sizeof(struct pmcraid_timestamp_data), 5086 &pinstance->timestamp_data_baddr); 5087 5088 if (pinstance->timestamp_data == NULL) { 5089 pmcraid_err("couldn't allocate DMA memory for \ 5090 set time_stamp \n"); 5091 pmcraid_release_buffers(pinstance); 5092 return -ENOMEM; 5093 } 5094 5095 5096 /* Initialize all the command blocks and add them to free pool. No 5097 * need to lock (free_pool_lock) as this is done in initialization 5098 * itself 5099 */ 5100 for (i = 0; i < PMCRAID_MAX_CMD; i++) { 5101 struct pmcraid_cmd *cmdp = pinstance->cmd_list[i]; 5102 pmcraid_init_cmdblk(cmdp, i); 5103 cmdp->drv_inst = pinstance; 5104 list_add_tail(&cmdp->free_list, &pinstance->free_cmd_pool); 5105 } 5106 5107 return 0; 5108 } 5109 5110 /** 5111 * pmcraid_reinit_buffers - resets various buffer pointers 5112 * @pinstance: pointer to adapter instance 5113 * Return value 5114 * none 5115 */ 5116 static void pmcraid_reinit_buffers(struct pmcraid_instance *pinstance) 5117 { 5118 int i; 5119 int buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD; 5120 5121 for (i = 0; i < pinstance->num_hrrq; i++) { 5122 memset(pinstance->hrrq_start[i], 0, buffer_size); 5123 pinstance->hrrq_curr[i] = pinstance->hrrq_start[i]; 5124 pinstance->hrrq_end[i] = 5125 pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1; 5126 pinstance->host_toggle_bit[i] = 1; 5127 } 5128 } 5129 5130 /** 5131 * pmcraid_init_instance - initialize per instance data structure 5132 * @pdev: pointer to pci device structure 5133 * @host: pointer to Scsi_Host structure 5134 * @mapped_pci_addr: memory mapped IOA configuration registers 5135 * 5136 * Return Value 5137 * 0 on success, non-zero in case of any failure 5138 */ 5139 static int pmcraid_init_instance(struct pci_dev *pdev, struct Scsi_Host *host, 5140 void __iomem *mapped_pci_addr) 5141 { 5142 struct pmcraid_instance *pinstance = 5143 (struct pmcraid_instance *)host->hostdata; 5144 5145 pinstance->host = host; 5146 pinstance->pdev = pdev; 5147 5148 /* Initialize register addresses */ 5149 pinstance->mapped_dma_addr = mapped_pci_addr; 5150 5151 /* Initialize chip-specific details */ 5152 { 5153 struct pmcraid_chip_details *chip_cfg = pinstance->chip_cfg; 5154 struct pmcraid_interrupts *pint_regs = &pinstance->int_regs; 5155 5156 pinstance->ioarrin = mapped_pci_addr + chip_cfg->ioarrin; 5157 5158 pint_regs->ioa_host_interrupt_reg = 5159 mapped_pci_addr + chip_cfg->ioa_host_intr; 5160 pint_regs->ioa_host_interrupt_clr_reg = 5161 mapped_pci_addr + chip_cfg->ioa_host_intr_clr; 5162 pint_regs->ioa_host_msix_interrupt_reg = 5163 mapped_pci_addr + chip_cfg->ioa_host_msix_intr; 5164 pint_regs->host_ioa_interrupt_reg = 5165 mapped_pci_addr + chip_cfg->host_ioa_intr; 5166 pint_regs->host_ioa_interrupt_clr_reg = 5167 mapped_pci_addr + chip_cfg->host_ioa_intr_clr; 5168 5169 /* Current version of firmware exposes interrupt mask set 5170 * and mask clr registers through memory mapped bar0. 5171 */ 5172 pinstance->mailbox = mapped_pci_addr + chip_cfg->mailbox; 5173 pinstance->ioa_status = mapped_pci_addr + chip_cfg->ioastatus; 5174 pint_regs->ioa_host_interrupt_mask_reg = 5175 mapped_pci_addr + chip_cfg->ioa_host_mask; 5176 pint_regs->ioa_host_interrupt_mask_clr_reg = 5177 mapped_pci_addr + chip_cfg->ioa_host_mask_clr; 5178 pint_regs->global_interrupt_mask_reg = 5179 mapped_pci_addr + chip_cfg->global_intr_mask; 5180 }; 5181 5182 pinstance->ioa_reset_attempts = 0; 5183 init_waitqueue_head(&pinstance->reset_wait_q); 5184 5185 atomic_set(&pinstance->outstanding_cmds, 0); 5186 atomic_set(&pinstance->last_message_id, 0); 5187 atomic_set(&pinstance->expose_resources, 0); 5188 5189 INIT_LIST_HEAD(&pinstance->free_res_q); 5190 INIT_LIST_HEAD(&pinstance->used_res_q); 5191 INIT_LIST_HEAD(&pinstance->free_cmd_pool); 5192 INIT_LIST_HEAD(&pinstance->pending_cmd_pool); 5193 5194 spin_lock_init(&pinstance->free_pool_lock); 5195 spin_lock_init(&pinstance->pending_pool_lock); 5196 spin_lock_init(&pinstance->resource_lock); 5197 mutex_init(&pinstance->aen_queue_lock); 5198 5199 /* Work-queue (Shared) for deferred processing error handling */ 5200 INIT_WORK(&pinstance->worker_q, pmcraid_worker_function); 5201 5202 /* Initialize the default log_level */ 5203 pinstance->current_log_level = pmcraid_log_level; 5204 5205 /* Setup variables required for reset engine */ 5206 pinstance->ioa_state = IOA_STATE_UNKNOWN; 5207 pinstance->reset_cmd = NULL; 5208 return 0; 5209 } 5210 5211 /** 5212 * pmcraid_shutdown - shutdown adapter controller. 5213 * @pdev: pci device struct 5214 * 5215 * Issues an adapter shutdown to the card waits for its completion 5216 * 5217 * Return value 5218 * none 5219 */ 5220 static void pmcraid_shutdown(struct pci_dev *pdev) 5221 { 5222 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev); 5223 pmcraid_reset_bringdown(pinstance); 5224 } 5225 5226 5227 /** 5228 * pmcraid_get_minor - returns unused minor number from minor number bitmap 5229 */ 5230 static unsigned short pmcraid_get_minor(void) 5231 { 5232 int minor; 5233 5234 minor = find_first_zero_bit(pmcraid_minor, sizeof(pmcraid_minor)); 5235 __set_bit(minor, pmcraid_minor); 5236 return minor; 5237 } 5238 5239 /** 5240 * pmcraid_release_minor - releases given minor back to minor number bitmap 5241 */ 5242 static void pmcraid_release_minor(unsigned short minor) 5243 { 5244 __clear_bit(minor, pmcraid_minor); 5245 } 5246 5247 /** 5248 * pmcraid_setup_chrdev - allocates a minor number and registers a char device 5249 * 5250 * @pinstance: pointer to adapter instance for which to register device 5251 * 5252 * Return value 5253 * 0 in case of success, otherwise non-zero 5254 */ 5255 static int pmcraid_setup_chrdev(struct pmcraid_instance *pinstance) 5256 { 5257 int minor; 5258 int error; 5259 5260 minor = pmcraid_get_minor(); 5261 cdev_init(&pinstance->cdev, &pmcraid_fops); 5262 pinstance->cdev.owner = THIS_MODULE; 5263 5264 error = cdev_add(&pinstance->cdev, MKDEV(pmcraid_major, minor), 1); 5265 5266 if (error) 5267 pmcraid_release_minor(minor); 5268 else 5269 device_create(pmcraid_class, NULL, MKDEV(pmcraid_major, minor), 5270 NULL, "%s%u", PMCRAID_DEVFILE, minor); 5271 return error; 5272 } 5273 5274 /** 5275 * pmcraid_release_chrdev - unregisters per-adapter management interface 5276 * 5277 * @pinstance: pointer to adapter instance structure 5278 * 5279 * Return value 5280 * none 5281 */ 5282 static void pmcraid_release_chrdev(struct pmcraid_instance *pinstance) 5283 { 5284 pmcraid_release_minor(MINOR(pinstance->cdev.dev)); 5285 device_destroy(pmcraid_class, 5286 MKDEV(pmcraid_major, MINOR(pinstance->cdev.dev))); 5287 cdev_del(&pinstance->cdev); 5288 } 5289 5290 /** 5291 * pmcraid_remove - IOA hot plug remove entry point 5292 * @pdev: pci device struct 5293 * 5294 * Return value 5295 * none 5296 */ 5297 static void pmcraid_remove(struct pci_dev *pdev) 5298 { 5299 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev); 5300 5301 /* remove the management interface (/dev file) for this device */ 5302 pmcraid_release_chrdev(pinstance); 5303 5304 /* remove host template from scsi midlayer */ 5305 scsi_remove_host(pinstance->host); 5306 5307 /* block requests from mid-layer */ 5308 scsi_block_requests(pinstance->host); 5309 5310 /* initiate shutdown adapter */ 5311 pmcraid_shutdown(pdev); 5312 5313 pmcraid_disable_interrupts(pinstance, ~0); 5314 flush_work(&pinstance->worker_q); 5315 5316 pmcraid_kill_tasklets(pinstance); 5317 pmcraid_unregister_interrupt_handler(pinstance); 5318 pmcraid_release_buffers(pinstance); 5319 iounmap(pinstance->mapped_dma_addr); 5320 pci_release_regions(pdev); 5321 scsi_host_put(pinstance->host); 5322 pci_disable_device(pdev); 5323 5324 return; 5325 } 5326 5327 #ifdef CONFIG_PM 5328 /** 5329 * pmcraid_suspend - driver suspend entry point for power management 5330 * @pdev: PCI device structure 5331 * @state: PCI power state to suspend routine 5332 * 5333 * Return Value - 0 always 5334 */ 5335 static int pmcraid_suspend(struct pci_dev *pdev, pm_message_t state) 5336 { 5337 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev); 5338 5339 pmcraid_shutdown(pdev); 5340 pmcraid_disable_interrupts(pinstance, ~0); 5341 pmcraid_kill_tasklets(pinstance); 5342 pci_set_drvdata(pinstance->pdev, pinstance); 5343 pmcraid_unregister_interrupt_handler(pinstance); 5344 pci_save_state(pdev); 5345 pci_disable_device(pdev); 5346 pci_set_power_state(pdev, pci_choose_state(pdev, state)); 5347 5348 return 0; 5349 } 5350 5351 /** 5352 * pmcraid_resume - driver resume entry point PCI power management 5353 * @pdev: PCI device structure 5354 * 5355 * Return Value - 0 in case of success. Error code in case of any failure 5356 */ 5357 static int pmcraid_resume(struct pci_dev *pdev) 5358 { 5359 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev); 5360 struct Scsi_Host *host = pinstance->host; 5361 int rc; 5362 5363 pci_set_power_state(pdev, PCI_D0); 5364 pci_enable_wake(pdev, PCI_D0, 0); 5365 pci_restore_state(pdev); 5366 5367 rc = pci_enable_device(pdev); 5368 5369 if (rc) { 5370 dev_err(&pdev->dev, "resume: Enable device failed\n"); 5371 return rc; 5372 } 5373 5374 pci_set_master(pdev); 5375 5376 if ((sizeof(dma_addr_t) == 4) || 5377 pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) 5378 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 5379 5380 if (rc == 0) 5381 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); 5382 5383 if (rc != 0) { 5384 dev_err(&pdev->dev, "resume: Failed to set PCI DMA mask\n"); 5385 goto disable_device; 5386 } 5387 5388 pmcraid_disable_interrupts(pinstance, ~0); 5389 atomic_set(&pinstance->outstanding_cmds, 0); 5390 rc = pmcraid_register_interrupt_handler(pinstance); 5391 5392 if (rc) { 5393 dev_err(&pdev->dev, 5394 "resume: couldn't register interrupt handlers\n"); 5395 rc = -ENODEV; 5396 goto release_host; 5397 } 5398 5399 pmcraid_init_tasklets(pinstance); 5400 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS); 5401 5402 /* Start with hard reset sequence which brings up IOA to operational 5403 * state as well as completes the reset sequence. 5404 */ 5405 pinstance->ioa_hard_reset = 1; 5406 5407 /* Start IOA firmware initialization and bring card to Operational 5408 * state. 5409 */ 5410 if (pmcraid_reset_bringup(pinstance)) { 5411 dev_err(&pdev->dev, "couldn't initialize IOA\n"); 5412 rc = -ENODEV; 5413 goto release_tasklets; 5414 } 5415 5416 return 0; 5417 5418 release_tasklets: 5419 pmcraid_disable_interrupts(pinstance, ~0); 5420 pmcraid_kill_tasklets(pinstance); 5421 pmcraid_unregister_interrupt_handler(pinstance); 5422 5423 release_host: 5424 scsi_host_put(host); 5425 5426 disable_device: 5427 pci_disable_device(pdev); 5428 5429 return rc; 5430 } 5431 5432 #else 5433 5434 #define pmcraid_suspend NULL 5435 #define pmcraid_resume NULL 5436 5437 #endif /* CONFIG_PM */ 5438 5439 /** 5440 * pmcraid_complete_ioa_reset - Called by either timer or tasklet during 5441 * completion of the ioa reset 5442 * @cmd: pointer to reset command block 5443 */ 5444 static void pmcraid_complete_ioa_reset(struct pmcraid_cmd *cmd) 5445 { 5446 struct pmcraid_instance *pinstance = cmd->drv_inst; 5447 unsigned long flags; 5448 5449 spin_lock_irqsave(pinstance->host->host_lock, flags); 5450 pmcraid_ioa_reset(cmd); 5451 spin_unlock_irqrestore(pinstance->host->host_lock, flags); 5452 scsi_unblock_requests(pinstance->host); 5453 schedule_work(&pinstance->worker_q); 5454 } 5455 5456 /** 5457 * pmcraid_set_supported_devs - sends SET SUPPORTED DEVICES to IOAFP 5458 * 5459 * @cmd: pointer to pmcraid_cmd structure 5460 * 5461 * Return Value 5462 * 0 for success or non-zero for failure cases 5463 */ 5464 static void pmcraid_set_supported_devs(struct pmcraid_cmd *cmd) 5465 { 5466 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 5467 void (*cmd_done) (struct pmcraid_cmd *) = pmcraid_complete_ioa_reset; 5468 5469 pmcraid_reinit_cmdblk(cmd); 5470 5471 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE); 5472 ioarcb->request_type = REQ_TYPE_IOACMD; 5473 ioarcb->cdb[0] = PMCRAID_SET_SUPPORTED_DEVICES; 5474 ioarcb->cdb[1] = ALL_DEVICES_SUPPORTED; 5475 5476 /* If this was called as part of resource table reinitialization due to 5477 * lost CCN, it is enough to return the command block back to free pool 5478 * as part of set_supported_devs completion function. 5479 */ 5480 if (cmd->drv_inst->reinit_cfg_table) { 5481 cmd->drv_inst->reinit_cfg_table = 0; 5482 cmd->release = 1; 5483 cmd_done = pmcraid_reinit_cfgtable_done; 5484 } 5485 5486 /* we will be done with the reset sequence after set supported devices, 5487 * setup the done function to return the command block back to free 5488 * pool 5489 */ 5490 pmcraid_send_cmd(cmd, 5491 cmd_done, 5492 PMCRAID_SET_SUP_DEV_TIMEOUT, 5493 pmcraid_timeout_handler); 5494 return; 5495 } 5496 5497 /** 5498 * pmcraid_set_timestamp - set the timestamp to IOAFP 5499 * 5500 * @cmd: pointer to pmcraid_cmd structure 5501 * 5502 * Return Value 5503 * 0 for success or non-zero for failure cases 5504 */ 5505 static void pmcraid_set_timestamp(struct pmcraid_cmd *cmd) 5506 { 5507 struct pmcraid_instance *pinstance = cmd->drv_inst; 5508 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 5509 __be32 time_stamp_len = cpu_to_be32(PMCRAID_TIMESTAMP_LEN); 5510 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl; 5511 u64 timestamp; 5512 5513 timestamp = ktime_get_real_seconds() * 1000; 5514 5515 pinstance->timestamp_data->timestamp[0] = (__u8)(timestamp); 5516 pinstance->timestamp_data->timestamp[1] = (__u8)((timestamp) >> 8); 5517 pinstance->timestamp_data->timestamp[2] = (__u8)((timestamp) >> 16); 5518 pinstance->timestamp_data->timestamp[3] = (__u8)((timestamp) >> 24); 5519 pinstance->timestamp_data->timestamp[4] = (__u8)((timestamp) >> 32); 5520 pinstance->timestamp_data->timestamp[5] = (__u8)((timestamp) >> 40); 5521 5522 pmcraid_reinit_cmdblk(cmd); 5523 ioarcb->request_type = REQ_TYPE_SCSI; 5524 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE); 5525 ioarcb->cdb[0] = PMCRAID_SCSI_SET_TIMESTAMP; 5526 ioarcb->cdb[1] = PMCRAID_SCSI_SERVICE_ACTION; 5527 memcpy(&(ioarcb->cdb[6]), &time_stamp_len, sizeof(time_stamp_len)); 5528 5529 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) + 5530 offsetof(struct pmcraid_ioarcb, 5531 add_data.u.ioadl[0])); 5532 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc)); 5533 ioarcb->ioarcb_bus_addr &= cpu_to_le64(~(0x1FULL)); 5534 5535 ioarcb->request_flags0 |= NO_LINK_DESCS; 5536 ioarcb->request_flags0 |= TRANSFER_DIR_WRITE; 5537 ioarcb->data_transfer_length = 5538 cpu_to_le32(sizeof(struct pmcraid_timestamp_data)); 5539 ioadl = &(ioarcb->add_data.u.ioadl[0]); 5540 ioadl->flags = IOADL_FLAGS_LAST_DESC; 5541 ioadl->address = cpu_to_le64(pinstance->timestamp_data_baddr); 5542 ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_timestamp_data)); 5543 5544 if (!pinstance->timestamp_error) { 5545 pinstance->timestamp_error = 0; 5546 pmcraid_send_cmd(cmd, pmcraid_set_supported_devs, 5547 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler); 5548 } else { 5549 pmcraid_send_cmd(cmd, pmcraid_return_cmd, 5550 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler); 5551 return; 5552 } 5553 } 5554 5555 5556 /** 5557 * pmcraid_init_res_table - Initialize the resource table 5558 * @cmd: pointer to pmcraid command struct 5559 * 5560 * This function looks through the existing resource table, comparing 5561 * it with the config table. This function will take care of old/new 5562 * devices and schedule adding/removing them from the mid-layer 5563 * as appropriate. 5564 * 5565 * Return value 5566 * None 5567 */ 5568 static void pmcraid_init_res_table(struct pmcraid_cmd *cmd) 5569 { 5570 struct pmcraid_instance *pinstance = cmd->drv_inst; 5571 struct pmcraid_resource_entry *res, *temp; 5572 struct pmcraid_config_table_entry *cfgte; 5573 unsigned long lock_flags; 5574 int found, rc, i; 5575 u16 fw_version; 5576 LIST_HEAD(old_res); 5577 5578 if (pinstance->cfg_table->flags & MICROCODE_UPDATE_REQUIRED) 5579 pmcraid_err("IOA requires microcode download\n"); 5580 5581 fw_version = be16_to_cpu(pinstance->inq_data->fw_version); 5582 5583 /* resource list is protected by pinstance->resource_lock. 5584 * init_res_table can be called from probe (user-thread) or runtime 5585 * reset (timer/tasklet) 5586 */ 5587 spin_lock_irqsave(&pinstance->resource_lock, lock_flags); 5588 5589 list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue) 5590 list_move_tail(&res->queue, &old_res); 5591 5592 for (i = 0; i < le16_to_cpu(pinstance->cfg_table->num_entries); i++) { 5593 if (be16_to_cpu(pinstance->inq_data->fw_version) <= 5594 PMCRAID_FW_VERSION_1) 5595 cfgte = &pinstance->cfg_table->entries[i]; 5596 else 5597 cfgte = (struct pmcraid_config_table_entry *) 5598 &pinstance->cfg_table->entries_ext[i]; 5599 5600 if (!pmcraid_expose_resource(fw_version, cfgte)) 5601 continue; 5602 5603 found = 0; 5604 5605 /* If this entry was already detected and initialized */ 5606 list_for_each_entry_safe(res, temp, &old_res, queue) { 5607 5608 rc = memcmp(&res->cfg_entry.resource_address, 5609 &cfgte->resource_address, 5610 sizeof(cfgte->resource_address)); 5611 if (!rc) { 5612 list_move_tail(&res->queue, 5613 &pinstance->used_res_q); 5614 found = 1; 5615 break; 5616 } 5617 } 5618 5619 /* If this is new entry, initialize it and add it the queue */ 5620 if (!found) { 5621 5622 if (list_empty(&pinstance->free_res_q)) { 5623 pmcraid_err("Too many devices attached\n"); 5624 break; 5625 } 5626 5627 found = 1; 5628 res = list_entry(pinstance->free_res_q.next, 5629 struct pmcraid_resource_entry, queue); 5630 5631 res->scsi_dev = NULL; 5632 res->change_detected = RES_CHANGE_ADD; 5633 res->reset_progress = 0; 5634 list_move_tail(&res->queue, &pinstance->used_res_q); 5635 } 5636 5637 /* copy new configuration table entry details into driver 5638 * maintained resource entry 5639 */ 5640 if (found) { 5641 memcpy(&res->cfg_entry, cfgte, 5642 pinstance->config_table_entry_size); 5643 pmcraid_info("New res type:%x, vset:%x, addr:%x:\n", 5644 res->cfg_entry.resource_type, 5645 (fw_version <= PMCRAID_FW_VERSION_1 ? 5646 res->cfg_entry.unique_flags1 : 5647 le16_to_cpu(res->cfg_entry.array_id) & 0xFF), 5648 le32_to_cpu(res->cfg_entry.resource_address)); 5649 } 5650 } 5651 5652 /* Detect any deleted entries, mark them for deletion from mid-layer */ 5653 list_for_each_entry_safe(res, temp, &old_res, queue) { 5654 5655 if (res->scsi_dev) { 5656 res->change_detected = RES_CHANGE_DEL; 5657 res->cfg_entry.resource_handle = 5658 PMCRAID_INVALID_RES_HANDLE; 5659 list_move_tail(&res->queue, &pinstance->used_res_q); 5660 } else { 5661 list_move_tail(&res->queue, &pinstance->free_res_q); 5662 } 5663 } 5664 5665 /* release the resource list lock */ 5666 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags); 5667 pmcraid_set_timestamp(cmd); 5668 } 5669 5670 /** 5671 * pmcraid_querycfg - Send a Query IOA Config to the adapter. 5672 * @cmd: pointer pmcraid_cmd struct 5673 * 5674 * This function sends a Query IOA Configuration command to the adapter to 5675 * retrieve the IOA configuration table. 5676 * 5677 * Return value: 5678 * none 5679 */ 5680 static void pmcraid_querycfg(struct pmcraid_cmd *cmd) 5681 { 5682 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 5683 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl; 5684 struct pmcraid_instance *pinstance = cmd->drv_inst; 5685 __be32 cfg_table_size = cpu_to_be32(sizeof(struct pmcraid_config_table)); 5686 5687 if (be16_to_cpu(pinstance->inq_data->fw_version) <= 5688 PMCRAID_FW_VERSION_1) 5689 pinstance->config_table_entry_size = 5690 sizeof(struct pmcraid_config_table_entry); 5691 else 5692 pinstance->config_table_entry_size = 5693 sizeof(struct pmcraid_config_table_entry_ext); 5694 5695 ioarcb->request_type = REQ_TYPE_IOACMD; 5696 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE); 5697 5698 ioarcb->cdb[0] = PMCRAID_QUERY_IOA_CONFIG; 5699 5700 /* firmware requires 4-byte length field, specified in B.E format */ 5701 memcpy(&(ioarcb->cdb[10]), &cfg_table_size, sizeof(cfg_table_size)); 5702 5703 /* Since entire config table can be described by single IOADL, it can 5704 * be part of IOARCB itself 5705 */ 5706 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) + 5707 offsetof(struct pmcraid_ioarcb, 5708 add_data.u.ioadl[0])); 5709 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc)); 5710 ioarcb->ioarcb_bus_addr &= cpu_to_le64(~0x1FULL); 5711 5712 ioarcb->request_flags0 |= NO_LINK_DESCS; 5713 ioarcb->data_transfer_length = 5714 cpu_to_le32(sizeof(struct pmcraid_config_table)); 5715 5716 ioadl = &(ioarcb->add_data.u.ioadl[0]); 5717 ioadl->flags = IOADL_FLAGS_LAST_DESC; 5718 ioadl->address = cpu_to_le64(pinstance->cfg_table_bus_addr); 5719 ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_config_table)); 5720 5721 pmcraid_send_cmd(cmd, pmcraid_init_res_table, 5722 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler); 5723 } 5724 5725 5726 /** 5727 * pmcraid_probe - PCI probe entry pointer for PMC MaxRAID controller driver 5728 * @pdev: pointer to pci device structure 5729 * @dev_id: pointer to device ids structure 5730 * 5731 * Return Value 5732 * returns 0 if the device is claimed and successfully configured. 5733 * returns non-zero error code in case of any failure 5734 */ 5735 static int pmcraid_probe(struct pci_dev *pdev, 5736 const struct pci_device_id *dev_id) 5737 { 5738 struct pmcraid_instance *pinstance; 5739 struct Scsi_Host *host; 5740 void __iomem *mapped_pci_addr; 5741 int rc = PCIBIOS_SUCCESSFUL; 5742 5743 if (atomic_read(&pmcraid_adapter_count) >= PMCRAID_MAX_ADAPTERS) { 5744 pmcraid_err 5745 ("maximum number(%d) of supported adapters reached\n", 5746 atomic_read(&pmcraid_adapter_count)); 5747 return -ENOMEM; 5748 } 5749 5750 atomic_inc(&pmcraid_adapter_count); 5751 rc = pci_enable_device(pdev); 5752 5753 if (rc) { 5754 dev_err(&pdev->dev, "Cannot enable adapter\n"); 5755 atomic_dec(&pmcraid_adapter_count); 5756 return rc; 5757 } 5758 5759 dev_info(&pdev->dev, 5760 "Found new IOA(%x:%x), Total IOA count: %d\n", 5761 pdev->vendor, pdev->device, 5762 atomic_read(&pmcraid_adapter_count)); 5763 5764 rc = pci_request_regions(pdev, PMCRAID_DRIVER_NAME); 5765 5766 if (rc < 0) { 5767 dev_err(&pdev->dev, 5768 "Couldn't register memory range of registers\n"); 5769 goto out_disable_device; 5770 } 5771 5772 mapped_pci_addr = pci_iomap(pdev, 0, 0); 5773 5774 if (!mapped_pci_addr) { 5775 dev_err(&pdev->dev, "Couldn't map PCI registers memory\n"); 5776 rc = -ENOMEM; 5777 goto out_release_regions; 5778 } 5779 5780 pci_set_master(pdev); 5781 5782 /* Firmware requires the system bus address of IOARCB to be within 5783 * 32-bit addressable range though it has 64-bit IOARRIN register. 5784 * However, firmware supports 64-bit streaming DMA buffers, whereas 5785 * coherent buffers are to be 32-bit. Since pci_alloc_consistent always 5786 * returns memory within 4GB (if not, change this logic), coherent 5787 * buffers are within firmware acceptable address ranges. 5788 */ 5789 if ((sizeof(dma_addr_t) == 4) || 5790 pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) 5791 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 5792 5793 /* firmware expects 32-bit DMA addresses for IOARRIN register; set 32 5794 * bit mask for pci_alloc_consistent to return addresses within 4GB 5795 */ 5796 if (rc == 0) 5797 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); 5798 5799 if (rc != 0) { 5800 dev_err(&pdev->dev, "Failed to set PCI DMA mask\n"); 5801 goto cleanup_nomem; 5802 } 5803 5804 host = scsi_host_alloc(&pmcraid_host_template, 5805 sizeof(struct pmcraid_instance)); 5806 5807 if (!host) { 5808 dev_err(&pdev->dev, "scsi_host_alloc failed!\n"); 5809 rc = -ENOMEM; 5810 goto cleanup_nomem; 5811 } 5812 5813 host->max_id = PMCRAID_MAX_NUM_TARGETS_PER_BUS; 5814 host->max_lun = PMCRAID_MAX_NUM_LUNS_PER_TARGET; 5815 host->unique_id = host->host_no; 5816 host->max_channel = PMCRAID_MAX_BUS_TO_SCAN; 5817 host->max_cmd_len = PMCRAID_MAX_CDB_LEN; 5818 5819 /* zero out entire instance structure */ 5820 pinstance = (struct pmcraid_instance *)host->hostdata; 5821 memset(pinstance, 0, sizeof(*pinstance)); 5822 5823 pinstance->chip_cfg = 5824 (struct pmcraid_chip_details *)(dev_id->driver_data); 5825 5826 rc = pmcraid_init_instance(pdev, host, mapped_pci_addr); 5827 5828 if (rc < 0) { 5829 dev_err(&pdev->dev, "failed to initialize adapter instance\n"); 5830 goto out_scsi_host_put; 5831 } 5832 5833 pci_set_drvdata(pdev, pinstance); 5834 5835 /* Save PCI config-space for use following the reset */ 5836 rc = pci_save_state(pinstance->pdev); 5837 5838 if (rc != 0) { 5839 dev_err(&pdev->dev, "Failed to save PCI config space\n"); 5840 goto out_scsi_host_put; 5841 } 5842 5843 pmcraid_disable_interrupts(pinstance, ~0); 5844 5845 rc = pmcraid_register_interrupt_handler(pinstance); 5846 5847 if (rc) { 5848 dev_err(&pdev->dev, "couldn't register interrupt handler\n"); 5849 goto out_scsi_host_put; 5850 } 5851 5852 pmcraid_init_tasklets(pinstance); 5853 5854 /* allocate verious buffers used by LLD.*/ 5855 rc = pmcraid_init_buffers(pinstance); 5856 5857 if (rc) { 5858 pmcraid_err("couldn't allocate memory blocks\n"); 5859 goto out_unregister_isr; 5860 } 5861 5862 /* check the reset type required */ 5863 pmcraid_reset_type(pinstance); 5864 5865 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS); 5866 5867 /* Start IOA firmware initialization and bring card to Operational 5868 * state. 5869 */ 5870 pmcraid_info("starting IOA initialization sequence\n"); 5871 if (pmcraid_reset_bringup(pinstance)) { 5872 dev_err(&pdev->dev, "couldn't initialize IOA\n"); 5873 rc = 1; 5874 goto out_release_bufs; 5875 } 5876 5877 /* Add adapter instance into mid-layer list */ 5878 rc = scsi_add_host(pinstance->host, &pdev->dev); 5879 if (rc != 0) { 5880 pmcraid_err("couldn't add host into mid-layer: %d\n", rc); 5881 goto out_release_bufs; 5882 } 5883 5884 scsi_scan_host(pinstance->host); 5885 5886 rc = pmcraid_setup_chrdev(pinstance); 5887 5888 if (rc != 0) { 5889 pmcraid_err("couldn't create mgmt interface, error: %x\n", 5890 rc); 5891 goto out_remove_host; 5892 } 5893 5894 /* Schedule worker thread to handle CCN and take care of adding and 5895 * removing devices to OS 5896 */ 5897 atomic_set(&pinstance->expose_resources, 1); 5898 schedule_work(&pinstance->worker_q); 5899 return rc; 5900 5901 out_remove_host: 5902 scsi_remove_host(host); 5903 5904 out_release_bufs: 5905 pmcraid_release_buffers(pinstance); 5906 5907 out_unregister_isr: 5908 pmcraid_kill_tasklets(pinstance); 5909 pmcraid_unregister_interrupt_handler(pinstance); 5910 5911 out_scsi_host_put: 5912 scsi_host_put(host); 5913 5914 cleanup_nomem: 5915 iounmap(mapped_pci_addr); 5916 5917 out_release_regions: 5918 pci_release_regions(pdev); 5919 5920 out_disable_device: 5921 atomic_dec(&pmcraid_adapter_count); 5922 pci_disable_device(pdev); 5923 return -ENODEV; 5924 } 5925 5926 /* 5927 * PCI driver structure of pcmraid driver 5928 */ 5929 static struct pci_driver pmcraid_driver = { 5930 .name = PMCRAID_DRIVER_NAME, 5931 .id_table = pmcraid_pci_table, 5932 .probe = pmcraid_probe, 5933 .remove = pmcraid_remove, 5934 .suspend = pmcraid_suspend, 5935 .resume = pmcraid_resume, 5936 .shutdown = pmcraid_shutdown 5937 }; 5938 5939 /** 5940 * pmcraid_init - module load entry point 5941 */ 5942 static int __init pmcraid_init(void) 5943 { 5944 dev_t dev; 5945 int error; 5946 5947 pmcraid_info("%s Device Driver version: %s\n", 5948 PMCRAID_DRIVER_NAME, PMCRAID_DRIVER_VERSION); 5949 5950 error = alloc_chrdev_region(&dev, 0, 5951 PMCRAID_MAX_ADAPTERS, 5952 PMCRAID_DEVFILE); 5953 5954 if (error) { 5955 pmcraid_err("failed to get a major number for adapters\n"); 5956 goto out_init; 5957 } 5958 5959 pmcraid_major = MAJOR(dev); 5960 pmcraid_class = class_create(THIS_MODULE, PMCRAID_DEVFILE); 5961 5962 if (IS_ERR(pmcraid_class)) { 5963 error = PTR_ERR(pmcraid_class); 5964 pmcraid_err("failed to register with sysfs, error = %x\n", 5965 error); 5966 goto out_unreg_chrdev; 5967 } 5968 5969 error = pmcraid_netlink_init(); 5970 5971 if (error) { 5972 class_destroy(pmcraid_class); 5973 goto out_unreg_chrdev; 5974 } 5975 5976 error = pci_register_driver(&pmcraid_driver); 5977 5978 if (error == 0) 5979 goto out_init; 5980 5981 pmcraid_err("failed to register pmcraid driver, error = %x\n", 5982 error); 5983 class_destroy(pmcraid_class); 5984 pmcraid_netlink_release(); 5985 5986 out_unreg_chrdev: 5987 unregister_chrdev_region(MKDEV(pmcraid_major, 0), PMCRAID_MAX_ADAPTERS); 5988 5989 out_init: 5990 return error; 5991 } 5992 5993 /** 5994 * pmcraid_exit - module unload entry point 5995 */ 5996 static void __exit pmcraid_exit(void) 5997 { 5998 pmcraid_netlink_release(); 5999 unregister_chrdev_region(MKDEV(pmcraid_major, 0), 6000 PMCRAID_MAX_ADAPTERS); 6001 pci_unregister_driver(&pmcraid_driver); 6002 class_destroy(pmcraid_class); 6003 } 6004 6005 module_init(pmcraid_init); 6006 module_exit(pmcraid_exit); 6007