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