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