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