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