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 }; 4169 4170 4171 4172 4173 /** 4174 * pmcraid_show_log_level - Display adapter's error logging level 4175 * @dev: class device struct 4176 * @buf: buffer 4177 * 4178 * Return value: 4179 * number of bytes printed to buffer 4180 */ 4181 static ssize_t pmcraid_show_log_level( 4182 struct device *dev, 4183 struct device_attribute *attr, 4184 char *buf) 4185 { 4186 struct Scsi_Host *shost = class_to_shost(dev); 4187 struct pmcraid_instance *pinstance = 4188 (struct pmcraid_instance *)shost->hostdata; 4189 return snprintf(buf, PAGE_SIZE, "%d\n", pinstance->current_log_level); 4190 } 4191 4192 /** 4193 * pmcraid_store_log_level - Change the adapter's error logging level 4194 * @dev: class device struct 4195 * @buf: buffer 4196 * @count: not used 4197 * 4198 * Return value: 4199 * number of bytes printed to buffer 4200 */ 4201 static ssize_t pmcraid_store_log_level( 4202 struct device *dev, 4203 struct device_attribute *attr, 4204 const char *buf, 4205 size_t count 4206 ) 4207 { 4208 struct Scsi_Host *shost; 4209 struct pmcraid_instance *pinstance; 4210 unsigned long val; 4211 4212 if (strict_strtoul(buf, 10, &val)) 4213 return -EINVAL; 4214 /* log-level should be from 0 to 2 */ 4215 if (val > 2) 4216 return -EINVAL; 4217 4218 shost = class_to_shost(dev); 4219 pinstance = (struct pmcraid_instance *)shost->hostdata; 4220 pinstance->current_log_level = val; 4221 4222 return strlen(buf); 4223 } 4224 4225 static struct device_attribute pmcraid_log_level_attr = { 4226 .attr = { 4227 .name = "log_level", 4228 .mode = S_IRUGO | S_IWUSR, 4229 }, 4230 .show = pmcraid_show_log_level, 4231 .store = pmcraid_store_log_level, 4232 }; 4233 4234 /** 4235 * pmcraid_show_drv_version - Display driver version 4236 * @dev: class device struct 4237 * @buf: buffer 4238 * 4239 * Return value: 4240 * number of bytes printed to buffer 4241 */ 4242 static ssize_t pmcraid_show_drv_version( 4243 struct device *dev, 4244 struct device_attribute *attr, 4245 char *buf 4246 ) 4247 { 4248 return snprintf(buf, PAGE_SIZE, "version: %s, build date: %s\n", 4249 PMCRAID_DRIVER_VERSION, PMCRAID_DRIVER_DATE); 4250 } 4251 4252 static struct device_attribute pmcraid_driver_version_attr = { 4253 .attr = { 4254 .name = "drv_version", 4255 .mode = S_IRUGO, 4256 }, 4257 .show = pmcraid_show_drv_version, 4258 }; 4259 4260 /** 4261 * pmcraid_show_io_adapter_id - Display driver assigned adapter id 4262 * @dev: class device struct 4263 * @buf: buffer 4264 * 4265 * Return value: 4266 * number of bytes printed to buffer 4267 */ 4268 static ssize_t pmcraid_show_adapter_id( 4269 struct device *dev, 4270 struct device_attribute *attr, 4271 char *buf 4272 ) 4273 { 4274 struct Scsi_Host *shost = class_to_shost(dev); 4275 struct pmcraid_instance *pinstance = 4276 (struct pmcraid_instance *)shost->hostdata; 4277 u32 adapter_id = (pinstance->pdev->bus->number << 8) | 4278 pinstance->pdev->devfn; 4279 u32 aen_group = pmcraid_event_family.id; 4280 4281 return snprintf(buf, PAGE_SIZE, 4282 "adapter id: %d\nminor: %d\naen group: %d\n", 4283 adapter_id, MINOR(pinstance->cdev.dev), aen_group); 4284 } 4285 4286 static struct device_attribute pmcraid_adapter_id_attr = { 4287 .attr = { 4288 .name = "adapter_id", 4289 .mode = S_IRUGO | S_IWUSR, 4290 }, 4291 .show = pmcraid_show_adapter_id, 4292 }; 4293 4294 static struct device_attribute *pmcraid_host_attrs[] = { 4295 &pmcraid_log_level_attr, 4296 &pmcraid_driver_version_attr, 4297 &pmcraid_adapter_id_attr, 4298 NULL, 4299 }; 4300 4301 4302 /* host template structure for pmcraid driver */ 4303 static struct scsi_host_template pmcraid_host_template = { 4304 .module = THIS_MODULE, 4305 .name = PMCRAID_DRIVER_NAME, 4306 .queuecommand = pmcraid_queuecommand, 4307 .eh_abort_handler = pmcraid_eh_abort_handler, 4308 .eh_bus_reset_handler = pmcraid_eh_bus_reset_handler, 4309 .eh_target_reset_handler = pmcraid_eh_target_reset_handler, 4310 .eh_device_reset_handler = pmcraid_eh_device_reset_handler, 4311 .eh_host_reset_handler = pmcraid_eh_host_reset_handler, 4312 4313 .slave_alloc = pmcraid_slave_alloc, 4314 .slave_configure = pmcraid_slave_configure, 4315 .slave_destroy = pmcraid_slave_destroy, 4316 .change_queue_depth = pmcraid_change_queue_depth, 4317 .change_queue_type = pmcraid_change_queue_type, 4318 .can_queue = PMCRAID_MAX_IO_CMD, 4319 .this_id = -1, 4320 .sg_tablesize = PMCRAID_MAX_IOADLS, 4321 .max_sectors = PMCRAID_IOA_MAX_SECTORS, 4322 .cmd_per_lun = PMCRAID_MAX_CMD_PER_LUN, 4323 .use_clustering = ENABLE_CLUSTERING, 4324 .shost_attrs = pmcraid_host_attrs, 4325 .proc_name = PMCRAID_DRIVER_NAME 4326 }; 4327 4328 /* 4329 * pmcraid_isr_msix - implements MSI-X interrupt handling routine 4330 * @irq: interrupt vector number 4331 * @dev_id: pointer hrrq_vector 4332 * 4333 * Return Value 4334 * IRQ_HANDLED if interrupt is handled or IRQ_NONE if ignored 4335 */ 4336 4337 static irqreturn_t pmcraid_isr_msix(int irq, void *dev_id) 4338 { 4339 struct pmcraid_isr_param *hrrq_vector; 4340 struct pmcraid_instance *pinstance; 4341 unsigned long lock_flags; 4342 u32 intrs_val; 4343 int hrrq_id; 4344 4345 hrrq_vector = (struct pmcraid_isr_param *)dev_id; 4346 hrrq_id = hrrq_vector->hrrq_id; 4347 pinstance = hrrq_vector->drv_inst; 4348 4349 if (!hrrq_id) { 4350 /* Read the interrupt */ 4351 intrs_val = pmcraid_read_interrupts(pinstance); 4352 if (intrs_val && 4353 ((ioread32(pinstance->int_regs.host_ioa_interrupt_reg) 4354 & DOORBELL_INTR_MSIX_CLR) == 0)) { 4355 /* Any error interrupts including unit_check, 4356 * initiate IOA reset.In case of unit check indicate 4357 * to reset_sequence that IOA unit checked and prepare 4358 * for a dump during reset sequence 4359 */ 4360 if (intrs_val & PMCRAID_ERROR_INTERRUPTS) { 4361 if (intrs_val & INTRS_IOA_UNIT_CHECK) 4362 pinstance->ioa_unit_check = 1; 4363 4364 pmcraid_err("ISR: error interrupts: %x \ 4365 initiating reset\n", intrs_val); 4366 spin_lock_irqsave(pinstance->host->host_lock, 4367 lock_flags); 4368 pmcraid_initiate_reset(pinstance); 4369 spin_unlock_irqrestore( 4370 pinstance->host->host_lock, 4371 lock_flags); 4372 } 4373 /* If interrupt was as part of the ioa initialization, 4374 * clear it. Delete the timer and wakeup the 4375 * reset engine to proceed with reset sequence 4376 */ 4377 if (intrs_val & INTRS_TRANSITION_TO_OPERATIONAL) 4378 pmcraid_clr_trans_op(pinstance); 4379 4380 /* Clear the interrupt register by writing 4381 * to host to ioa doorbell. Once done 4382 * FW will clear the interrupt. 4383 */ 4384 iowrite32(DOORBELL_INTR_MSIX_CLR, 4385 pinstance->int_regs.host_ioa_interrupt_reg); 4386 ioread32(pinstance->int_regs.host_ioa_interrupt_reg); 4387 4388 4389 } 4390 } 4391 4392 tasklet_schedule(&(pinstance->isr_tasklet[hrrq_id])); 4393 4394 return IRQ_HANDLED; 4395 } 4396 4397 /** 4398 * pmcraid_isr - implements legacy interrupt handling routine 4399 * 4400 * @irq: interrupt vector number 4401 * @dev_id: pointer hrrq_vector 4402 * 4403 * Return Value 4404 * IRQ_HANDLED if interrupt is handled or IRQ_NONE if ignored 4405 */ 4406 static irqreturn_t pmcraid_isr(int irq, void *dev_id) 4407 { 4408 struct pmcraid_isr_param *hrrq_vector; 4409 struct pmcraid_instance *pinstance; 4410 u32 intrs; 4411 unsigned long lock_flags; 4412 int hrrq_id = 0; 4413 4414 /* In case of legacy interrupt mode where interrupts are shared across 4415 * isrs, it may be possible that the current interrupt is not from IOA 4416 */ 4417 if (!dev_id) { 4418 printk(KERN_INFO "%s(): NULL host pointer\n", __func__); 4419 return IRQ_NONE; 4420 } 4421 hrrq_vector = (struct pmcraid_isr_param *)dev_id; 4422 pinstance = hrrq_vector->drv_inst; 4423 4424 intrs = pmcraid_read_interrupts(pinstance); 4425 4426 if (unlikely((intrs & PMCRAID_PCI_INTERRUPTS) == 0)) 4427 return IRQ_NONE; 4428 4429 /* Any error interrupts including unit_check, initiate IOA reset. 4430 * In case of unit check indicate to reset_sequence that IOA unit 4431 * checked and prepare for a dump during reset sequence 4432 */ 4433 if (intrs & PMCRAID_ERROR_INTERRUPTS) { 4434 4435 if (intrs & INTRS_IOA_UNIT_CHECK) 4436 pinstance->ioa_unit_check = 1; 4437 4438 iowrite32(intrs, 4439 pinstance->int_regs.ioa_host_interrupt_clr_reg); 4440 pmcraid_err("ISR: error interrupts: %x initiating reset\n", 4441 intrs); 4442 intrs = ioread32( 4443 pinstance->int_regs.ioa_host_interrupt_clr_reg); 4444 spin_lock_irqsave(pinstance->host->host_lock, lock_flags); 4445 pmcraid_initiate_reset(pinstance); 4446 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags); 4447 } else { 4448 /* If interrupt was as part of the ioa initialization, 4449 * clear. Delete the timer and wakeup the 4450 * reset engine to proceed with reset sequence 4451 */ 4452 if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) { 4453 pmcraid_clr_trans_op(pinstance); 4454 } else { 4455 iowrite32(intrs, 4456 pinstance->int_regs.ioa_host_interrupt_clr_reg); 4457 ioread32( 4458 pinstance->int_regs.ioa_host_interrupt_clr_reg); 4459 4460 tasklet_schedule( 4461 &(pinstance->isr_tasklet[hrrq_id])); 4462 } 4463 } 4464 4465 return IRQ_HANDLED; 4466 } 4467 4468 4469 /** 4470 * pmcraid_worker_function - worker thread function 4471 * 4472 * @workp: pointer to struct work queue 4473 * 4474 * Return Value 4475 * None 4476 */ 4477 4478 static void pmcraid_worker_function(struct work_struct *workp) 4479 { 4480 struct pmcraid_instance *pinstance; 4481 struct pmcraid_resource_entry *res; 4482 struct pmcraid_resource_entry *temp; 4483 struct scsi_device *sdev; 4484 unsigned long lock_flags; 4485 unsigned long host_lock_flags; 4486 u16 fw_version; 4487 u8 bus, target, lun; 4488 4489 pinstance = container_of(workp, struct pmcraid_instance, worker_q); 4490 /* add resources only after host is added into system */ 4491 if (!atomic_read(&pinstance->expose_resources)) 4492 return; 4493 4494 fw_version = be16_to_cpu(pinstance->inq_data->fw_version); 4495 4496 spin_lock_irqsave(&pinstance->resource_lock, lock_flags); 4497 list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue) { 4498 4499 if (res->change_detected == RES_CHANGE_DEL && res->scsi_dev) { 4500 sdev = res->scsi_dev; 4501 4502 /* host_lock must be held before calling 4503 * scsi_device_get 4504 */ 4505 spin_lock_irqsave(pinstance->host->host_lock, 4506 host_lock_flags); 4507 if (!scsi_device_get(sdev)) { 4508 spin_unlock_irqrestore( 4509 pinstance->host->host_lock, 4510 host_lock_flags); 4511 pmcraid_info("deleting %x from midlayer\n", 4512 res->cfg_entry.resource_address); 4513 list_move_tail(&res->queue, 4514 &pinstance->free_res_q); 4515 spin_unlock_irqrestore( 4516 &pinstance->resource_lock, 4517 lock_flags); 4518 scsi_remove_device(sdev); 4519 scsi_device_put(sdev); 4520 spin_lock_irqsave(&pinstance->resource_lock, 4521 lock_flags); 4522 res->change_detected = 0; 4523 } else { 4524 spin_unlock_irqrestore( 4525 pinstance->host->host_lock, 4526 host_lock_flags); 4527 } 4528 } 4529 } 4530 4531 list_for_each_entry(res, &pinstance->used_res_q, queue) { 4532 4533 if (res->change_detected == RES_CHANGE_ADD) { 4534 4535 if (!pmcraid_expose_resource(fw_version, 4536 &res->cfg_entry)) 4537 continue; 4538 4539 if (RES_IS_VSET(res->cfg_entry)) { 4540 bus = PMCRAID_VSET_BUS_ID; 4541 if (fw_version <= PMCRAID_FW_VERSION_1) 4542 target = res->cfg_entry.unique_flags1; 4543 else 4544 target = res->cfg_entry.array_id & 0xFF; 4545 lun = PMCRAID_VSET_LUN_ID; 4546 } else { 4547 bus = PMCRAID_PHYS_BUS_ID; 4548 target = 4549 RES_TARGET( 4550 res->cfg_entry.resource_address); 4551 lun = RES_LUN(res->cfg_entry.resource_address); 4552 } 4553 4554 res->change_detected = 0; 4555 spin_unlock_irqrestore(&pinstance->resource_lock, 4556 lock_flags); 4557 scsi_add_device(pinstance->host, bus, target, lun); 4558 spin_lock_irqsave(&pinstance->resource_lock, 4559 lock_flags); 4560 } 4561 } 4562 4563 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags); 4564 } 4565 4566 /** 4567 * pmcraid_tasklet_function - Tasklet function 4568 * 4569 * @instance: pointer to msix param structure 4570 * 4571 * Return Value 4572 * None 4573 */ 4574 static void pmcraid_tasklet_function(unsigned long instance) 4575 { 4576 struct pmcraid_isr_param *hrrq_vector; 4577 struct pmcraid_instance *pinstance; 4578 unsigned long hrrq_lock_flags; 4579 unsigned long pending_lock_flags; 4580 unsigned long host_lock_flags; 4581 spinlock_t *lockp; /* hrrq buffer lock */ 4582 int id; 4583 __le32 resp; 4584 4585 hrrq_vector = (struct pmcraid_isr_param *)instance; 4586 pinstance = hrrq_vector->drv_inst; 4587 id = hrrq_vector->hrrq_id; 4588 lockp = &(pinstance->hrrq_lock[id]); 4589 4590 /* loop through each of the commands responded by IOA. Each HRRQ buf is 4591 * protected by its own lock. Traversals must be done within this lock 4592 * as there may be multiple tasklets running on multiple CPUs. Note 4593 * that the lock is held just for picking up the response handle and 4594 * manipulating hrrq_curr/toggle_bit values. 4595 */ 4596 spin_lock_irqsave(lockp, hrrq_lock_flags); 4597 4598 resp = le32_to_cpu(*(pinstance->hrrq_curr[id])); 4599 4600 while ((resp & HRRQ_TOGGLE_BIT) == 4601 pinstance->host_toggle_bit[id]) { 4602 4603 int cmd_index = resp >> 2; 4604 struct pmcraid_cmd *cmd = NULL; 4605 4606 if (pinstance->hrrq_curr[id] < pinstance->hrrq_end[id]) { 4607 pinstance->hrrq_curr[id]++; 4608 } else { 4609 pinstance->hrrq_curr[id] = pinstance->hrrq_start[id]; 4610 pinstance->host_toggle_bit[id] ^= 1u; 4611 } 4612 4613 if (cmd_index >= PMCRAID_MAX_CMD) { 4614 /* In case of invalid response handle, log message */ 4615 pmcraid_err("Invalid response handle %d\n", cmd_index); 4616 resp = le32_to_cpu(*(pinstance->hrrq_curr[id])); 4617 continue; 4618 } 4619 4620 cmd = pinstance->cmd_list[cmd_index]; 4621 spin_unlock_irqrestore(lockp, hrrq_lock_flags); 4622 4623 spin_lock_irqsave(&pinstance->pending_pool_lock, 4624 pending_lock_flags); 4625 list_del(&cmd->free_list); 4626 spin_unlock_irqrestore(&pinstance->pending_pool_lock, 4627 pending_lock_flags); 4628 del_timer(&cmd->timer); 4629 atomic_dec(&pinstance->outstanding_cmds); 4630 4631 if (cmd->cmd_done == pmcraid_ioa_reset) { 4632 spin_lock_irqsave(pinstance->host->host_lock, 4633 host_lock_flags); 4634 cmd->cmd_done(cmd); 4635 spin_unlock_irqrestore(pinstance->host->host_lock, 4636 host_lock_flags); 4637 } else if (cmd->cmd_done != NULL) { 4638 cmd->cmd_done(cmd); 4639 } 4640 /* loop over until we are done with all responses */ 4641 spin_lock_irqsave(lockp, hrrq_lock_flags); 4642 resp = le32_to_cpu(*(pinstance->hrrq_curr[id])); 4643 } 4644 4645 spin_unlock_irqrestore(lockp, hrrq_lock_flags); 4646 } 4647 4648 /** 4649 * pmcraid_unregister_interrupt_handler - de-register interrupts handlers 4650 * @pinstance: pointer to adapter instance structure 4651 * 4652 * This routine un-registers registered interrupt handler and 4653 * also frees irqs/vectors. 4654 * 4655 * Retun Value 4656 * None 4657 */ 4658 static 4659 void pmcraid_unregister_interrupt_handler(struct pmcraid_instance *pinstance) 4660 { 4661 int i; 4662 4663 for (i = 0; i < pinstance->num_hrrq; i++) 4664 free_irq(pinstance->hrrq_vector[i].vector, 4665 &(pinstance->hrrq_vector[i])); 4666 4667 if (pinstance->interrupt_mode) { 4668 pci_disable_msix(pinstance->pdev); 4669 pinstance->interrupt_mode = 0; 4670 } 4671 } 4672 4673 /** 4674 * pmcraid_register_interrupt_handler - registers interrupt handler 4675 * @pinstance: pointer to per-adapter instance structure 4676 * 4677 * Return Value 4678 * 0 on success, non-zero error code otherwise. 4679 */ 4680 static int 4681 pmcraid_register_interrupt_handler(struct pmcraid_instance *pinstance) 4682 { 4683 int rc; 4684 struct pci_dev *pdev = pinstance->pdev; 4685 4686 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) { 4687 int num_hrrq = PMCRAID_NUM_MSIX_VECTORS; 4688 struct msix_entry entries[PMCRAID_NUM_MSIX_VECTORS]; 4689 int i; 4690 for (i = 0; i < PMCRAID_NUM_MSIX_VECTORS; i++) 4691 entries[i].entry = i; 4692 4693 rc = pci_enable_msix(pdev, entries, num_hrrq); 4694 if (rc < 0) 4695 goto pmcraid_isr_legacy; 4696 4697 /* Check how many MSIX vectors are allocated and register 4698 * msi-x handlers for each of them giving appropriate buffer 4699 */ 4700 if (rc > 0) { 4701 num_hrrq = rc; 4702 if (pci_enable_msix(pdev, entries, num_hrrq)) 4703 goto pmcraid_isr_legacy; 4704 } 4705 4706 for (i = 0; i < num_hrrq; i++) { 4707 pinstance->hrrq_vector[i].hrrq_id = i; 4708 pinstance->hrrq_vector[i].drv_inst = pinstance; 4709 pinstance->hrrq_vector[i].vector = entries[i].vector; 4710 rc = request_irq(pinstance->hrrq_vector[i].vector, 4711 pmcraid_isr_msix, 0, 4712 PMCRAID_DRIVER_NAME, 4713 &(pinstance->hrrq_vector[i])); 4714 4715 if (rc) { 4716 int j; 4717 for (j = 0; j < i; j++) 4718 free_irq(entries[j].vector, 4719 &(pinstance->hrrq_vector[j])); 4720 pci_disable_msix(pdev); 4721 goto pmcraid_isr_legacy; 4722 } 4723 } 4724 4725 pinstance->num_hrrq = num_hrrq; 4726 pinstance->interrupt_mode = 1; 4727 iowrite32(DOORBELL_INTR_MODE_MSIX, 4728 pinstance->int_regs.host_ioa_interrupt_reg); 4729 ioread32(pinstance->int_regs.host_ioa_interrupt_reg); 4730 goto pmcraid_isr_out; 4731 } 4732 4733 pmcraid_isr_legacy: 4734 /* If MSI-X registration failed fallback to legacy mode, where 4735 * only one hrrq entry will be used 4736 */ 4737 pinstance->hrrq_vector[0].hrrq_id = 0; 4738 pinstance->hrrq_vector[0].drv_inst = pinstance; 4739 pinstance->hrrq_vector[0].vector = pdev->irq; 4740 pinstance->num_hrrq = 1; 4741 rc = 0; 4742 4743 rc = request_irq(pdev->irq, pmcraid_isr, IRQF_SHARED, 4744 PMCRAID_DRIVER_NAME, &pinstance->hrrq_vector[0]); 4745 pmcraid_isr_out: 4746 return rc; 4747 } 4748 4749 /** 4750 * pmcraid_release_cmd_blocks - release buufers allocated for command blocks 4751 * @pinstance: per adapter instance structure pointer 4752 * @max_index: number of buffer blocks to release 4753 * 4754 * Return Value 4755 * None 4756 */ 4757 static void 4758 pmcraid_release_cmd_blocks(struct pmcraid_instance *pinstance, int max_index) 4759 { 4760 int i; 4761 for (i = 0; i < max_index; i++) { 4762 kmem_cache_free(pinstance->cmd_cachep, pinstance->cmd_list[i]); 4763 pinstance->cmd_list[i] = NULL; 4764 } 4765 kmem_cache_destroy(pinstance->cmd_cachep); 4766 pinstance->cmd_cachep = NULL; 4767 } 4768 4769 /** 4770 * pmcraid_release_control_blocks - releases buffers alloced for control blocks 4771 * @pinstance: pointer to per adapter instance structure 4772 * @max_index: number of buffers (from 0 onwards) to release 4773 * 4774 * This function assumes that the command blocks for which control blocks are 4775 * linked are not released. 4776 * 4777 * Return Value 4778 * None 4779 */ 4780 static void 4781 pmcraid_release_control_blocks( 4782 struct pmcraid_instance *pinstance, 4783 int max_index 4784 ) 4785 { 4786 int i; 4787 4788 if (pinstance->control_pool == NULL) 4789 return; 4790 4791 for (i = 0; i < max_index; i++) { 4792 pci_pool_free(pinstance->control_pool, 4793 pinstance->cmd_list[i]->ioa_cb, 4794 pinstance->cmd_list[i]->ioa_cb_bus_addr); 4795 pinstance->cmd_list[i]->ioa_cb = NULL; 4796 pinstance->cmd_list[i]->ioa_cb_bus_addr = 0; 4797 } 4798 pci_pool_destroy(pinstance->control_pool); 4799 pinstance->control_pool = NULL; 4800 } 4801 4802 /** 4803 * pmcraid_allocate_cmd_blocks - allocate memory for cmd block structures 4804 * @pinstance - pointer to per adapter instance structure 4805 * 4806 * Allocates memory for command blocks using kernel slab allocator. 4807 * 4808 * Return Value 4809 * 0 in case of success; -ENOMEM in case of failure 4810 */ 4811 static int __devinit 4812 pmcraid_allocate_cmd_blocks(struct pmcraid_instance *pinstance) 4813 { 4814 int i; 4815 4816 sprintf(pinstance->cmd_pool_name, "pmcraid_cmd_pool_%d", 4817 pinstance->host->unique_id); 4818 4819 4820 pinstance->cmd_cachep = kmem_cache_create( 4821 pinstance->cmd_pool_name, 4822 sizeof(struct pmcraid_cmd), 0, 4823 SLAB_HWCACHE_ALIGN, NULL); 4824 if (!pinstance->cmd_cachep) 4825 return -ENOMEM; 4826 4827 for (i = 0; i < PMCRAID_MAX_CMD; i++) { 4828 pinstance->cmd_list[i] = 4829 kmem_cache_alloc(pinstance->cmd_cachep, GFP_KERNEL); 4830 if (!pinstance->cmd_list[i]) { 4831 pmcraid_release_cmd_blocks(pinstance, i); 4832 return -ENOMEM; 4833 } 4834 } 4835 return 0; 4836 } 4837 4838 /** 4839 * pmcraid_allocate_control_blocks - allocates memory control blocks 4840 * @pinstance : pointer to per adapter instance structure 4841 * 4842 * This function allocates PCI memory for DMAable buffers like IOARCB, IOADLs 4843 * and IOASAs. This is called after command blocks are already allocated. 4844 * 4845 * Return Value 4846 * 0 in case it can allocate all control blocks, otherwise -ENOMEM 4847 */ 4848 static int __devinit 4849 pmcraid_allocate_control_blocks(struct pmcraid_instance *pinstance) 4850 { 4851 int i; 4852 4853 sprintf(pinstance->ctl_pool_name, "pmcraid_control_pool_%d", 4854 pinstance->host->unique_id); 4855 4856 pinstance->control_pool = 4857 pci_pool_create(pinstance->ctl_pool_name, 4858 pinstance->pdev, 4859 sizeof(struct pmcraid_control_block), 4860 PMCRAID_IOARCB_ALIGNMENT, 0); 4861 4862 if (!pinstance->control_pool) 4863 return -ENOMEM; 4864 4865 for (i = 0; i < PMCRAID_MAX_CMD; i++) { 4866 pinstance->cmd_list[i]->ioa_cb = 4867 pci_pool_alloc( 4868 pinstance->control_pool, 4869 GFP_KERNEL, 4870 &(pinstance->cmd_list[i]->ioa_cb_bus_addr)); 4871 4872 if (!pinstance->cmd_list[i]->ioa_cb) { 4873 pmcraid_release_control_blocks(pinstance, i); 4874 return -ENOMEM; 4875 } 4876 memset(pinstance->cmd_list[i]->ioa_cb, 0, 4877 sizeof(struct pmcraid_control_block)); 4878 } 4879 return 0; 4880 } 4881 4882 /** 4883 * pmcraid_release_host_rrqs - release memory allocated for hrrq buffer(s) 4884 * @pinstance: pointer to per adapter instance structure 4885 * @maxindex: size of hrrq buffer pointer array 4886 * 4887 * Return Value 4888 * None 4889 */ 4890 static void 4891 pmcraid_release_host_rrqs(struct pmcraid_instance *pinstance, int maxindex) 4892 { 4893 int i; 4894 for (i = 0; i < maxindex; i++) { 4895 4896 pci_free_consistent(pinstance->pdev, 4897 HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD, 4898 pinstance->hrrq_start[i], 4899 pinstance->hrrq_start_bus_addr[i]); 4900 4901 /* reset pointers and toggle bit to zeros */ 4902 pinstance->hrrq_start[i] = NULL; 4903 pinstance->hrrq_start_bus_addr[i] = 0; 4904 pinstance->host_toggle_bit[i] = 0; 4905 } 4906 } 4907 4908 /** 4909 * pmcraid_allocate_host_rrqs - Allocate and initialize host RRQ buffers 4910 * @pinstance: pointer to per adapter instance structure 4911 * 4912 * Return value 4913 * 0 hrrq buffers are allocated, -ENOMEM otherwise. 4914 */ 4915 static int __devinit 4916 pmcraid_allocate_host_rrqs(struct pmcraid_instance *pinstance) 4917 { 4918 int i, buffer_size; 4919 4920 buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD; 4921 4922 for (i = 0; i < pinstance->num_hrrq; i++) { 4923 pinstance->hrrq_start[i] = 4924 pci_alloc_consistent( 4925 pinstance->pdev, 4926 buffer_size, 4927 &(pinstance->hrrq_start_bus_addr[i])); 4928 4929 if (pinstance->hrrq_start[i] == 0) { 4930 pmcraid_err("pci_alloc failed for hrrq vector : %d\n", 4931 i); 4932 pmcraid_release_host_rrqs(pinstance, i); 4933 return -ENOMEM; 4934 } 4935 4936 memset(pinstance->hrrq_start[i], 0, buffer_size); 4937 pinstance->hrrq_curr[i] = pinstance->hrrq_start[i]; 4938 pinstance->hrrq_end[i] = 4939 pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1; 4940 pinstance->host_toggle_bit[i] = 1; 4941 spin_lock_init(&pinstance->hrrq_lock[i]); 4942 } 4943 return 0; 4944 } 4945 4946 /** 4947 * pmcraid_release_hcams - release HCAM buffers 4948 * 4949 * @pinstance: pointer to per adapter instance structure 4950 * 4951 * Return value 4952 * none 4953 */ 4954 static void pmcraid_release_hcams(struct pmcraid_instance *pinstance) 4955 { 4956 if (pinstance->ccn.msg != NULL) { 4957 pci_free_consistent(pinstance->pdev, 4958 PMCRAID_AEN_HDR_SIZE + 4959 sizeof(struct pmcraid_hcam_ccn_ext), 4960 pinstance->ccn.msg, 4961 pinstance->ccn.baddr); 4962 4963 pinstance->ccn.msg = NULL; 4964 pinstance->ccn.hcam = NULL; 4965 pinstance->ccn.baddr = 0; 4966 } 4967 4968 if (pinstance->ldn.msg != NULL) { 4969 pci_free_consistent(pinstance->pdev, 4970 PMCRAID_AEN_HDR_SIZE + 4971 sizeof(struct pmcraid_hcam_ldn), 4972 pinstance->ldn.msg, 4973 pinstance->ldn.baddr); 4974 4975 pinstance->ldn.msg = NULL; 4976 pinstance->ldn.hcam = NULL; 4977 pinstance->ldn.baddr = 0; 4978 } 4979 } 4980 4981 /** 4982 * pmcraid_allocate_hcams - allocates HCAM buffers 4983 * @pinstance : pointer to per adapter instance structure 4984 * 4985 * Return Value: 4986 * 0 in case of successful allocation, non-zero otherwise 4987 */ 4988 static int pmcraid_allocate_hcams(struct pmcraid_instance *pinstance) 4989 { 4990 pinstance->ccn.msg = pci_alloc_consistent( 4991 pinstance->pdev, 4992 PMCRAID_AEN_HDR_SIZE + 4993 sizeof(struct pmcraid_hcam_ccn_ext), 4994 &(pinstance->ccn.baddr)); 4995 4996 pinstance->ldn.msg = pci_alloc_consistent( 4997 pinstance->pdev, 4998 PMCRAID_AEN_HDR_SIZE + 4999 sizeof(struct pmcraid_hcam_ldn), 5000 &(pinstance->ldn.baddr)); 5001 5002 if (pinstance->ldn.msg == NULL || pinstance->ccn.msg == NULL) { 5003 pmcraid_release_hcams(pinstance); 5004 } else { 5005 pinstance->ccn.hcam = 5006 (void *)pinstance->ccn.msg + PMCRAID_AEN_HDR_SIZE; 5007 pinstance->ldn.hcam = 5008 (void *)pinstance->ldn.msg + PMCRAID_AEN_HDR_SIZE; 5009 5010 atomic_set(&pinstance->ccn.ignore, 0); 5011 atomic_set(&pinstance->ldn.ignore, 0); 5012 } 5013 5014 return (pinstance->ldn.msg == NULL) ? -ENOMEM : 0; 5015 } 5016 5017 /** 5018 * pmcraid_release_config_buffers - release config.table buffers 5019 * @pinstance: pointer to per adapter instance structure 5020 * 5021 * Return Value 5022 * none 5023 */ 5024 static void pmcraid_release_config_buffers(struct pmcraid_instance *pinstance) 5025 { 5026 if (pinstance->cfg_table != NULL && 5027 pinstance->cfg_table_bus_addr != 0) { 5028 pci_free_consistent(pinstance->pdev, 5029 sizeof(struct pmcraid_config_table), 5030 pinstance->cfg_table, 5031 pinstance->cfg_table_bus_addr); 5032 pinstance->cfg_table = NULL; 5033 pinstance->cfg_table_bus_addr = 0; 5034 } 5035 5036 if (pinstance->res_entries != NULL) { 5037 int i; 5038 5039 for (i = 0; i < PMCRAID_MAX_RESOURCES; i++) 5040 list_del(&pinstance->res_entries[i].queue); 5041 kfree(pinstance->res_entries); 5042 pinstance->res_entries = NULL; 5043 } 5044 5045 pmcraid_release_hcams(pinstance); 5046 } 5047 5048 /** 5049 * pmcraid_allocate_config_buffers - allocates DMAable memory for config table 5050 * @pinstance : pointer to per adapter instance structure 5051 * 5052 * Return Value 5053 * 0 for successful allocation, -ENOMEM for any failure 5054 */ 5055 static int __devinit 5056 pmcraid_allocate_config_buffers(struct pmcraid_instance *pinstance) 5057 { 5058 int i; 5059 5060 pinstance->res_entries = 5061 kzalloc(sizeof(struct pmcraid_resource_entry) * 5062 PMCRAID_MAX_RESOURCES, GFP_KERNEL); 5063 5064 if (NULL == pinstance->res_entries) { 5065 pmcraid_err("failed to allocate memory for resource table\n"); 5066 return -ENOMEM; 5067 } 5068 5069 for (i = 0; i < PMCRAID_MAX_RESOURCES; i++) 5070 list_add_tail(&pinstance->res_entries[i].queue, 5071 &pinstance->free_res_q); 5072 5073 pinstance->cfg_table = 5074 pci_alloc_consistent(pinstance->pdev, 5075 sizeof(struct pmcraid_config_table), 5076 &pinstance->cfg_table_bus_addr); 5077 5078 if (NULL == pinstance->cfg_table) { 5079 pmcraid_err("couldn't alloc DMA memory for config table\n"); 5080 pmcraid_release_config_buffers(pinstance); 5081 return -ENOMEM; 5082 } 5083 5084 if (pmcraid_allocate_hcams(pinstance)) { 5085 pmcraid_err("could not alloc DMA memory for HCAMS\n"); 5086 pmcraid_release_config_buffers(pinstance); 5087 return -ENOMEM; 5088 } 5089 5090 return 0; 5091 } 5092 5093 /** 5094 * pmcraid_init_tasklets - registers tasklets for response handling 5095 * 5096 * @pinstance: pointer adapter instance structure 5097 * 5098 * Return value 5099 * none 5100 */ 5101 static void pmcraid_init_tasklets(struct pmcraid_instance *pinstance) 5102 { 5103 int i; 5104 for (i = 0; i < pinstance->num_hrrq; i++) 5105 tasklet_init(&pinstance->isr_tasklet[i], 5106 pmcraid_tasklet_function, 5107 (unsigned long)&pinstance->hrrq_vector[i]); 5108 } 5109 5110 /** 5111 * pmcraid_kill_tasklets - destroys tasklets registered for response handling 5112 * 5113 * @pinstance: pointer to adapter instance structure 5114 * 5115 * Return value 5116 * none 5117 */ 5118 static void pmcraid_kill_tasklets(struct pmcraid_instance *pinstance) 5119 { 5120 int i; 5121 for (i = 0; i < pinstance->num_hrrq; i++) 5122 tasklet_kill(&pinstance->isr_tasklet[i]); 5123 } 5124 5125 /** 5126 * pmcraid_release_buffers - release per-adapter buffers allocated 5127 * 5128 * @pinstance: pointer to adapter soft state 5129 * 5130 * Return Value 5131 * none 5132 */ 5133 static void pmcraid_release_buffers(struct pmcraid_instance *pinstance) 5134 { 5135 pmcraid_release_config_buffers(pinstance); 5136 pmcraid_release_control_blocks(pinstance, PMCRAID_MAX_CMD); 5137 pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD); 5138 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq); 5139 5140 if (pinstance->inq_data != NULL) { 5141 pci_free_consistent(pinstance->pdev, 5142 sizeof(struct pmcraid_inquiry_data), 5143 pinstance->inq_data, 5144 pinstance->inq_data_baddr); 5145 5146 pinstance->inq_data = NULL; 5147 pinstance->inq_data_baddr = 0; 5148 } 5149 } 5150 5151 /** 5152 * pmcraid_init_buffers - allocates memory and initializes various structures 5153 * @pinstance: pointer to per adapter instance structure 5154 * 5155 * This routine pre-allocates memory based on the type of block as below: 5156 * cmdblocks(PMCRAID_MAX_CMD): kernel memory using kernel's slab_allocator, 5157 * IOARCBs(PMCRAID_MAX_CMD) : DMAable memory, using pci pool allocator 5158 * config-table entries : DMAable memory using pci_alloc_consistent 5159 * HostRRQs : DMAable memory, using pci_alloc_consistent 5160 * 5161 * Return Value 5162 * 0 in case all of the blocks are allocated, -ENOMEM otherwise. 5163 */ 5164 static int __devinit pmcraid_init_buffers(struct pmcraid_instance *pinstance) 5165 { 5166 int i; 5167 5168 if (pmcraid_allocate_host_rrqs(pinstance)) { 5169 pmcraid_err("couldn't allocate memory for %d host rrqs\n", 5170 pinstance->num_hrrq); 5171 return -ENOMEM; 5172 } 5173 5174 if (pmcraid_allocate_config_buffers(pinstance)) { 5175 pmcraid_err("couldn't allocate memory for config buffers\n"); 5176 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq); 5177 return -ENOMEM; 5178 } 5179 5180 if (pmcraid_allocate_cmd_blocks(pinstance)) { 5181 pmcraid_err("couldn't allocate memory for cmd blocks\n"); 5182 pmcraid_release_config_buffers(pinstance); 5183 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq); 5184 return -ENOMEM; 5185 } 5186 5187 if (pmcraid_allocate_control_blocks(pinstance)) { 5188 pmcraid_err("couldn't allocate memory control blocks\n"); 5189 pmcraid_release_config_buffers(pinstance); 5190 pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD); 5191 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq); 5192 return -ENOMEM; 5193 } 5194 5195 /* allocate DMAable memory for page D0 INQUIRY buffer */ 5196 pinstance->inq_data = pci_alloc_consistent( 5197 pinstance->pdev, 5198 sizeof(struct pmcraid_inquiry_data), 5199 &pinstance->inq_data_baddr); 5200 5201 if (pinstance->inq_data == NULL) { 5202 pmcraid_err("couldn't allocate DMA memory for INQUIRY\n"); 5203 pmcraid_release_buffers(pinstance); 5204 return -ENOMEM; 5205 } 5206 5207 /* Initialize all the command blocks and add them to free pool. No 5208 * need to lock (free_pool_lock) as this is done in initialization 5209 * itself 5210 */ 5211 for (i = 0; i < PMCRAID_MAX_CMD; i++) { 5212 struct pmcraid_cmd *cmdp = pinstance->cmd_list[i]; 5213 pmcraid_init_cmdblk(cmdp, i); 5214 cmdp->drv_inst = pinstance; 5215 list_add_tail(&cmdp->free_list, &pinstance->free_cmd_pool); 5216 } 5217 5218 return 0; 5219 } 5220 5221 /** 5222 * pmcraid_reinit_buffers - resets various buffer pointers 5223 * @pinstance: pointer to adapter instance 5224 * Return value 5225 * none 5226 */ 5227 static void pmcraid_reinit_buffers(struct pmcraid_instance *pinstance) 5228 { 5229 int i; 5230 int buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD; 5231 5232 for (i = 0; i < pinstance->num_hrrq; i++) { 5233 memset(pinstance->hrrq_start[i], 0, buffer_size); 5234 pinstance->hrrq_curr[i] = pinstance->hrrq_start[i]; 5235 pinstance->hrrq_end[i] = 5236 pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1; 5237 pinstance->host_toggle_bit[i] = 1; 5238 } 5239 } 5240 5241 /** 5242 * pmcraid_init_instance - initialize per instance data structure 5243 * @pdev: pointer to pci device structure 5244 * @host: pointer to Scsi_Host structure 5245 * @mapped_pci_addr: memory mapped IOA configuration registers 5246 * 5247 * Return Value 5248 * 0 on success, non-zero in case of any failure 5249 */ 5250 static int __devinit pmcraid_init_instance( 5251 struct pci_dev *pdev, 5252 struct Scsi_Host *host, 5253 void __iomem *mapped_pci_addr 5254 ) 5255 { 5256 struct pmcraid_instance *pinstance = 5257 (struct pmcraid_instance *)host->hostdata; 5258 5259 pinstance->host = host; 5260 pinstance->pdev = pdev; 5261 5262 /* Initialize register addresses */ 5263 pinstance->mapped_dma_addr = mapped_pci_addr; 5264 5265 /* Initialize chip-specific details */ 5266 { 5267 struct pmcraid_chip_details *chip_cfg = pinstance->chip_cfg; 5268 struct pmcraid_interrupts *pint_regs = &pinstance->int_regs; 5269 5270 pinstance->ioarrin = mapped_pci_addr + chip_cfg->ioarrin; 5271 5272 pint_regs->ioa_host_interrupt_reg = 5273 mapped_pci_addr + chip_cfg->ioa_host_intr; 5274 pint_regs->ioa_host_interrupt_clr_reg = 5275 mapped_pci_addr + chip_cfg->ioa_host_intr_clr; 5276 pint_regs->ioa_host_msix_interrupt_reg = 5277 mapped_pci_addr + chip_cfg->ioa_host_msix_intr; 5278 pint_regs->host_ioa_interrupt_reg = 5279 mapped_pci_addr + chip_cfg->host_ioa_intr; 5280 pint_regs->host_ioa_interrupt_clr_reg = 5281 mapped_pci_addr + chip_cfg->host_ioa_intr_clr; 5282 5283 /* Current version of firmware exposes interrupt mask set 5284 * and mask clr registers through memory mapped bar0. 5285 */ 5286 pinstance->mailbox = mapped_pci_addr + chip_cfg->mailbox; 5287 pinstance->ioa_status = mapped_pci_addr + chip_cfg->ioastatus; 5288 pint_regs->ioa_host_interrupt_mask_reg = 5289 mapped_pci_addr + chip_cfg->ioa_host_mask; 5290 pint_regs->ioa_host_interrupt_mask_clr_reg = 5291 mapped_pci_addr + chip_cfg->ioa_host_mask_clr; 5292 pint_regs->global_interrupt_mask_reg = 5293 mapped_pci_addr + chip_cfg->global_intr_mask; 5294 }; 5295 5296 pinstance->ioa_reset_attempts = 0; 5297 init_waitqueue_head(&pinstance->reset_wait_q); 5298 5299 atomic_set(&pinstance->outstanding_cmds, 0); 5300 atomic_set(&pinstance->last_message_id, 0); 5301 atomic_set(&pinstance->expose_resources, 0); 5302 5303 INIT_LIST_HEAD(&pinstance->free_res_q); 5304 INIT_LIST_HEAD(&pinstance->used_res_q); 5305 INIT_LIST_HEAD(&pinstance->free_cmd_pool); 5306 INIT_LIST_HEAD(&pinstance->pending_cmd_pool); 5307 5308 spin_lock_init(&pinstance->free_pool_lock); 5309 spin_lock_init(&pinstance->pending_pool_lock); 5310 spin_lock_init(&pinstance->resource_lock); 5311 mutex_init(&pinstance->aen_queue_lock); 5312 5313 /* Work-queue (Shared) for deferred processing error handling */ 5314 INIT_WORK(&pinstance->worker_q, pmcraid_worker_function); 5315 5316 /* Initialize the default log_level */ 5317 pinstance->current_log_level = pmcraid_log_level; 5318 5319 /* Setup variables required for reset engine */ 5320 pinstance->ioa_state = IOA_STATE_UNKNOWN; 5321 pinstance->reset_cmd = NULL; 5322 return 0; 5323 } 5324 5325 /** 5326 * pmcraid_shutdown - shutdown adapter controller. 5327 * @pdev: pci device struct 5328 * 5329 * Issues an adapter shutdown to the card waits for its completion 5330 * 5331 * Return value 5332 * none 5333 */ 5334 static void pmcraid_shutdown(struct pci_dev *pdev) 5335 { 5336 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev); 5337 pmcraid_reset_bringdown(pinstance); 5338 } 5339 5340 5341 /** 5342 * pmcraid_get_minor - returns unused minor number from minor number bitmap 5343 */ 5344 static unsigned short pmcraid_get_minor(void) 5345 { 5346 int minor; 5347 5348 minor = find_first_zero_bit(pmcraid_minor, sizeof(pmcraid_minor)); 5349 __set_bit(minor, pmcraid_minor); 5350 return minor; 5351 } 5352 5353 /** 5354 * pmcraid_release_minor - releases given minor back to minor number bitmap 5355 */ 5356 static void pmcraid_release_minor(unsigned short minor) 5357 { 5358 __clear_bit(minor, pmcraid_minor); 5359 } 5360 5361 /** 5362 * pmcraid_setup_chrdev - allocates a minor number and registers a char device 5363 * 5364 * @pinstance: pointer to adapter instance for which to register device 5365 * 5366 * Return value 5367 * 0 in case of success, otherwise non-zero 5368 */ 5369 static int pmcraid_setup_chrdev(struct pmcraid_instance *pinstance) 5370 { 5371 int minor; 5372 int error; 5373 5374 minor = pmcraid_get_minor(); 5375 cdev_init(&pinstance->cdev, &pmcraid_fops); 5376 pinstance->cdev.owner = THIS_MODULE; 5377 5378 error = cdev_add(&pinstance->cdev, MKDEV(pmcraid_major, minor), 1); 5379 5380 if (error) 5381 pmcraid_release_minor(minor); 5382 else 5383 device_create(pmcraid_class, NULL, MKDEV(pmcraid_major, minor), 5384 NULL, "%s%u", PMCRAID_DEVFILE, minor); 5385 return error; 5386 } 5387 5388 /** 5389 * pmcraid_release_chrdev - unregisters per-adapter management interface 5390 * 5391 * @pinstance: pointer to adapter instance structure 5392 * 5393 * Return value 5394 * none 5395 */ 5396 static void pmcraid_release_chrdev(struct pmcraid_instance *pinstance) 5397 { 5398 pmcraid_release_minor(MINOR(pinstance->cdev.dev)); 5399 device_destroy(pmcraid_class, 5400 MKDEV(pmcraid_major, MINOR(pinstance->cdev.dev))); 5401 cdev_del(&pinstance->cdev); 5402 } 5403 5404 /** 5405 * pmcraid_remove - IOA hot plug remove entry point 5406 * @pdev: pci device struct 5407 * 5408 * Return value 5409 * none 5410 */ 5411 static void __devexit pmcraid_remove(struct pci_dev *pdev) 5412 { 5413 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev); 5414 5415 /* remove the management interface (/dev file) for this device */ 5416 pmcraid_release_chrdev(pinstance); 5417 5418 /* remove host template from scsi midlayer */ 5419 scsi_remove_host(pinstance->host); 5420 5421 /* block requests from mid-layer */ 5422 scsi_block_requests(pinstance->host); 5423 5424 /* initiate shutdown adapter */ 5425 pmcraid_shutdown(pdev); 5426 5427 pmcraid_disable_interrupts(pinstance, ~0); 5428 flush_scheduled_work(); 5429 5430 pmcraid_kill_tasklets(pinstance); 5431 pmcraid_unregister_interrupt_handler(pinstance); 5432 pmcraid_release_buffers(pinstance); 5433 iounmap(pinstance->mapped_dma_addr); 5434 pci_release_regions(pdev); 5435 scsi_host_put(pinstance->host); 5436 pci_disable_device(pdev); 5437 5438 return; 5439 } 5440 5441 #ifdef CONFIG_PM 5442 /** 5443 * pmcraid_suspend - driver suspend entry point for power management 5444 * @pdev: PCI device structure 5445 * @state: PCI power state to suspend routine 5446 * 5447 * Return Value - 0 always 5448 */ 5449 static int pmcraid_suspend(struct pci_dev *pdev, pm_message_t state) 5450 { 5451 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev); 5452 5453 pmcraid_shutdown(pdev); 5454 pmcraid_disable_interrupts(pinstance, ~0); 5455 pmcraid_kill_tasklets(pinstance); 5456 pci_set_drvdata(pinstance->pdev, pinstance); 5457 pmcraid_unregister_interrupt_handler(pinstance); 5458 pci_save_state(pdev); 5459 pci_disable_device(pdev); 5460 pci_set_power_state(pdev, pci_choose_state(pdev, state)); 5461 5462 return 0; 5463 } 5464 5465 /** 5466 * pmcraid_resume - driver resume entry point PCI power management 5467 * @pdev: PCI device structure 5468 * 5469 * Return Value - 0 in case of success. Error code in case of any failure 5470 */ 5471 static int pmcraid_resume(struct pci_dev *pdev) 5472 { 5473 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev); 5474 struct Scsi_Host *host = pinstance->host; 5475 int rc; 5476 5477 pci_set_power_state(pdev, PCI_D0); 5478 pci_enable_wake(pdev, PCI_D0, 0); 5479 pci_restore_state(pdev); 5480 5481 rc = pci_enable_device(pdev); 5482 5483 if (rc) { 5484 dev_err(&pdev->dev, "resume: Enable device failed\n"); 5485 return rc; 5486 } 5487 5488 pci_set_master(pdev); 5489 5490 if ((sizeof(dma_addr_t) == 4) || 5491 pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) 5492 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 5493 5494 if (rc == 0) 5495 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); 5496 5497 if (rc != 0) { 5498 dev_err(&pdev->dev, "resume: Failed to set PCI DMA mask\n"); 5499 goto disable_device; 5500 } 5501 5502 pmcraid_disable_interrupts(pinstance, ~0); 5503 atomic_set(&pinstance->outstanding_cmds, 0); 5504 rc = pmcraid_register_interrupt_handler(pinstance); 5505 5506 if (rc) { 5507 dev_err(&pdev->dev, 5508 "resume: couldn't register interrupt handlers\n"); 5509 rc = -ENODEV; 5510 goto release_host; 5511 } 5512 5513 pmcraid_init_tasklets(pinstance); 5514 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS); 5515 5516 /* Start with hard reset sequence which brings up IOA to operational 5517 * state as well as completes the reset sequence. 5518 */ 5519 pinstance->ioa_hard_reset = 1; 5520 5521 /* Start IOA firmware initialization and bring card to Operational 5522 * state. 5523 */ 5524 if (pmcraid_reset_bringup(pinstance)) { 5525 dev_err(&pdev->dev, "couldn't initialize IOA\n"); 5526 rc = -ENODEV; 5527 goto release_tasklets; 5528 } 5529 5530 return 0; 5531 5532 release_tasklets: 5533 pmcraid_disable_interrupts(pinstance, ~0); 5534 pmcraid_kill_tasklets(pinstance); 5535 pmcraid_unregister_interrupt_handler(pinstance); 5536 5537 release_host: 5538 scsi_host_put(host); 5539 5540 disable_device: 5541 pci_disable_device(pdev); 5542 5543 return rc; 5544 } 5545 5546 #else 5547 5548 #define pmcraid_suspend NULL 5549 #define pmcraid_resume NULL 5550 5551 #endif /* CONFIG_PM */ 5552 5553 /** 5554 * pmcraid_complete_ioa_reset - Called by either timer or tasklet during 5555 * completion of the ioa reset 5556 * @cmd: pointer to reset command block 5557 */ 5558 static void pmcraid_complete_ioa_reset(struct pmcraid_cmd *cmd) 5559 { 5560 struct pmcraid_instance *pinstance = cmd->drv_inst; 5561 unsigned long flags; 5562 5563 spin_lock_irqsave(pinstance->host->host_lock, flags); 5564 pmcraid_ioa_reset(cmd); 5565 spin_unlock_irqrestore(pinstance->host->host_lock, flags); 5566 scsi_unblock_requests(pinstance->host); 5567 schedule_work(&pinstance->worker_q); 5568 } 5569 5570 /** 5571 * pmcraid_set_supported_devs - sends SET SUPPORTED DEVICES to IOAFP 5572 * 5573 * @cmd: pointer to pmcraid_cmd structure 5574 * 5575 * Return Value 5576 * 0 for success or non-zero for failure cases 5577 */ 5578 static void pmcraid_set_supported_devs(struct pmcraid_cmd *cmd) 5579 { 5580 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 5581 void (*cmd_done) (struct pmcraid_cmd *) = pmcraid_complete_ioa_reset; 5582 5583 pmcraid_reinit_cmdblk(cmd); 5584 5585 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE); 5586 ioarcb->request_type = REQ_TYPE_IOACMD; 5587 ioarcb->cdb[0] = PMCRAID_SET_SUPPORTED_DEVICES; 5588 ioarcb->cdb[1] = ALL_DEVICES_SUPPORTED; 5589 5590 /* If this was called as part of resource table reinitialization due to 5591 * lost CCN, it is enough to return the command block back to free pool 5592 * as part of set_supported_devs completion function. 5593 */ 5594 if (cmd->drv_inst->reinit_cfg_table) { 5595 cmd->drv_inst->reinit_cfg_table = 0; 5596 cmd->release = 1; 5597 cmd_done = pmcraid_reinit_cfgtable_done; 5598 } 5599 5600 /* we will be done with the reset sequence after set supported devices, 5601 * setup the done function to return the command block back to free 5602 * pool 5603 */ 5604 pmcraid_send_cmd(cmd, 5605 cmd_done, 5606 PMCRAID_SET_SUP_DEV_TIMEOUT, 5607 pmcraid_timeout_handler); 5608 return; 5609 } 5610 5611 /** 5612 * pmcraid_init_res_table - Initialize the resource table 5613 * @cmd: pointer to pmcraid command struct 5614 * 5615 * This function looks through the existing resource table, comparing 5616 * it with the config table. This function will take care of old/new 5617 * devices and schedule adding/removing them from the mid-layer 5618 * as appropriate. 5619 * 5620 * Return value 5621 * None 5622 */ 5623 static void pmcraid_init_res_table(struct pmcraid_cmd *cmd) 5624 { 5625 struct pmcraid_instance *pinstance = cmd->drv_inst; 5626 struct pmcraid_resource_entry *res, *temp; 5627 struct pmcraid_config_table_entry *cfgte; 5628 unsigned long lock_flags; 5629 int found, rc, i; 5630 u16 fw_version; 5631 LIST_HEAD(old_res); 5632 5633 if (pinstance->cfg_table->flags & MICROCODE_UPDATE_REQUIRED) 5634 pmcraid_err("IOA requires microcode download\n"); 5635 5636 fw_version = be16_to_cpu(pinstance->inq_data->fw_version); 5637 5638 /* resource list is protected by pinstance->resource_lock. 5639 * init_res_table can be called from probe (user-thread) or runtime 5640 * reset (timer/tasklet) 5641 */ 5642 spin_lock_irqsave(&pinstance->resource_lock, lock_flags); 5643 5644 list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue) 5645 list_move_tail(&res->queue, &old_res); 5646 5647 for (i = 0; i < pinstance->cfg_table->num_entries; i++) { 5648 if (be16_to_cpu(pinstance->inq_data->fw_version) <= 5649 PMCRAID_FW_VERSION_1) 5650 cfgte = &pinstance->cfg_table->entries[i]; 5651 else 5652 cfgte = (struct pmcraid_config_table_entry *) 5653 &pinstance->cfg_table->entries_ext[i]; 5654 5655 if (!pmcraid_expose_resource(fw_version, cfgte)) 5656 continue; 5657 5658 found = 0; 5659 5660 /* If this entry was already detected and initialized */ 5661 list_for_each_entry_safe(res, temp, &old_res, queue) { 5662 5663 rc = memcmp(&res->cfg_entry.resource_address, 5664 &cfgte->resource_address, 5665 sizeof(cfgte->resource_address)); 5666 if (!rc) { 5667 list_move_tail(&res->queue, 5668 &pinstance->used_res_q); 5669 found = 1; 5670 break; 5671 } 5672 } 5673 5674 /* If this is new entry, initialize it and add it the queue */ 5675 if (!found) { 5676 5677 if (list_empty(&pinstance->free_res_q)) { 5678 pmcraid_err("Too many devices attached\n"); 5679 break; 5680 } 5681 5682 found = 1; 5683 res = list_entry(pinstance->free_res_q.next, 5684 struct pmcraid_resource_entry, queue); 5685 5686 res->scsi_dev = NULL; 5687 res->change_detected = RES_CHANGE_ADD; 5688 res->reset_progress = 0; 5689 list_move_tail(&res->queue, &pinstance->used_res_q); 5690 } 5691 5692 /* copy new configuration table entry details into driver 5693 * maintained resource entry 5694 */ 5695 if (found) { 5696 memcpy(&res->cfg_entry, cfgte, 5697 pinstance->config_table_entry_size); 5698 pmcraid_info("New res type:%x, vset:%x, addr:%x:\n", 5699 res->cfg_entry.resource_type, 5700 (fw_version <= PMCRAID_FW_VERSION_1 ? 5701 res->cfg_entry.unique_flags1 : 5702 res->cfg_entry.array_id & 0xFF), 5703 le32_to_cpu(res->cfg_entry.resource_address)); 5704 } 5705 } 5706 5707 /* Detect any deleted entries, mark them for deletion from mid-layer */ 5708 list_for_each_entry_safe(res, temp, &old_res, queue) { 5709 5710 if (res->scsi_dev) { 5711 res->change_detected = RES_CHANGE_DEL; 5712 res->cfg_entry.resource_handle = 5713 PMCRAID_INVALID_RES_HANDLE; 5714 list_move_tail(&res->queue, &pinstance->used_res_q); 5715 } else { 5716 list_move_tail(&res->queue, &pinstance->free_res_q); 5717 } 5718 } 5719 5720 /* release the resource list lock */ 5721 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags); 5722 pmcraid_set_supported_devs(cmd); 5723 } 5724 5725 /** 5726 * pmcraid_querycfg - Send a Query IOA Config to the adapter. 5727 * @cmd: pointer pmcraid_cmd struct 5728 * 5729 * This function sends a Query IOA Configuration command to the adapter to 5730 * retrieve the IOA configuration table. 5731 * 5732 * Return value: 5733 * none 5734 */ 5735 static void pmcraid_querycfg(struct pmcraid_cmd *cmd) 5736 { 5737 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb; 5738 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl; 5739 struct pmcraid_instance *pinstance = cmd->drv_inst; 5740 int cfg_table_size = cpu_to_be32(sizeof(struct pmcraid_config_table)); 5741 5742 if (be16_to_cpu(pinstance->inq_data->fw_version) <= 5743 PMCRAID_FW_VERSION_1) 5744 pinstance->config_table_entry_size = 5745 sizeof(struct pmcraid_config_table_entry); 5746 else 5747 pinstance->config_table_entry_size = 5748 sizeof(struct pmcraid_config_table_entry_ext); 5749 5750 ioarcb->request_type = REQ_TYPE_IOACMD; 5751 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE); 5752 5753 ioarcb->cdb[0] = PMCRAID_QUERY_IOA_CONFIG; 5754 5755 /* firmware requires 4-byte length field, specified in B.E format */ 5756 memcpy(&(ioarcb->cdb[10]), &cfg_table_size, sizeof(cfg_table_size)); 5757 5758 /* Since entire config table can be described by single IOADL, it can 5759 * be part of IOARCB itself 5760 */ 5761 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) + 5762 offsetof(struct pmcraid_ioarcb, 5763 add_data.u.ioadl[0])); 5764 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc)); 5765 ioarcb->ioarcb_bus_addr &= ~(0x1FULL); 5766 5767 ioarcb->request_flags0 |= NO_LINK_DESCS; 5768 ioarcb->data_transfer_length = 5769 cpu_to_le32(sizeof(struct pmcraid_config_table)); 5770 5771 ioadl = &(ioarcb->add_data.u.ioadl[0]); 5772 ioadl->flags = IOADL_FLAGS_LAST_DESC; 5773 ioadl->address = cpu_to_le64(pinstance->cfg_table_bus_addr); 5774 ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_config_table)); 5775 5776 pmcraid_send_cmd(cmd, pmcraid_init_res_table, 5777 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler); 5778 } 5779 5780 5781 /** 5782 * pmcraid_probe - PCI probe entry pointer for PMC MaxRAID controller driver 5783 * @pdev: pointer to pci device structure 5784 * @dev_id: pointer to device ids structure 5785 * 5786 * Return Value 5787 * returns 0 if the device is claimed and successfully configured. 5788 * returns non-zero error code in case of any failure 5789 */ 5790 static int __devinit pmcraid_probe( 5791 struct pci_dev *pdev, 5792 const struct pci_device_id *dev_id 5793 ) 5794 { 5795 struct pmcraid_instance *pinstance; 5796 struct Scsi_Host *host; 5797 void __iomem *mapped_pci_addr; 5798 int rc = PCIBIOS_SUCCESSFUL; 5799 5800 if (atomic_read(&pmcraid_adapter_count) >= PMCRAID_MAX_ADAPTERS) { 5801 pmcraid_err 5802 ("maximum number(%d) of supported adapters reached\n", 5803 atomic_read(&pmcraid_adapter_count)); 5804 return -ENOMEM; 5805 } 5806 5807 atomic_inc(&pmcraid_adapter_count); 5808 rc = pci_enable_device(pdev); 5809 5810 if (rc) { 5811 dev_err(&pdev->dev, "Cannot enable adapter\n"); 5812 atomic_dec(&pmcraid_adapter_count); 5813 return rc; 5814 } 5815 5816 dev_info(&pdev->dev, 5817 "Found new IOA(%x:%x), Total IOA count: %d\n", 5818 pdev->vendor, pdev->device, 5819 atomic_read(&pmcraid_adapter_count)); 5820 5821 rc = pci_request_regions(pdev, PMCRAID_DRIVER_NAME); 5822 5823 if (rc < 0) { 5824 dev_err(&pdev->dev, 5825 "Couldn't register memory range of registers\n"); 5826 goto out_disable_device; 5827 } 5828 5829 mapped_pci_addr = pci_iomap(pdev, 0, 0); 5830 5831 if (!mapped_pci_addr) { 5832 dev_err(&pdev->dev, "Couldn't map PCI registers memory\n"); 5833 rc = -ENOMEM; 5834 goto out_release_regions; 5835 } 5836 5837 pci_set_master(pdev); 5838 5839 /* Firmware requires the system bus address of IOARCB to be within 5840 * 32-bit addressable range though it has 64-bit IOARRIN register. 5841 * However, firmware supports 64-bit streaming DMA buffers, whereas 5842 * coherent buffers are to be 32-bit. Since pci_alloc_consistent always 5843 * returns memory within 4GB (if not, change this logic), coherent 5844 * buffers are within firmware acceptible address ranges. 5845 */ 5846 if ((sizeof(dma_addr_t) == 4) || 5847 pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) 5848 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 5849 5850 /* firmware expects 32-bit DMA addresses for IOARRIN register; set 32 5851 * bit mask for pci_alloc_consistent to return addresses within 4GB 5852 */ 5853 if (rc == 0) 5854 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); 5855 5856 if (rc != 0) { 5857 dev_err(&pdev->dev, "Failed to set PCI DMA mask\n"); 5858 goto cleanup_nomem; 5859 } 5860 5861 host = scsi_host_alloc(&pmcraid_host_template, 5862 sizeof(struct pmcraid_instance)); 5863 5864 if (!host) { 5865 dev_err(&pdev->dev, "scsi_host_alloc failed!\n"); 5866 rc = -ENOMEM; 5867 goto cleanup_nomem; 5868 } 5869 5870 host->max_id = PMCRAID_MAX_NUM_TARGETS_PER_BUS; 5871 host->max_lun = PMCRAID_MAX_NUM_LUNS_PER_TARGET; 5872 host->unique_id = host->host_no; 5873 host->max_channel = PMCRAID_MAX_BUS_TO_SCAN; 5874 host->max_cmd_len = PMCRAID_MAX_CDB_LEN; 5875 5876 /* zero out entire instance structure */ 5877 pinstance = (struct pmcraid_instance *)host->hostdata; 5878 memset(pinstance, 0, sizeof(*pinstance)); 5879 5880 pinstance->chip_cfg = 5881 (struct pmcraid_chip_details *)(dev_id->driver_data); 5882 5883 rc = pmcraid_init_instance(pdev, host, mapped_pci_addr); 5884 5885 if (rc < 0) { 5886 dev_err(&pdev->dev, "failed to initialize adapter instance\n"); 5887 goto out_scsi_host_put; 5888 } 5889 5890 pci_set_drvdata(pdev, pinstance); 5891 5892 /* Save PCI config-space for use following the reset */ 5893 rc = pci_save_state(pinstance->pdev); 5894 5895 if (rc != 0) { 5896 dev_err(&pdev->dev, "Failed to save PCI config space\n"); 5897 goto out_scsi_host_put; 5898 } 5899 5900 pmcraid_disable_interrupts(pinstance, ~0); 5901 5902 rc = pmcraid_register_interrupt_handler(pinstance); 5903 5904 if (rc) { 5905 dev_err(&pdev->dev, "couldn't register interrupt handler\n"); 5906 goto out_scsi_host_put; 5907 } 5908 5909 pmcraid_init_tasklets(pinstance); 5910 5911 /* allocate verious buffers used by LLD.*/ 5912 rc = pmcraid_init_buffers(pinstance); 5913 5914 if (rc) { 5915 pmcraid_err("couldn't allocate memory blocks\n"); 5916 goto out_unregister_isr; 5917 } 5918 5919 /* check the reset type required */ 5920 pmcraid_reset_type(pinstance); 5921 5922 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS); 5923 5924 /* Start IOA firmware initialization and bring card to Operational 5925 * state. 5926 */ 5927 pmcraid_info("starting IOA initialization sequence\n"); 5928 if (pmcraid_reset_bringup(pinstance)) { 5929 dev_err(&pdev->dev, "couldn't initialize IOA\n"); 5930 rc = 1; 5931 goto out_release_bufs; 5932 } 5933 5934 /* Add adapter instance into mid-layer list */ 5935 rc = scsi_add_host(pinstance->host, &pdev->dev); 5936 if (rc != 0) { 5937 pmcraid_err("couldn't add host into mid-layer: %d\n", rc); 5938 goto out_release_bufs; 5939 } 5940 5941 scsi_scan_host(pinstance->host); 5942 5943 rc = pmcraid_setup_chrdev(pinstance); 5944 5945 if (rc != 0) { 5946 pmcraid_err("couldn't create mgmt interface, error: %x\n", 5947 rc); 5948 goto out_remove_host; 5949 } 5950 5951 /* Schedule worker thread to handle CCN and take care of adding and 5952 * removing devices to OS 5953 */ 5954 atomic_set(&pinstance->expose_resources, 1); 5955 schedule_work(&pinstance->worker_q); 5956 return rc; 5957 5958 out_remove_host: 5959 scsi_remove_host(host); 5960 5961 out_release_bufs: 5962 pmcraid_release_buffers(pinstance); 5963 5964 out_unregister_isr: 5965 pmcraid_kill_tasklets(pinstance); 5966 pmcraid_unregister_interrupt_handler(pinstance); 5967 5968 out_scsi_host_put: 5969 scsi_host_put(host); 5970 5971 cleanup_nomem: 5972 iounmap(mapped_pci_addr); 5973 5974 out_release_regions: 5975 pci_release_regions(pdev); 5976 5977 out_disable_device: 5978 atomic_dec(&pmcraid_adapter_count); 5979 pci_set_drvdata(pdev, NULL); 5980 pci_disable_device(pdev); 5981 return -ENODEV; 5982 } 5983 5984 /* 5985 * PCI driver structure of pcmraid driver 5986 */ 5987 static struct pci_driver pmcraid_driver = { 5988 .name = PMCRAID_DRIVER_NAME, 5989 .id_table = pmcraid_pci_table, 5990 .probe = pmcraid_probe, 5991 .remove = pmcraid_remove, 5992 .suspend = pmcraid_suspend, 5993 .resume = pmcraid_resume, 5994 .shutdown = pmcraid_shutdown 5995 }; 5996 5997 /** 5998 * pmcraid_init - module load entry point 5999 */ 6000 static int __init pmcraid_init(void) 6001 { 6002 dev_t dev; 6003 int error; 6004 6005 pmcraid_info("%s Device Driver version: %s %s\n", 6006 PMCRAID_DRIVER_NAME, 6007 PMCRAID_DRIVER_VERSION, PMCRAID_DRIVER_DATE); 6008 6009 error = alloc_chrdev_region(&dev, 0, 6010 PMCRAID_MAX_ADAPTERS, 6011 PMCRAID_DEVFILE); 6012 6013 if (error) { 6014 pmcraid_err("failed to get a major number for adapters\n"); 6015 goto out_init; 6016 } 6017 6018 pmcraid_major = MAJOR(dev); 6019 pmcraid_class = class_create(THIS_MODULE, PMCRAID_DEVFILE); 6020 6021 if (IS_ERR(pmcraid_class)) { 6022 error = PTR_ERR(pmcraid_class); 6023 pmcraid_err("failed to register with with sysfs, error = %x\n", 6024 error); 6025 goto out_unreg_chrdev; 6026 } 6027 6028 error = pmcraid_netlink_init(); 6029 6030 if (error) 6031 goto out_unreg_chrdev; 6032 6033 error = pci_register_driver(&pmcraid_driver); 6034 6035 if (error == 0) 6036 goto out_init; 6037 6038 pmcraid_err("failed to register pmcraid driver, error = %x\n", 6039 error); 6040 class_destroy(pmcraid_class); 6041 pmcraid_netlink_release(); 6042 6043 out_unreg_chrdev: 6044 unregister_chrdev_region(MKDEV(pmcraid_major, 0), PMCRAID_MAX_ADAPTERS); 6045 6046 out_init: 6047 return error; 6048 } 6049 6050 /** 6051 * pmcraid_exit - module unload entry point 6052 */ 6053 static void __exit pmcraid_exit(void) 6054 { 6055 pmcraid_netlink_release(); 6056 class_destroy(pmcraid_class); 6057 unregister_chrdev_region(MKDEV(pmcraid_major, 0), 6058 PMCRAID_MAX_ADAPTERS); 6059 pci_unregister_driver(&pmcraid_driver); 6060 } 6061 6062 module_init(pmcraid_init); 6063 module_exit(pmcraid_exit); 6064