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