1 /* 2 * linux/drivers/message/fusion/mptfc.c 3 * For use with LSI PCI chip/adapter(s) 4 * running LSI Fusion MPT (Message Passing Technology) firmware. 5 * 6 * Copyright (c) 1999-2008 LSI Corporation 7 * (mailto:DL-MPTFusionLinux@lsi.com) 8 * 9 */ 10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 11 /* 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; version 2 of the License. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 NO WARRANTY 22 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 23 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 24 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 25 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 26 solely responsible for determining the appropriateness of using and 27 distributing the Program and assumes all risks associated with its 28 exercise of rights under this Agreement, including but not limited to 29 the risks and costs of program errors, damage to or loss of data, 30 programs or equipment, and unavailability or interruption of operations. 31 32 DISCLAIMER OF LIABILITY 33 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 34 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 35 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 36 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 37 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 38 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 39 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 40 41 You should have received a copy of the GNU General Public License 42 along with this program; if not, write to the Free Software 43 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 44 */ 45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 46 #include <linux/module.h> 47 #include <linux/kernel.h> 48 #include <linux/init.h> 49 #include <linux/errno.h> 50 #include <linux/kdev_t.h> 51 #include <linux/blkdev.h> 52 #include <linux/delay.h> /* for mdelay */ 53 #include <linux/interrupt.h> /* needed for in_interrupt() proto */ 54 #include <linux/reboot.h> /* notifier code */ 55 #include <linux/workqueue.h> 56 #include <linux/sort.h> 57 #include <linux/slab.h> 58 59 #include <scsi/scsi.h> 60 #include <scsi/scsi_cmnd.h> 61 #include <scsi/scsi_device.h> 62 #include <scsi/scsi_host.h> 63 #include <scsi/scsi_tcq.h> 64 #include <scsi/scsi_transport_fc.h> 65 66 #include "mptbase.h" 67 #include "mptscsih.h" 68 69 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 70 #define my_NAME "Fusion MPT FC Host driver" 71 #define my_VERSION MPT_LINUX_VERSION_COMMON 72 #define MYNAM "mptfc" 73 74 MODULE_AUTHOR(MODULEAUTHOR); 75 MODULE_DESCRIPTION(my_NAME); 76 MODULE_LICENSE("GPL"); 77 MODULE_VERSION(my_VERSION); 78 79 /* Command line args */ 80 #define MPTFC_DEV_LOSS_TMO (60) 81 static int mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO; /* reasonable default */ 82 module_param(mptfc_dev_loss_tmo, int, 0); 83 MODULE_PARM_DESC(mptfc_dev_loss_tmo, " Initial time the driver programs the " 84 " transport to wait for an rport to " 85 " return following a device loss event." 86 " Default=60."); 87 88 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */ 89 #define MPTFC_MAX_LUN (16895) 90 static int max_lun = MPTFC_MAX_LUN; 91 module_param(max_lun, int, 0); 92 MODULE_PARM_DESC(max_lun, " max lun, default=16895 "); 93 94 static u8 mptfcDoneCtx = MPT_MAX_PROTOCOL_DRIVERS; 95 static u8 mptfcTaskCtx = MPT_MAX_PROTOCOL_DRIVERS; 96 static u8 mptfcInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; 97 98 static int mptfc_target_alloc(struct scsi_target *starget); 99 static int mptfc_slave_alloc(struct scsi_device *sdev); 100 static int mptfc_qcmd(struct scsi_cmnd *SCpnt, 101 void (*done)(struct scsi_cmnd *)); 102 static void mptfc_target_destroy(struct scsi_target *starget); 103 static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout); 104 static void __devexit mptfc_remove(struct pci_dev *pdev); 105 static int mptfc_abort(struct scsi_cmnd *SCpnt); 106 static int mptfc_dev_reset(struct scsi_cmnd *SCpnt); 107 static int mptfc_bus_reset(struct scsi_cmnd *SCpnt); 108 static int mptfc_host_reset(struct scsi_cmnd *SCpnt); 109 110 static struct scsi_host_template mptfc_driver_template = { 111 .module = THIS_MODULE, 112 .proc_name = "mptfc", 113 .proc_info = mptscsih_proc_info, 114 .name = "MPT FC Host", 115 .info = mptscsih_info, 116 .queuecommand = mptfc_qcmd, 117 .target_alloc = mptfc_target_alloc, 118 .slave_alloc = mptfc_slave_alloc, 119 .slave_configure = mptscsih_slave_configure, 120 .target_destroy = mptfc_target_destroy, 121 .slave_destroy = mptscsih_slave_destroy, 122 .change_queue_depth = mptscsih_change_queue_depth, 123 .eh_abort_handler = mptfc_abort, 124 .eh_device_reset_handler = mptfc_dev_reset, 125 .eh_bus_reset_handler = mptfc_bus_reset, 126 .eh_host_reset_handler = mptfc_host_reset, 127 .bios_param = mptscsih_bios_param, 128 .can_queue = MPT_FC_CAN_QUEUE, 129 .this_id = -1, 130 .sg_tablesize = MPT_SCSI_SG_DEPTH, 131 .max_sectors = 8192, 132 .cmd_per_lun = 7, 133 .use_clustering = ENABLE_CLUSTERING, 134 .shost_attrs = mptscsih_host_attrs, 135 }; 136 137 /**************************************************************************** 138 * Supported hardware 139 */ 140 141 static struct pci_device_id mptfc_pci_table[] = { 142 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC909, 143 PCI_ANY_ID, PCI_ANY_ID }, 144 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC919, 145 PCI_ANY_ID, PCI_ANY_ID }, 146 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC929, 147 PCI_ANY_ID, PCI_ANY_ID }, 148 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC919X, 149 PCI_ANY_ID, PCI_ANY_ID }, 150 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC929X, 151 PCI_ANY_ID, PCI_ANY_ID }, 152 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC939X, 153 PCI_ANY_ID, PCI_ANY_ID }, 154 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC949X, 155 PCI_ANY_ID, PCI_ANY_ID }, 156 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC949E, 157 PCI_ANY_ID, PCI_ANY_ID }, 158 { PCI_VENDOR_ID_BROCADE, MPI_MANUFACTPAGE_DEVICEID_FC949E, 159 PCI_ANY_ID, PCI_ANY_ID }, 160 {0} /* Terminating entry */ 161 }; 162 MODULE_DEVICE_TABLE(pci, mptfc_pci_table); 163 164 static struct scsi_transport_template *mptfc_transport_template = NULL; 165 166 static struct fc_function_template mptfc_transport_functions = { 167 .dd_fcrport_size = 8, 168 .show_host_node_name = 1, 169 .show_host_port_name = 1, 170 .show_host_supported_classes = 1, 171 .show_host_port_id = 1, 172 .show_rport_supported_classes = 1, 173 .show_starget_node_name = 1, 174 .show_starget_port_name = 1, 175 .show_starget_port_id = 1, 176 .set_rport_dev_loss_tmo = mptfc_set_rport_loss_tmo, 177 .show_rport_dev_loss_tmo = 1, 178 .show_host_supported_speeds = 1, 179 .show_host_maxframe_size = 1, 180 .show_host_speed = 1, 181 .show_host_fabric_name = 1, 182 .show_host_port_type = 1, 183 .show_host_port_state = 1, 184 .show_host_symbolic_name = 1, 185 }; 186 187 static int 188 mptfc_block_error_handler(struct scsi_cmnd *SCpnt, 189 int (*func)(struct scsi_cmnd *SCpnt), 190 const char *caller) 191 { 192 MPT_SCSI_HOST *hd; 193 struct scsi_device *sdev = SCpnt->device; 194 struct Scsi_Host *shost = sdev->host; 195 struct fc_rport *rport = starget_to_rport(scsi_target(sdev)); 196 unsigned long flags; 197 int ready; 198 MPT_ADAPTER *ioc; 199 int loops = 40; /* seconds */ 200 201 hd = shost_priv(SCpnt->device->host); 202 ioc = hd->ioc; 203 spin_lock_irqsave(shost->host_lock, flags); 204 while ((ready = fc_remote_port_chkready(rport) >> 16) == DID_IMM_RETRY 205 || (loops > 0 && ioc->active == 0)) { 206 spin_unlock_irqrestore(shost->host_lock, flags); 207 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT 208 "mptfc_block_error_handler.%d: %d:%d, port status is " 209 "%x, active flag %d, deferring %s recovery.\n", 210 ioc->name, ioc->sh->host_no, 211 SCpnt->device->id, SCpnt->device->lun, 212 ready, ioc->active, caller)); 213 msleep(1000); 214 spin_lock_irqsave(shost->host_lock, flags); 215 loops --; 216 } 217 spin_unlock_irqrestore(shost->host_lock, flags); 218 219 if (ready == DID_NO_CONNECT || !SCpnt->device->hostdata 220 || ioc->active == 0) { 221 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT 222 "%s.%d: %d:%d, failing recovery, " 223 "port state %x, active %d, vdevice %p.\n", caller, 224 ioc->name, ioc->sh->host_no, 225 SCpnt->device->id, SCpnt->device->lun, ready, 226 ioc->active, SCpnt->device->hostdata)); 227 return FAILED; 228 } 229 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT 230 "%s.%d: %d:%d, executing recovery.\n", caller, 231 ioc->name, ioc->sh->host_no, 232 SCpnt->device->id, SCpnt->device->lun)); 233 return (*func)(SCpnt); 234 } 235 236 static int 237 mptfc_abort(struct scsi_cmnd *SCpnt) 238 { 239 return 240 mptfc_block_error_handler(SCpnt, mptscsih_abort, __func__); 241 } 242 243 static int 244 mptfc_dev_reset(struct scsi_cmnd *SCpnt) 245 { 246 return 247 mptfc_block_error_handler(SCpnt, mptscsih_dev_reset, __func__); 248 } 249 250 static int 251 mptfc_bus_reset(struct scsi_cmnd *SCpnt) 252 { 253 return 254 mptfc_block_error_handler(SCpnt, mptscsih_bus_reset, __func__); 255 } 256 257 static int 258 mptfc_host_reset(struct scsi_cmnd *SCpnt) 259 { 260 return 261 mptfc_block_error_handler(SCpnt, mptscsih_host_reset, __func__); 262 } 263 264 static void 265 mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout) 266 { 267 if (timeout > 0) 268 rport->dev_loss_tmo = timeout; 269 else 270 rport->dev_loss_tmo = mptfc_dev_loss_tmo; 271 } 272 273 static int 274 mptfc_FcDevPage0_cmp_func(const void *a, const void *b) 275 { 276 FCDevicePage0_t **aa = (FCDevicePage0_t **)a; 277 FCDevicePage0_t **bb = (FCDevicePage0_t **)b; 278 279 if ((*aa)->CurrentBus == (*bb)->CurrentBus) { 280 if ((*aa)->CurrentTargetID == (*bb)->CurrentTargetID) 281 return 0; 282 if ((*aa)->CurrentTargetID < (*bb)->CurrentTargetID) 283 return -1; 284 return 1; 285 } 286 if ((*aa)->CurrentBus < (*bb)->CurrentBus) 287 return -1; 288 return 1; 289 } 290 291 static int 292 mptfc_GetFcDevPage0(MPT_ADAPTER *ioc, int ioc_port, 293 void(*func)(MPT_ADAPTER *ioc,int channel, FCDevicePage0_t *arg)) 294 { 295 ConfigPageHeader_t hdr; 296 CONFIGPARMS cfg; 297 FCDevicePage0_t *ppage0_alloc, *fc; 298 dma_addr_t page0_dma; 299 int data_sz; 300 int ii; 301 302 FCDevicePage0_t *p0_array=NULL, *p_p0; 303 FCDevicePage0_t **pp0_array=NULL, **p_pp0; 304 305 int rc = -ENOMEM; 306 U32 port_id = 0xffffff; 307 int num_targ = 0; 308 int max_bus = ioc->facts.MaxBuses; 309 int max_targ; 310 311 max_targ = (ioc->facts.MaxDevices == 0) ? 256 : ioc->facts.MaxDevices; 312 313 data_sz = sizeof(FCDevicePage0_t) * max_bus * max_targ; 314 p_p0 = p0_array = kzalloc(data_sz, GFP_KERNEL); 315 if (!p0_array) 316 goto out; 317 318 data_sz = sizeof(FCDevicePage0_t *) * max_bus * max_targ; 319 p_pp0 = pp0_array = kzalloc(data_sz, GFP_KERNEL); 320 if (!pp0_array) 321 goto out; 322 323 do { 324 /* Get FC Device Page 0 header */ 325 hdr.PageVersion = 0; 326 hdr.PageLength = 0; 327 hdr.PageNumber = 0; 328 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_DEVICE; 329 cfg.cfghdr.hdr = &hdr; 330 cfg.physAddr = -1; 331 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 332 cfg.dir = 0; 333 cfg.pageAddr = port_id; 334 cfg.timeout = 0; 335 336 if ((rc = mpt_config(ioc, &cfg)) != 0) 337 break; 338 339 if (hdr.PageLength <= 0) 340 break; 341 342 data_sz = hdr.PageLength * 4; 343 ppage0_alloc = pci_alloc_consistent(ioc->pcidev, data_sz, 344 &page0_dma); 345 rc = -ENOMEM; 346 if (!ppage0_alloc) 347 break; 348 349 cfg.physAddr = page0_dma; 350 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 351 352 if ((rc = mpt_config(ioc, &cfg)) == 0) { 353 ppage0_alloc->PortIdentifier = 354 le32_to_cpu(ppage0_alloc->PortIdentifier); 355 356 ppage0_alloc->WWNN.Low = 357 le32_to_cpu(ppage0_alloc->WWNN.Low); 358 359 ppage0_alloc->WWNN.High = 360 le32_to_cpu(ppage0_alloc->WWNN.High); 361 362 ppage0_alloc->WWPN.Low = 363 le32_to_cpu(ppage0_alloc->WWPN.Low); 364 365 ppage0_alloc->WWPN.High = 366 le32_to_cpu(ppage0_alloc->WWPN.High); 367 368 ppage0_alloc->BBCredit = 369 le16_to_cpu(ppage0_alloc->BBCredit); 370 371 ppage0_alloc->MaxRxFrameSize = 372 le16_to_cpu(ppage0_alloc->MaxRxFrameSize); 373 374 port_id = ppage0_alloc->PortIdentifier; 375 num_targ++; 376 *p_p0 = *ppage0_alloc; /* save data */ 377 *p_pp0++ = p_p0++; /* save addr */ 378 } 379 pci_free_consistent(ioc->pcidev, data_sz, 380 (u8 *) ppage0_alloc, page0_dma); 381 if (rc != 0) 382 break; 383 384 } while (port_id <= 0xff0000); 385 386 if (num_targ) { 387 /* sort array */ 388 if (num_targ > 1) 389 sort (pp0_array, num_targ, sizeof(FCDevicePage0_t *), 390 mptfc_FcDevPage0_cmp_func, NULL); 391 /* call caller's func for each targ */ 392 for (ii = 0; ii < num_targ; ii++) { 393 fc = *(pp0_array+ii); 394 func(ioc, ioc_port, fc); 395 } 396 } 397 398 out: 399 kfree(pp0_array); 400 kfree(p0_array); 401 return rc; 402 } 403 404 static int 405 mptfc_generate_rport_ids(FCDevicePage0_t *pg0, struct fc_rport_identifiers *rid) 406 { 407 /* not currently usable */ 408 if (pg0->Flags & (MPI_FC_DEVICE_PAGE0_FLAGS_PLOGI_INVALID | 409 MPI_FC_DEVICE_PAGE0_FLAGS_PRLI_INVALID)) 410 return -1; 411 412 if (!(pg0->Flags & MPI_FC_DEVICE_PAGE0_FLAGS_TARGETID_BUS_VALID)) 413 return -1; 414 415 if (!(pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_TARGET)) 416 return -1; 417 418 /* 419 * board data structure already normalized to platform endianness 420 * shifted to avoid unaligned access on 64 bit architecture 421 */ 422 rid->node_name = ((u64)pg0->WWNN.High) << 32 | (u64)pg0->WWNN.Low; 423 rid->port_name = ((u64)pg0->WWPN.High) << 32 | (u64)pg0->WWPN.Low; 424 rid->port_id = pg0->PortIdentifier; 425 rid->roles = FC_RPORT_ROLE_UNKNOWN; 426 427 return 0; 428 } 429 430 static void 431 mptfc_register_dev(MPT_ADAPTER *ioc, int channel, FCDevicePage0_t *pg0) 432 { 433 struct fc_rport_identifiers rport_ids; 434 struct fc_rport *rport; 435 struct mptfc_rport_info *ri; 436 int new_ri = 1; 437 u64 pn, nn; 438 VirtTarget *vtarget; 439 u32 roles = FC_RPORT_ROLE_UNKNOWN; 440 441 if (mptfc_generate_rport_ids(pg0, &rport_ids) < 0) 442 return; 443 444 roles |= FC_RPORT_ROLE_FCP_TARGET; 445 if (pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_INITIATOR) 446 roles |= FC_RPORT_ROLE_FCP_INITIATOR; 447 448 /* scan list looking for a match */ 449 list_for_each_entry(ri, &ioc->fc_rports, list) { 450 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low; 451 if (pn == rport_ids.port_name) { /* match */ 452 list_move_tail(&ri->list, &ioc->fc_rports); 453 new_ri = 0; 454 break; 455 } 456 } 457 if (new_ri) { /* allocate one */ 458 ri = kzalloc(sizeof(struct mptfc_rport_info), GFP_KERNEL); 459 if (!ri) 460 return; 461 list_add_tail(&ri->list, &ioc->fc_rports); 462 } 463 464 ri->pg0 = *pg0; /* add/update pg0 data */ 465 ri->flags &= ~MPT_RPORT_INFO_FLAGS_MISSING; 466 467 /* MPT_RPORT_INFO_FLAGS_REGISTERED - rport not previously deleted */ 468 if (!(ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED)) { 469 ri->flags |= MPT_RPORT_INFO_FLAGS_REGISTERED; 470 rport = fc_remote_port_add(ioc->sh, channel, &rport_ids); 471 if (rport) { 472 ri->rport = rport; 473 if (new_ri) /* may have been reset by user */ 474 rport->dev_loss_tmo = mptfc_dev_loss_tmo; 475 /* 476 * if already mapped, remap here. If not mapped, 477 * target_alloc will allocate vtarget and map, 478 * slave_alloc will fill in vdevice from vtarget. 479 */ 480 if (ri->starget) { 481 vtarget = ri->starget->hostdata; 482 if (vtarget) { 483 vtarget->id = pg0->CurrentTargetID; 484 vtarget->channel = pg0->CurrentBus; 485 vtarget->deleted = 0; 486 } 487 } 488 *((struct mptfc_rport_info **)rport->dd_data) = ri; 489 /* scan will be scheduled once rport becomes a target */ 490 fc_remote_port_rolechg(rport,roles); 491 492 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low; 493 nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low; 494 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT 495 "mptfc_reg_dev.%d: %x, %llx / %llx, tid %d, " 496 "rport tid %d, tmo %d\n", 497 ioc->name, 498 ioc->sh->host_no, 499 pg0->PortIdentifier, 500 (unsigned long long)nn, 501 (unsigned long long)pn, 502 pg0->CurrentTargetID, 503 ri->rport->scsi_target_id, 504 ri->rport->dev_loss_tmo)); 505 } else { 506 list_del(&ri->list); 507 kfree(ri); 508 ri = NULL; 509 } 510 } 511 } 512 513 /* 514 * OS entry point to allow for host driver to free allocated memory 515 * Called if no device present or device being unloaded 516 */ 517 static void 518 mptfc_target_destroy(struct scsi_target *starget) 519 { 520 struct fc_rport *rport; 521 struct mptfc_rport_info *ri; 522 523 rport = starget_to_rport(starget); 524 if (rport) { 525 ri = *((struct mptfc_rport_info **)rport->dd_data); 526 if (ri) /* better be! */ 527 ri->starget = NULL; 528 } 529 if (starget->hostdata) 530 kfree(starget->hostdata); 531 starget->hostdata = NULL; 532 } 533 534 /* 535 * OS entry point to allow host driver to alloc memory 536 * for each scsi target. Called once per device the bus scan. 537 * Return non-zero if allocation fails. 538 */ 539 static int 540 mptfc_target_alloc(struct scsi_target *starget) 541 { 542 VirtTarget *vtarget; 543 struct fc_rport *rport; 544 struct mptfc_rport_info *ri; 545 int rc; 546 547 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL); 548 if (!vtarget) 549 return -ENOMEM; 550 starget->hostdata = vtarget; 551 552 rc = -ENODEV; 553 rport = starget_to_rport(starget); 554 if (rport) { 555 ri = *((struct mptfc_rport_info **)rport->dd_data); 556 if (ri) { /* better be! */ 557 vtarget->id = ri->pg0.CurrentTargetID; 558 vtarget->channel = ri->pg0.CurrentBus; 559 ri->starget = starget; 560 rc = 0; 561 } 562 } 563 if (rc != 0) { 564 kfree(vtarget); 565 starget->hostdata = NULL; 566 } 567 568 return rc; 569 } 570 /* 571 * mptfc_dump_lun_info 572 * @ioc 573 * @rport 574 * @sdev 575 * 576 */ 577 static void 578 mptfc_dump_lun_info(MPT_ADAPTER *ioc, struct fc_rport *rport, struct scsi_device *sdev, 579 VirtTarget *vtarget) 580 { 581 u64 nn, pn; 582 struct mptfc_rport_info *ri; 583 584 ri = *((struct mptfc_rport_info **)rport->dd_data); 585 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low; 586 nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low; 587 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT 588 "mptfc_slv_alloc.%d: num_luns %d, sdev.id %d, " 589 "CurrentTargetID %d, %x %llx %llx\n", 590 ioc->name, 591 sdev->host->host_no, 592 vtarget->num_luns, 593 sdev->id, ri->pg0.CurrentTargetID, 594 ri->pg0.PortIdentifier, 595 (unsigned long long)pn, 596 (unsigned long long)nn)); 597 } 598 599 600 /* 601 * OS entry point to allow host driver to alloc memory 602 * for each scsi device. Called once per device the bus scan. 603 * Return non-zero if allocation fails. 604 * Init memory once per LUN. 605 */ 606 static int 607 mptfc_slave_alloc(struct scsi_device *sdev) 608 { 609 MPT_SCSI_HOST *hd; 610 VirtTarget *vtarget; 611 VirtDevice *vdevice; 612 struct scsi_target *starget; 613 struct fc_rport *rport; 614 MPT_ADAPTER *ioc; 615 616 starget = scsi_target(sdev); 617 rport = starget_to_rport(starget); 618 619 if (!rport || fc_remote_port_chkready(rport)) 620 return -ENXIO; 621 622 hd = shost_priv(sdev->host); 623 ioc = hd->ioc; 624 625 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL); 626 if (!vdevice) { 627 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n", 628 ioc->name, sizeof(VirtDevice)); 629 return -ENOMEM; 630 } 631 632 633 sdev->hostdata = vdevice; 634 vtarget = starget->hostdata; 635 636 if (vtarget->num_luns == 0) { 637 vtarget->ioc_id = ioc->id; 638 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES; 639 } 640 641 vdevice->vtarget = vtarget; 642 vdevice->lun = sdev->lun; 643 644 vtarget->num_luns++; 645 646 647 mptfc_dump_lun_info(ioc, rport, sdev, vtarget); 648 649 return 0; 650 } 651 652 static int 653 mptfc_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 654 { 655 struct mptfc_rport_info *ri; 656 struct fc_rport *rport = starget_to_rport(scsi_target(SCpnt->device)); 657 int err; 658 VirtDevice *vdevice = SCpnt->device->hostdata; 659 660 if (!vdevice || !vdevice->vtarget) { 661 SCpnt->result = DID_NO_CONNECT << 16; 662 done(SCpnt); 663 return 0; 664 } 665 666 err = fc_remote_port_chkready(rport); 667 if (unlikely(err)) { 668 SCpnt->result = err; 669 done(SCpnt); 670 return 0; 671 } 672 673 /* dd_data is null until finished adding target */ 674 ri = *((struct mptfc_rport_info **)rport->dd_data); 675 if (unlikely(!ri)) { 676 SCpnt->result = DID_IMM_RETRY << 16; 677 done(SCpnt); 678 return 0; 679 } 680 681 return mptscsih_qcmd(SCpnt,done); 682 } 683 684 /* 685 * mptfc_display_port_link_speed - displaying link speed 686 * @ioc: Pointer to MPT_ADAPTER structure 687 * @portnum: IOC Port number 688 * @pp0dest: port page0 data payload 689 * 690 */ 691 static void 692 mptfc_display_port_link_speed(MPT_ADAPTER *ioc, int portnum, FCPortPage0_t *pp0dest) 693 { 694 u8 old_speed, new_speed, state; 695 char *old, *new; 696 697 if (portnum >= 2) 698 return; 699 700 old_speed = ioc->fc_link_speed[portnum]; 701 new_speed = pp0dest->CurrentSpeed; 702 state = pp0dest->PortState; 703 704 if (state != MPI_FCPORTPAGE0_PORTSTATE_OFFLINE && 705 new_speed != MPI_FCPORTPAGE0_CURRENT_SPEED_UKNOWN) { 706 707 old = old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT ? "1 Gbps" : 708 old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT ? "2 Gbps" : 709 old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT ? "4 Gbps" : 710 "Unknown"; 711 new = new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT ? "1 Gbps" : 712 new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT ? "2 Gbps" : 713 new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT ? "4 Gbps" : 714 "Unknown"; 715 if (old_speed == 0) 716 printk(MYIOC_s_NOTE_FMT 717 "FC Link Established, Speed = %s\n", 718 ioc->name, new); 719 else if (old_speed != new_speed) 720 printk(MYIOC_s_WARN_FMT 721 "FC Link Speed Change, Old Speed = %s, New Speed = %s\n", 722 ioc->name, old, new); 723 724 ioc->fc_link_speed[portnum] = new_speed; 725 } 726 } 727 728 /* 729 * mptfc_GetFcPortPage0 - Fetch FCPort config Page0. 730 * @ioc: Pointer to MPT_ADAPTER structure 731 * @portnum: IOC Port number 732 * 733 * Return: 0 for success 734 * -ENOMEM if no memory available 735 * -EPERM if not allowed due to ISR context 736 * -EAGAIN if no msg frames currently available 737 * -EFAULT for non-successful reply or no reply (timeout) 738 * -EINVAL portnum arg out of range (hardwired to two elements) 739 */ 740 static int 741 mptfc_GetFcPortPage0(MPT_ADAPTER *ioc, int portnum) 742 { 743 ConfigPageHeader_t hdr; 744 CONFIGPARMS cfg; 745 FCPortPage0_t *ppage0_alloc; 746 FCPortPage0_t *pp0dest; 747 dma_addr_t page0_dma; 748 int data_sz; 749 int copy_sz; 750 int rc; 751 int count = 400; 752 753 if (portnum > 1) 754 return -EINVAL; 755 756 /* Get FCPort Page 0 header */ 757 hdr.PageVersion = 0; 758 hdr.PageLength = 0; 759 hdr.PageNumber = 0; 760 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT; 761 cfg.cfghdr.hdr = &hdr; 762 cfg.physAddr = -1; 763 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 764 cfg.dir = 0; 765 cfg.pageAddr = portnum; 766 cfg.timeout = 0; 767 768 if ((rc = mpt_config(ioc, &cfg)) != 0) 769 return rc; 770 771 if (hdr.PageLength == 0) 772 return 0; 773 774 data_sz = hdr.PageLength * 4; 775 rc = -ENOMEM; 776 ppage0_alloc = (FCPortPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma); 777 if (ppage0_alloc) { 778 779 try_again: 780 memset((u8 *)ppage0_alloc, 0, data_sz); 781 cfg.physAddr = page0_dma; 782 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 783 784 if ((rc = mpt_config(ioc, &cfg)) == 0) { 785 /* save the data */ 786 pp0dest = &ioc->fc_port_page0[portnum]; 787 copy_sz = min_t(int, sizeof(FCPortPage0_t), data_sz); 788 memcpy(pp0dest, ppage0_alloc, copy_sz); 789 790 /* 791 * Normalize endianness of structure data, 792 * by byte-swapping all > 1 byte fields! 793 */ 794 pp0dest->Flags = le32_to_cpu(pp0dest->Flags); 795 pp0dest->PortIdentifier = le32_to_cpu(pp0dest->PortIdentifier); 796 pp0dest->WWNN.Low = le32_to_cpu(pp0dest->WWNN.Low); 797 pp0dest->WWNN.High = le32_to_cpu(pp0dest->WWNN.High); 798 pp0dest->WWPN.Low = le32_to_cpu(pp0dest->WWPN.Low); 799 pp0dest->WWPN.High = le32_to_cpu(pp0dest->WWPN.High); 800 pp0dest->SupportedServiceClass = le32_to_cpu(pp0dest->SupportedServiceClass); 801 pp0dest->SupportedSpeeds = le32_to_cpu(pp0dest->SupportedSpeeds); 802 pp0dest->CurrentSpeed = le32_to_cpu(pp0dest->CurrentSpeed); 803 pp0dest->MaxFrameSize = le32_to_cpu(pp0dest->MaxFrameSize); 804 pp0dest->FabricWWNN.Low = le32_to_cpu(pp0dest->FabricWWNN.Low); 805 pp0dest->FabricWWNN.High = le32_to_cpu(pp0dest->FabricWWNN.High); 806 pp0dest->FabricWWPN.Low = le32_to_cpu(pp0dest->FabricWWPN.Low); 807 pp0dest->FabricWWPN.High = le32_to_cpu(pp0dest->FabricWWPN.High); 808 pp0dest->DiscoveredPortsCount = le32_to_cpu(pp0dest->DiscoveredPortsCount); 809 pp0dest->MaxInitiators = le32_to_cpu(pp0dest->MaxInitiators); 810 811 /* 812 * if still doing discovery, 813 * hang loose a while until finished 814 */ 815 if ((pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_UNKNOWN) || 816 (pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_ONLINE && 817 (pp0dest->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_TYPE_MASK) 818 == MPI_FCPORTPAGE0_FLAGS_ATTACH_NO_INIT)) { 819 if (count-- > 0) { 820 msleep(100); 821 goto try_again; 822 } 823 printk(MYIOC_s_INFO_FMT "Firmware discovery not" 824 " complete.\n", 825 ioc->name); 826 } 827 mptfc_display_port_link_speed(ioc, portnum, pp0dest); 828 } 829 830 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma); 831 } 832 833 return rc; 834 } 835 836 static int 837 mptfc_WriteFcPortPage1(MPT_ADAPTER *ioc, int portnum) 838 { 839 ConfigPageHeader_t hdr; 840 CONFIGPARMS cfg; 841 int rc; 842 843 if (portnum > 1) 844 return -EINVAL; 845 846 if (!(ioc->fc_data.fc_port_page1[portnum].data)) 847 return -EINVAL; 848 849 /* get fcport page 1 header */ 850 hdr.PageVersion = 0; 851 hdr.PageLength = 0; 852 hdr.PageNumber = 1; 853 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT; 854 cfg.cfghdr.hdr = &hdr; 855 cfg.physAddr = -1; 856 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 857 cfg.dir = 0; 858 cfg.pageAddr = portnum; 859 cfg.timeout = 0; 860 861 if ((rc = mpt_config(ioc, &cfg)) != 0) 862 return rc; 863 864 if (hdr.PageLength == 0) 865 return -ENODEV; 866 867 if (hdr.PageLength*4 != ioc->fc_data.fc_port_page1[portnum].pg_sz) 868 return -EINVAL; 869 870 cfg.physAddr = ioc->fc_data.fc_port_page1[portnum].dma; 871 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 872 cfg.dir = 1; 873 874 rc = mpt_config(ioc, &cfg); 875 876 return rc; 877 } 878 879 static int 880 mptfc_GetFcPortPage1(MPT_ADAPTER *ioc, int portnum) 881 { 882 ConfigPageHeader_t hdr; 883 CONFIGPARMS cfg; 884 FCPortPage1_t *page1_alloc; 885 dma_addr_t page1_dma; 886 int data_sz; 887 int rc; 888 889 if (portnum > 1) 890 return -EINVAL; 891 892 /* get fcport page 1 header */ 893 hdr.PageVersion = 0; 894 hdr.PageLength = 0; 895 hdr.PageNumber = 1; 896 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT; 897 cfg.cfghdr.hdr = &hdr; 898 cfg.physAddr = -1; 899 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 900 cfg.dir = 0; 901 cfg.pageAddr = portnum; 902 cfg.timeout = 0; 903 904 if ((rc = mpt_config(ioc, &cfg)) != 0) 905 return rc; 906 907 if (hdr.PageLength == 0) 908 return -ENODEV; 909 910 start_over: 911 912 if (ioc->fc_data.fc_port_page1[portnum].data == NULL) { 913 data_sz = hdr.PageLength * 4; 914 if (data_sz < sizeof(FCPortPage1_t)) 915 data_sz = sizeof(FCPortPage1_t); 916 917 page1_alloc = (FCPortPage1_t *) pci_alloc_consistent(ioc->pcidev, 918 data_sz, 919 &page1_dma); 920 if (!page1_alloc) 921 return -ENOMEM; 922 } 923 else { 924 page1_alloc = ioc->fc_data.fc_port_page1[portnum].data; 925 page1_dma = ioc->fc_data.fc_port_page1[portnum].dma; 926 data_sz = ioc->fc_data.fc_port_page1[portnum].pg_sz; 927 if (hdr.PageLength * 4 > data_sz) { 928 ioc->fc_data.fc_port_page1[portnum].data = NULL; 929 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) 930 page1_alloc, page1_dma); 931 goto start_over; 932 } 933 } 934 935 memset(page1_alloc,0,data_sz); 936 937 cfg.physAddr = page1_dma; 938 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 939 940 if ((rc = mpt_config(ioc, &cfg)) == 0) { 941 ioc->fc_data.fc_port_page1[portnum].data = page1_alloc; 942 ioc->fc_data.fc_port_page1[portnum].pg_sz = data_sz; 943 ioc->fc_data.fc_port_page1[portnum].dma = page1_dma; 944 } 945 else { 946 ioc->fc_data.fc_port_page1[portnum].data = NULL; 947 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) 948 page1_alloc, page1_dma); 949 } 950 951 return rc; 952 } 953 954 static void 955 mptfc_SetFcPortPage1_defaults(MPT_ADAPTER *ioc) 956 { 957 int ii; 958 FCPortPage1_t *pp1; 959 960 #define MPTFC_FW_DEVICE_TIMEOUT (1) 961 #define MPTFC_FW_IO_PEND_TIMEOUT (1) 962 #define ON_FLAGS (MPI_FCPORTPAGE1_FLAGS_IMMEDIATE_ERROR_REPLY) 963 #define OFF_FLAGS (MPI_FCPORTPAGE1_FLAGS_VERBOSE_RESCAN_EVENTS) 964 965 for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) { 966 if (mptfc_GetFcPortPage1(ioc, ii) != 0) 967 continue; 968 pp1 = ioc->fc_data.fc_port_page1[ii].data; 969 if ((pp1->InitiatorDeviceTimeout == MPTFC_FW_DEVICE_TIMEOUT) 970 && (pp1->InitiatorIoPendTimeout == MPTFC_FW_IO_PEND_TIMEOUT) 971 && ((pp1->Flags & ON_FLAGS) == ON_FLAGS) 972 && ((pp1->Flags & OFF_FLAGS) == 0)) 973 continue; 974 pp1->InitiatorDeviceTimeout = MPTFC_FW_DEVICE_TIMEOUT; 975 pp1->InitiatorIoPendTimeout = MPTFC_FW_IO_PEND_TIMEOUT; 976 pp1->Flags &= ~OFF_FLAGS; 977 pp1->Flags |= ON_FLAGS; 978 mptfc_WriteFcPortPage1(ioc, ii); 979 } 980 } 981 982 983 static void 984 mptfc_init_host_attr(MPT_ADAPTER *ioc,int portnum) 985 { 986 unsigned class = 0; 987 unsigned cos = 0; 988 unsigned speed; 989 unsigned port_type; 990 unsigned port_state; 991 FCPortPage0_t *pp0; 992 struct Scsi_Host *sh; 993 char *sn; 994 995 /* don't know what to do as only one scsi (fc) host was allocated */ 996 if (portnum != 0) 997 return; 998 999 pp0 = &ioc->fc_port_page0[portnum]; 1000 sh = ioc->sh; 1001 1002 sn = fc_host_symbolic_name(sh); 1003 snprintf(sn, FC_SYMBOLIC_NAME_SIZE, "%s %s%08xh", 1004 ioc->prod_name, 1005 MPT_FW_REV_MAGIC_ID_STRING, 1006 ioc->facts.FWVersion.Word); 1007 1008 fc_host_tgtid_bind_type(sh) = FC_TGTID_BIND_BY_WWPN; 1009 1010 fc_host_maxframe_size(sh) = pp0->MaxFrameSize; 1011 1012 fc_host_node_name(sh) = 1013 (u64)pp0->WWNN.High << 32 | (u64)pp0->WWNN.Low; 1014 1015 fc_host_port_name(sh) = 1016 (u64)pp0->WWPN.High << 32 | (u64)pp0->WWPN.Low; 1017 1018 fc_host_port_id(sh) = pp0->PortIdentifier; 1019 1020 class = pp0->SupportedServiceClass; 1021 if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_1) 1022 cos |= FC_COS_CLASS1; 1023 if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_2) 1024 cos |= FC_COS_CLASS2; 1025 if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_3) 1026 cos |= FC_COS_CLASS3; 1027 fc_host_supported_classes(sh) = cos; 1028 1029 if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT) 1030 speed = FC_PORTSPEED_1GBIT; 1031 else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT) 1032 speed = FC_PORTSPEED_2GBIT; 1033 else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT) 1034 speed = FC_PORTSPEED_4GBIT; 1035 else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_10GBIT) 1036 speed = FC_PORTSPEED_10GBIT; 1037 else 1038 speed = FC_PORTSPEED_UNKNOWN; 1039 fc_host_speed(sh) = speed; 1040 1041 speed = 0; 1042 if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_1GBIT_SPEED) 1043 speed |= FC_PORTSPEED_1GBIT; 1044 if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_2GBIT_SPEED) 1045 speed |= FC_PORTSPEED_2GBIT; 1046 if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_4GBIT_SPEED) 1047 speed |= FC_PORTSPEED_4GBIT; 1048 if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_10GBIT_SPEED) 1049 speed |= FC_PORTSPEED_10GBIT; 1050 fc_host_supported_speeds(sh) = speed; 1051 1052 port_state = FC_PORTSTATE_UNKNOWN; 1053 if (pp0->PortState == MPI_FCPORTPAGE0_PORTSTATE_ONLINE) 1054 port_state = FC_PORTSTATE_ONLINE; 1055 else if (pp0->PortState == MPI_FCPORTPAGE0_PORTSTATE_OFFLINE) 1056 port_state = FC_PORTSTATE_LINKDOWN; 1057 fc_host_port_state(sh) = port_state; 1058 1059 port_type = FC_PORTTYPE_UNKNOWN; 1060 if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_POINT_TO_POINT) 1061 port_type = FC_PORTTYPE_PTP; 1062 else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_PRIVATE_LOOP) 1063 port_type = FC_PORTTYPE_LPORT; 1064 else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_PUBLIC_LOOP) 1065 port_type = FC_PORTTYPE_NLPORT; 1066 else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_FABRIC_DIRECT) 1067 port_type = FC_PORTTYPE_NPORT; 1068 fc_host_port_type(sh) = port_type; 1069 1070 fc_host_fabric_name(sh) = 1071 (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_FABRIC_WWN_VALID) ? 1072 (u64) pp0->FabricWWNN.High << 32 | (u64) pp0->FabricWWPN.Low : 1073 (u64)pp0->WWNN.High << 32 | (u64)pp0->WWNN.Low; 1074 1075 } 1076 1077 static void 1078 mptfc_link_status_change(struct work_struct *work) 1079 { 1080 MPT_ADAPTER *ioc = 1081 container_of(work, MPT_ADAPTER, fc_rescan_work); 1082 int ii; 1083 1084 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) 1085 (void) mptfc_GetFcPortPage0(ioc, ii); 1086 1087 } 1088 1089 static void 1090 mptfc_setup_reset(struct work_struct *work) 1091 { 1092 MPT_ADAPTER *ioc = 1093 container_of(work, MPT_ADAPTER, fc_setup_reset_work); 1094 u64 pn; 1095 struct mptfc_rport_info *ri; 1096 struct scsi_target *starget; 1097 VirtTarget *vtarget; 1098 1099 /* reset about to happen, delete (block) all rports */ 1100 list_for_each_entry(ri, &ioc->fc_rports, list) { 1101 if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) { 1102 ri->flags &= ~MPT_RPORT_INFO_FLAGS_REGISTERED; 1103 fc_remote_port_delete(ri->rport); /* won't sleep */ 1104 ri->rport = NULL; 1105 starget = ri->starget; 1106 if (starget) { 1107 vtarget = starget->hostdata; 1108 if (vtarget) 1109 vtarget->deleted = 1; 1110 } 1111 1112 pn = (u64)ri->pg0.WWPN.High << 32 | 1113 (u64)ri->pg0.WWPN.Low; 1114 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT 1115 "mptfc_setup_reset.%d: %llx deleted\n", 1116 ioc->name, 1117 ioc->sh->host_no, 1118 (unsigned long long)pn)); 1119 } 1120 } 1121 } 1122 1123 static void 1124 mptfc_rescan_devices(struct work_struct *work) 1125 { 1126 MPT_ADAPTER *ioc = 1127 container_of(work, MPT_ADAPTER, fc_rescan_work); 1128 int ii; 1129 u64 pn; 1130 struct mptfc_rport_info *ri; 1131 struct scsi_target *starget; 1132 VirtTarget *vtarget; 1133 1134 /* start by tagging all ports as missing */ 1135 list_for_each_entry(ri, &ioc->fc_rports, list) { 1136 if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) { 1137 ri->flags |= MPT_RPORT_INFO_FLAGS_MISSING; 1138 } 1139 } 1140 1141 /* 1142 * now rescan devices known to adapter, 1143 * will reregister existing rports 1144 */ 1145 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) { 1146 (void) mptfc_GetFcPortPage0(ioc, ii); 1147 mptfc_init_host_attr(ioc, ii); /* refresh */ 1148 mptfc_GetFcDevPage0(ioc, ii, mptfc_register_dev); 1149 } 1150 1151 /* delete devices still missing */ 1152 list_for_each_entry(ri, &ioc->fc_rports, list) { 1153 /* if newly missing, delete it */ 1154 if (ri->flags & MPT_RPORT_INFO_FLAGS_MISSING) { 1155 1156 ri->flags &= ~(MPT_RPORT_INFO_FLAGS_REGISTERED| 1157 MPT_RPORT_INFO_FLAGS_MISSING); 1158 fc_remote_port_delete(ri->rport); /* won't sleep */ 1159 ri->rport = NULL; 1160 starget = ri->starget; 1161 if (starget) { 1162 vtarget = starget->hostdata; 1163 if (vtarget) 1164 vtarget->deleted = 1; 1165 } 1166 1167 pn = (u64)ri->pg0.WWPN.High << 32 | 1168 (u64)ri->pg0.WWPN.Low; 1169 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT 1170 "mptfc_rescan.%d: %llx deleted\n", 1171 ioc->name, 1172 ioc->sh->host_no, 1173 (unsigned long long)pn)); 1174 } 1175 } 1176 } 1177 1178 static int 1179 mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id) 1180 { 1181 struct Scsi_Host *sh; 1182 MPT_SCSI_HOST *hd; 1183 MPT_ADAPTER *ioc; 1184 unsigned long flags; 1185 int ii; 1186 int numSGE = 0; 1187 int scale; 1188 int ioc_cap; 1189 int error=0; 1190 int r; 1191 1192 if ((r = mpt_attach(pdev,id)) != 0) 1193 return r; 1194 1195 ioc = pci_get_drvdata(pdev); 1196 ioc->DoneCtx = mptfcDoneCtx; 1197 ioc->TaskCtx = mptfcTaskCtx; 1198 ioc->InternalCtx = mptfcInternalCtx; 1199 1200 /* Added sanity check on readiness of the MPT adapter. 1201 */ 1202 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) { 1203 printk(MYIOC_s_WARN_FMT 1204 "Skipping because it's not operational!\n", 1205 ioc->name); 1206 error = -ENODEV; 1207 goto out_mptfc_probe; 1208 } 1209 1210 if (!ioc->active) { 1211 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", 1212 ioc->name); 1213 error = -ENODEV; 1214 goto out_mptfc_probe; 1215 } 1216 1217 /* Sanity check - ensure at least 1 port is INITIATOR capable 1218 */ 1219 ioc_cap = 0; 1220 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) { 1221 if (ioc->pfacts[ii].ProtocolFlags & 1222 MPI_PORTFACTS_PROTOCOL_INITIATOR) 1223 ioc_cap ++; 1224 } 1225 1226 if (!ioc_cap) { 1227 printk(MYIOC_s_WARN_FMT 1228 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n", 1229 ioc->name, ioc); 1230 return 0; 1231 } 1232 1233 sh = scsi_host_alloc(&mptfc_driver_template, sizeof(MPT_SCSI_HOST)); 1234 1235 if (!sh) { 1236 printk(MYIOC_s_WARN_FMT 1237 "Unable to register controller with SCSI subsystem\n", 1238 ioc->name); 1239 error = -1; 1240 goto out_mptfc_probe; 1241 } 1242 1243 spin_lock_init(&ioc->fc_rescan_work_lock); 1244 INIT_WORK(&ioc->fc_rescan_work, mptfc_rescan_devices); 1245 INIT_WORK(&ioc->fc_setup_reset_work, mptfc_setup_reset); 1246 INIT_WORK(&ioc->fc_lsc_work, mptfc_link_status_change); 1247 1248 spin_lock_irqsave(&ioc->FreeQlock, flags); 1249 1250 /* Attach the SCSI Host to the IOC structure 1251 */ 1252 ioc->sh = sh; 1253 1254 sh->io_port = 0; 1255 sh->n_io_port = 0; 1256 sh->irq = 0; 1257 1258 /* set 16 byte cdb's */ 1259 sh->max_cmd_len = 16; 1260 1261 sh->max_id = ioc->pfacts->MaxDevices; 1262 sh->max_lun = max_lun; 1263 1264 /* Required entry. 1265 */ 1266 sh->unique_id = ioc->id; 1267 1268 /* Verify that we won't exceed the maximum 1269 * number of chain buffers 1270 * We can optimize: ZZ = req_sz/sizeof(SGE) 1271 * For 32bit SGE's: 1272 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ 1273 * + (req_sz - 64)/sizeof(SGE) 1274 * A slightly different algorithm is required for 1275 * 64bit SGEs. 1276 */ 1277 scale = ioc->req_sz/ioc->SGE_size; 1278 if (ioc->sg_addr_size == sizeof(u64)) { 1279 numSGE = (scale - 1) * 1280 (ioc->facts.MaxChainDepth-1) + scale + 1281 (ioc->req_sz - 60) / ioc->SGE_size; 1282 } else { 1283 numSGE = 1 + (scale - 1) * 1284 (ioc->facts.MaxChainDepth-1) + scale + 1285 (ioc->req_sz - 64) / ioc->SGE_size; 1286 } 1287 1288 if (numSGE < sh->sg_tablesize) { 1289 /* Reset this value */ 1290 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1291 "Resetting sg_tablesize to %d from %d\n", 1292 ioc->name, numSGE, sh->sg_tablesize)); 1293 sh->sg_tablesize = numSGE; 1294 } 1295 1296 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 1297 1298 hd = shost_priv(sh); 1299 hd->ioc = ioc; 1300 1301 /* SCSI needs scsi_cmnd lookup table! 1302 * (with size equal to req_depth*PtrSz!) 1303 */ 1304 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC); 1305 if (!ioc->ScsiLookup) { 1306 error = -ENOMEM; 1307 goto out_mptfc_probe; 1308 } 1309 spin_lock_init(&ioc->scsi_lookup_lock); 1310 1311 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n", 1312 ioc->name, ioc->ScsiLookup)); 1313 1314 hd->last_queue_full = 0; 1315 1316 sh->transportt = mptfc_transport_template; 1317 error = scsi_add_host (sh, &ioc->pcidev->dev); 1318 if(error) { 1319 dprintk(ioc, printk(MYIOC_s_ERR_FMT 1320 "scsi_add_host failed\n", ioc->name)); 1321 goto out_mptfc_probe; 1322 } 1323 1324 /* initialize workqueue */ 1325 1326 snprintf(ioc->fc_rescan_work_q_name, sizeof(ioc->fc_rescan_work_q_name), 1327 "mptfc_wq_%d", sh->host_no); 1328 ioc->fc_rescan_work_q = 1329 create_singlethread_workqueue(ioc->fc_rescan_work_q_name); 1330 if (!ioc->fc_rescan_work_q) 1331 goto out_mptfc_probe; 1332 1333 /* 1334 * Pre-fetch FC port WWN and stuff... 1335 * (FCPortPage0_t stuff) 1336 */ 1337 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) { 1338 (void) mptfc_GetFcPortPage0(ioc, ii); 1339 } 1340 mptfc_SetFcPortPage1_defaults(ioc); 1341 1342 /* 1343 * scan for rports - 1344 * by doing it via the workqueue, some locking is eliminated 1345 */ 1346 1347 queue_work(ioc->fc_rescan_work_q, &ioc->fc_rescan_work); 1348 flush_workqueue(ioc->fc_rescan_work_q); 1349 1350 return 0; 1351 1352 out_mptfc_probe: 1353 1354 mptscsih_remove(pdev); 1355 return error; 1356 } 1357 1358 static struct pci_driver mptfc_driver = { 1359 .name = "mptfc", 1360 .id_table = mptfc_pci_table, 1361 .probe = mptfc_probe, 1362 .remove = __devexit_p(mptfc_remove), 1363 .shutdown = mptscsih_shutdown, 1364 #ifdef CONFIG_PM 1365 .suspend = mptscsih_suspend, 1366 .resume = mptscsih_resume, 1367 #endif 1368 }; 1369 1370 static int 1371 mptfc_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) 1372 { 1373 MPT_SCSI_HOST *hd; 1374 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF; 1375 unsigned long flags; 1376 int rc=1; 1377 1378 if (ioc->bus_type != FC) 1379 return 0; 1380 1381 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n", 1382 ioc->name, event)); 1383 1384 if (ioc->sh == NULL || 1385 ((hd = shost_priv(ioc->sh)) == NULL)) 1386 return 1; 1387 1388 switch (event) { 1389 case MPI_EVENT_RESCAN: 1390 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags); 1391 if (ioc->fc_rescan_work_q) { 1392 queue_work(ioc->fc_rescan_work_q, 1393 &ioc->fc_rescan_work); 1394 } 1395 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags); 1396 break; 1397 case MPI_EVENT_LINK_STATUS_CHANGE: 1398 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags); 1399 if (ioc->fc_rescan_work_q) { 1400 queue_work(ioc->fc_rescan_work_q, 1401 &ioc->fc_lsc_work); 1402 } 1403 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags); 1404 break; 1405 default: 1406 rc = mptscsih_event_process(ioc,pEvReply); 1407 break; 1408 } 1409 return rc; 1410 } 1411 1412 static int 1413 mptfc_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) 1414 { 1415 int rc; 1416 unsigned long flags; 1417 1418 rc = mptscsih_ioc_reset(ioc,reset_phase); 1419 if ((ioc->bus_type != FC) || (!rc)) 1420 return rc; 1421 1422 1423 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1424 ": IOC %s_reset routed to FC host driver!\n",ioc->name, 1425 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : ( 1426 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post"))); 1427 1428 if (reset_phase == MPT_IOC_SETUP_RESET) { 1429 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags); 1430 if (ioc->fc_rescan_work_q) { 1431 queue_work(ioc->fc_rescan_work_q, 1432 &ioc->fc_setup_reset_work); 1433 } 1434 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags); 1435 } 1436 1437 else if (reset_phase == MPT_IOC_PRE_RESET) { 1438 } 1439 1440 else { /* MPT_IOC_POST_RESET */ 1441 mptfc_SetFcPortPage1_defaults(ioc); 1442 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags); 1443 if (ioc->fc_rescan_work_q) { 1444 queue_work(ioc->fc_rescan_work_q, 1445 &ioc->fc_rescan_work); 1446 } 1447 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags); 1448 } 1449 return 1; 1450 } 1451 1452 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1453 /** 1454 * mptfc_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer. 1455 * 1456 * Returns 0 for success, non-zero for failure. 1457 */ 1458 static int __init 1459 mptfc_init(void) 1460 { 1461 int error; 1462 1463 show_mptmod_ver(my_NAME, my_VERSION); 1464 1465 /* sanity check module parameters */ 1466 if (mptfc_dev_loss_tmo <= 0) 1467 mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO; 1468 1469 mptfc_transport_template = 1470 fc_attach_transport(&mptfc_transport_functions); 1471 1472 if (!mptfc_transport_template) 1473 return -ENODEV; 1474 1475 mptfcDoneCtx = mpt_register(mptscsih_io_done, MPTFC_DRIVER, 1476 "mptscsih_scandv_complete"); 1477 mptfcTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTFC_DRIVER, 1478 "mptscsih_scandv_complete"); 1479 mptfcInternalCtx = mpt_register(mptscsih_scandv_complete, MPTFC_DRIVER, 1480 "mptscsih_scandv_complete"); 1481 1482 mpt_event_register(mptfcDoneCtx, mptfc_event_process); 1483 mpt_reset_register(mptfcDoneCtx, mptfc_ioc_reset); 1484 1485 error = pci_register_driver(&mptfc_driver); 1486 if (error) 1487 fc_release_transport(mptfc_transport_template); 1488 1489 return error; 1490 } 1491 1492 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1493 /** 1494 * mptfc_remove - Remove fc infrastructure for devices 1495 * @pdev: Pointer to pci_dev structure 1496 * 1497 */ 1498 static void __devexit 1499 mptfc_remove(struct pci_dev *pdev) 1500 { 1501 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1502 struct mptfc_rport_info *p, *n; 1503 struct workqueue_struct *work_q; 1504 unsigned long flags; 1505 int ii; 1506 1507 /* destroy workqueue */ 1508 if ((work_q=ioc->fc_rescan_work_q)) { 1509 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags); 1510 ioc->fc_rescan_work_q = NULL; 1511 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags); 1512 destroy_workqueue(work_q); 1513 } 1514 1515 fc_remove_host(ioc->sh); 1516 1517 list_for_each_entry_safe(p, n, &ioc->fc_rports, list) { 1518 list_del(&p->list); 1519 kfree(p); 1520 } 1521 1522 for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) { 1523 if (ioc->fc_data.fc_port_page1[ii].data) { 1524 pci_free_consistent(ioc->pcidev, 1525 ioc->fc_data.fc_port_page1[ii].pg_sz, 1526 (u8 *) ioc->fc_data.fc_port_page1[ii].data, 1527 ioc->fc_data.fc_port_page1[ii].dma); 1528 ioc->fc_data.fc_port_page1[ii].data = NULL; 1529 } 1530 } 1531 1532 mptscsih_remove(pdev); 1533 } 1534 1535 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1536 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1537 /** 1538 * mptfc_exit - Unregisters MPT adapter(s) 1539 * 1540 */ 1541 static void __exit 1542 mptfc_exit(void) 1543 { 1544 pci_unregister_driver(&mptfc_driver); 1545 fc_release_transport(mptfc_transport_template); 1546 1547 mpt_reset_deregister(mptfcDoneCtx); 1548 mpt_event_deregister(mptfcDoneCtx); 1549 1550 mpt_deregister(mptfcInternalCtx); 1551 mpt_deregister(mptfcTaskCtx); 1552 mpt_deregister(mptfcDoneCtx); 1553 } 1554 1555 module_init(mptfc_init); 1556 module_exit(mptfc_exit); 1557