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