git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/lpfc/lpfc_attr.c

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2004-2005 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
   8  *                                                                 *
   9  * This program is free software; you can redistribute it and/or   *
  10  * modify it under the terms of version 2 of the GNU General       *
  11  * Public License as published by the Free Software Foundation.    *
  12  * This program is distributed in the hope that it will be useful. *
  13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  18  * more details, a copy of which can be found in the file COPYING  *
  19  * included with this package.                                     *
  20  *******************************************************************/
  21
  22 #include <linux/ctype.h>
  23 #include <linux/pci.h>
  24 #include <linux/interrupt.h>
  25
  26 #include <scsi/scsi_device.h>
  27 #include <scsi/scsi_host.h>
  28 #include <scsi/scsi_tcq.h>
  29 #include <scsi/scsi_transport_fc.h>
  30
  31 #include "lpfc_hw.h"
  32 #include "lpfc_sli.h"
  33 #include "lpfc_disc.h"
  34 #include "lpfc_scsi.h"
  35 #include "lpfc.h"
  36 #include "lpfc_logmsg.h"
  37 #include "lpfc_version.h"
  38 #include "lpfc_compat.h"
  39 #include "lpfc_crtn.h"
  40
  41
  42 static void
  43 lpfc_jedec_to_ascii(int incr, char hdw[])
  44 {
  45         int i, j;
  46         for (i = 0; i < 8; i++) {
  47                 j = (incr & 0xf);
  48                 if (j <= 9)
  49                         hdw[7 - i] = 0x30 +  j;
  50                  else
  51                         hdw[7 - i] = 0x61 + j - 10;
  52                 incr = (incr >> 4);
  53         }
  54         hdw[8] = 0;
  55         return;
  56 }
  57
  58 static ssize_t
  59 lpfc_drvr_version_show(struct class_device *cdev, char *buf)
  60 {
  61         return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
  62 }
  63
  64 static ssize_t
  65 management_version_show(struct class_device *cdev, char *buf)
  66 {
  67         return snprintf(buf, PAGE_SIZE, DFC_API_VERSION "\n");
  68 }
  69
  70 static ssize_t
  71 lpfc_info_show(struct class_device *cdev, char *buf)
  72 {
  73         struct Scsi_Host *host = class_to_shost(cdev);
  74         return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
  75 }
  76
  77 static ssize_t
  78 lpfc_serialnum_show(struct class_device *cdev, char *buf)
  79 {
  80         struct Scsi_Host *host = class_to_shost(cdev);
  81         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
  82         return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber);
  83 }
  84
  85 static ssize_t
  86 lpfc_modeldesc_show(struct class_device *cdev, char *buf)
  87 {
  88         struct Scsi_Host *host = class_to_shost(cdev);
  89         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
  90         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc);
  91 }
  92
  93 static ssize_t
  94 lpfc_modelname_show(struct class_device *cdev, char *buf)
  95 {
  96         struct Scsi_Host *host = class_to_shost(cdev);
  97         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
  98         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName);
  99 }
 100
 101 static ssize_t
 102 lpfc_programtype_show(struct class_device *cdev, char *buf)
 103 {
 104         struct Scsi_Host *host = class_to_shost(cdev);
 105         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 106         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType);
 107 }
 108
 109 static ssize_t
 110 lpfc_portnum_show(struct class_device *cdev, char *buf)
 111 {
 112         struct Scsi_Host *host = class_to_shost(cdev);
 113         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 114         return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port);
 115 }
 116
 117 static ssize_t
 118 lpfc_fwrev_show(struct class_device *cdev, char *buf)
 119 {
 120         struct Scsi_Host *host = class_to_shost(cdev);
 121         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 122         char fwrev[32];
 123         lpfc_decode_firmware_rev(phba, fwrev, 1);
 124         return snprintf(buf, PAGE_SIZE, "%s\n",fwrev);
 125 }
 126
 127 static ssize_t
 128 lpfc_hdw_show(struct class_device *cdev, char *buf)
 129 {
 130         char hdw[9];
 131         struct Scsi_Host *host = class_to_shost(cdev);
 132         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 133         lpfc_vpd_t *vp = &phba->vpd;
 134         lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
 135         return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
 136 }
 137 static ssize_t
 138 lpfc_option_rom_version_show(struct class_device *cdev, char *buf)
 139 {
 140         struct Scsi_Host *host = class_to_shost(cdev);
 141         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 142         return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
 143 }
 144 static ssize_t
 145 lpfc_state_show(struct class_device *cdev, char *buf)
 146 {
 147         struct Scsi_Host *host = class_to_shost(cdev);
 148         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 149         int len = 0;
 150         switch (phba->hba_state) {
 151         case LPFC_INIT_START:
 152         case LPFC_INIT_MBX_CMDS:
 153         case LPFC_LINK_DOWN:
 154                 len += snprintf(buf + len, PAGE_SIZE-len, "Link Down\n");
 155                 break;
 156         case LPFC_LINK_UP:
 157         case LPFC_LOCAL_CFG_LINK:
 158                 len += snprintf(buf + len, PAGE_SIZE-len, "Link Up\n");
 159                 break;
 160         case LPFC_FLOGI:
 161         case LPFC_FABRIC_CFG_LINK:
 162         case LPFC_NS_REG:
 163         case LPFC_NS_QRY:
 164         case LPFC_BUILD_DISC_LIST:
 165         case LPFC_DISC_AUTH:
 166         case LPFC_CLEAR_LA:
 167                 len += snprintf(buf + len, PAGE_SIZE-len,
 168                                 "Link Up - Discovery\n");
 169                 break;
 170         case LPFC_HBA_READY:
 171                 len += snprintf(buf + len, PAGE_SIZE-len,
 172                                 "Link Up - Ready:\n");
 173                 if (phba->fc_topology == TOPOLOGY_LOOP) {
 174                         if (phba->fc_flag & FC_PUBLIC_LOOP)
 175                                 len += snprintf(buf + len, PAGE_SIZE-len,
 176                                                 "   Public Loop\n");
 177                         else
 178                                 len += snprintf(buf + len, PAGE_SIZE-len,
 179                                                 "   Private Loop\n");
 180                 } else {
 181                         if (phba->fc_flag & FC_FABRIC)
 182                                 len += snprintf(buf + len, PAGE_SIZE-len,
 183                                                 "   Fabric\n");
 184                         else
 185                                 len += snprintf(buf + len, PAGE_SIZE-len,
 186                                                 "   Point-2-Point\n");
 187                 }
 188         }
 189         return len;
 190 }
 191
 192 static ssize_t
 193 lpfc_num_discovered_ports_show(struct class_device *cdev, char *buf)
 194 {
 195         struct Scsi_Host *host = class_to_shost(cdev);
 196         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 197         return snprintf(buf, PAGE_SIZE, "%d\n", phba->fc_map_cnt +
 198                                                         phba->fc_unmap_cnt);
 199 }
 200
 201
 202 static ssize_t
 203 lpfc_issue_lip (struct class_device *cdev, const char *buf, size_t count)
 204 {
 205         struct Scsi_Host *host = class_to_shost(cdev);
 206         struct lpfc_hba *phba = (struct lpfc_hba *) host->hostdata[0];
 207         int val = 0;
 208         LPFC_MBOXQ_t *pmboxq;
 209         int mbxstatus = MBXERR_ERROR;
 210
 211         if ((sscanf(buf, "%d", &val) != 1) ||
 212             (val != 1))
 213                 return -EINVAL;
 214
 215         if ((phba->fc_flag & FC_OFFLINE_MODE) ||
 216             (phba->hba_state != LPFC_HBA_READY))
 217                 return -EPERM;
 218
 219         pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
 220
 221         if (!pmboxq)
 222                 return -ENOMEM;
 223
 224         memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
 225         lpfc_init_link(phba, pmboxq, phba->cfg_topology, phba->cfg_link_speed);
 226         mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
 227
 228         if (mbxstatus == MBX_TIMEOUT)
 229                 pmboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 230         else
 231                 mempool_free( pmboxq, phba->mbox_mem_pool);
 232
 233         if (mbxstatus == MBXERR_ERROR)
 234                 return -EIO;
 235
 236         return strlen(buf);
 237 }
 238
 239 static ssize_t
 240 lpfc_nport_evt_cnt_show(struct class_device *cdev, char *buf)
 241 {
 242         struct Scsi_Host *host = class_to_shost(cdev);
 243         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 244         return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
 245 }
 246
 247 static ssize_t
 248 lpfc_board_online_show(struct class_device *cdev, char *buf)
 249 {
 250         struct Scsi_Host *host = class_to_shost(cdev);
 251         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 252
 253         if (!phba) return 0;
 254
 255         if (phba->fc_flag & FC_OFFLINE_MODE)
 256                 return snprintf(buf, PAGE_SIZE, "0\n");
 257         else
 258                 return snprintf(buf, PAGE_SIZE, "1\n");
 259 }
 260
 261 static ssize_t
 262 lpfc_board_online_store(struct class_device *cdev, const char *buf,
 263                                                                 size_t count)
 264 {
 265         struct Scsi_Host *host = class_to_shost(cdev);
 266         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 267         struct completion online_compl;
 268         int val=0, status=0;
 269
 270         if (sscanf(buf, "%d", &val) != 1)
 271                 return 0;
 272
 273         init_completion(&online_compl);
 274
 275         if (val)
 276                 lpfc_workq_post_event(phba, &status, &online_compl,
 277                                                         LPFC_EVT_ONLINE);
 278         else
 279                 lpfc_workq_post_event(phba, &status, &online_compl,
 280                                                         LPFC_EVT_OFFLINE);
 281         wait_for_completion(&online_compl);
 282         if (!status)
 283                 return strlen(buf);
 284         else
 285                 return 0;
 286 }
 287
 288
 289 #define lpfc_param_show(attr)   \
 290 static ssize_t \
 291 lpfc_##attr##_show(struct class_device *cdev, char *buf) \
 292 { \
 293         struct Scsi_Host *host = class_to_shost(cdev);\
 294         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];\
 295         int val = 0;\
 296         if (phba){\
 297                 val = phba->cfg_##attr;\
 298                 return snprintf(buf, PAGE_SIZE, "%d\n",\
 299                                 phba->cfg_##attr);\
 300         }\
 301         return 0;\
 302 }
 303
 304 #define lpfc_param_store(attr, minval, maxval)  \
 305 static ssize_t \
 306 lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \
 307 { \
 308         struct Scsi_Host *host = class_to_shost(cdev);\
 309         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];\
 310         int val = 0;\
 311         if (!isdigit(buf[0]))\
 312                 return -EINVAL;\
 313         if (sscanf(buf, "0x%x", &val) != 1)\
 314                 if (sscanf(buf, "%d", &val) != 1)\
 315                         return -EINVAL;\
 316         if (phba){\
 317                 if (val >= minval && val <= maxval) {\
 318                         phba->cfg_##attr = val;\
 319                         return strlen(buf);\
 320                 }\
 321         }\
 322         return 0;\
 323 }
 324
 325 #define LPFC_ATTR_R_NOINIT(name, desc) \
 326 extern int lpfc_##name;\
 327 module_param(lpfc_##name, int, 0);\
 328 MODULE_PARM_DESC(lpfc_##name, desc);\
 329 lpfc_param_show(name)\
 330 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 331
 332 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
 333 static int lpfc_##name = defval;\
 334 module_param(lpfc_##name, int, 0);\
 335 MODULE_PARM_DESC(lpfc_##name, desc);\
 336 lpfc_param_show(name)\
 337 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 338
 339 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
 340 static int lpfc_##name = defval;\
 341 module_param(lpfc_##name, int, 0);\
 342 MODULE_PARM_DESC(lpfc_##name, desc);\
 343 lpfc_param_show(name)\
 344 lpfc_param_store(name, minval, maxval)\
 345 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
 346                          lpfc_##name##_show, lpfc_##name##_store)
 347
 348 static CLASS_DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
 349 static CLASS_DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
 350 static CLASS_DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
 351 static CLASS_DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
 352 static CLASS_DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
 353 static CLASS_DEVICE_ATTR(portnum, S_IRUGO, lpfc_portnum_show, NULL);
 354 static CLASS_DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
 355 static CLASS_DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
 356 static CLASS_DEVICE_ATTR(state, S_IRUGO, lpfc_state_show, NULL);
 357 static CLASS_DEVICE_ATTR(option_rom_version, S_IRUGO,
 358                                         lpfc_option_rom_version_show, NULL);
 359 static CLASS_DEVICE_ATTR(num_discovered_ports, S_IRUGO,
 360                                         lpfc_num_discovered_ports_show, NULL);
 361 static CLASS_DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
 362 static CLASS_DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show,
 363                          NULL);
 364 static CLASS_DEVICE_ATTR(management_version, S_IRUGO, management_version_show,
 365                          NULL);
 366 static CLASS_DEVICE_ATTR(issue_lip, S_IWUSR, NULL, lpfc_issue_lip);
 367 static CLASS_DEVICE_ATTR(board_online, S_IRUGO | S_IWUSR,
 368                          lpfc_board_online_show, lpfc_board_online_store);
 369
 370
 371 /*
 372 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
 373 # deluged with LOTS of information.
 374 # You can set a bit mask to record specific types of verbose messages:
 375 #
 376 # LOG_ELS                       0x1        ELS events
 377 # LOG_DISCOVERY                 0x2        Link discovery events
 378 # LOG_MBOX                      0x4        Mailbox events
 379 # LOG_INIT                      0x8        Initialization events
 380 # LOG_LINK_EVENT                0x10       Link events
 381 # LOG_IP                        0x20       IP traffic history
 382 # LOG_FCP                       0x40       FCP traffic history
 383 # LOG_NODE                      0x80       Node table events
 384 # LOG_MISC                      0x400      Miscellaneous events
 385 # LOG_SLI                       0x800      SLI events
 386 # LOG_CHK_COND                  0x1000     FCP Check condition flag
 387 # LOG_LIBDFC                    0x2000     LIBDFC events
 388 # LOG_ALL_MSG                   0xffff     LOG all messages
 389 */
 390 LPFC_ATTR_RW(log_verbose, 0x0, 0x0, 0xffff, "Verbose logging bit-mask");
 391
 392 /*
 393 # lun_queue_depth:  This parameter is used to limit the number of outstanding
 394 # commands per FCP LUN. Value range is [1,128]. Default value is 30.
 395 */
 396 LPFC_ATTR_R(lun_queue_depth, 30, 1, 128,
 397             "Max number of FCP commands we can queue to a specific LUN");
 398
 399 /*
 400 # Some disk devices have a "select ID" or "select Target" capability.
 401 # From a protocol standpoint "select ID" usually means select the
 402 # Fibre channel "ALPA".  In the FC-AL Profile there is an "informative
 403 # annex" which contains a table that maps a "select ID" (a number
 404 # between 0 and 7F) to an ALPA.  By default, for compatibility with
 405 # older drivers, the lpfc driver scans this table from low ALPA to high
 406 # ALPA.
 407 #
 408 # Turning on the scan-down variable (on  = 1, off = 0) will
 409 # cause the lpfc driver to use an inverted table, effectively
 410 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
 411 #
 412 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
 413 # and will not work across a fabric. Also this parameter will take
 414 # effect only in the case when ALPA map is not available.)
 415 */
 416 LPFC_ATTR_R(scan_down, 1, 0, 1,
 417              "Start scanning for devices from highest ALPA to lowest");
 418
 419 /*
 420 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
 421 # until the timer expires. Value range is [0,255]. Default value is 20.
 422 # NOTE: this MUST be less then the SCSI Layer command timeout - 1.
 423 */
 424 LPFC_ATTR_RW(nodev_tmo, 30, 0, 255,
 425              "Seconds driver will hold I/O waiting for a device to come back");
 426
 427 /*
 428 # lpfc_topology:  link topology for init link
 429 #            0x0  = attempt loop mode then point-to-point
 430 #            0x02 = attempt point-to-point mode only
 431 #            0x04 = attempt loop mode only
 432 #            0x06 = attempt point-to-point mode then loop
 433 # Set point-to-point mode if you want to run as an N_Port.
 434 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
 435 # Default value is 0.
 436 */
 437 LPFC_ATTR_R(topology, 0, 0, 6, "Select Fibre Channel topology");
 438
 439 /*
 440 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
 441 # connection.
 442 #       0  = auto select (default)
 443 #       1  = 1 Gigabaud
 444 #       2  = 2 Gigabaud
 445 #       4  = 4 Gigabaud
 446 # Value range is [0,4]. Default value is 0.
 447 */
 448 LPFC_ATTR_R(link_speed, 0, 0, 4, "Select link speed");
 449
 450 /*
 451 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
 452 # Value range is [2,3]. Default value is 3.
 453 */
 454 LPFC_ATTR_R(fcp_class, 3, 2, 3,
 455              "Select Fibre Channel class of service for FCP sequences");
 456
 457 /*
 458 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
 459 # is [0,1]. Default value is 0.
 460 */
 461 LPFC_ATTR_RW(use_adisc, 0, 0, 1,
 462              "Use ADISC on rediscovery to authenticate FCP devices");
 463
 464 /*
 465 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
 466 # range is [0,1]. Default value is 0.
 467 */
 468 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
 469
 470 /*
 471 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
 472 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
 473 # value [0,63]. cr_count can take value [0,255]. Default value of cr_delay
 474 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
 475 # cr_delay is set to 0.
 476 */
 477 static int lpfc_cr_delay = 0;
 478 module_param(lpfc_cr_delay, int , 0);
 479 MODULE_PARM_DESC(lpfc_cr_delay, "A count of milliseconds after which an "
 480                 "interrupt response is generated");
 481
 482 static int lpfc_cr_count = 1;
 483 module_param(lpfc_cr_count, int, 0);
 484 MODULE_PARM_DESC(lpfc_cr_count, "A count of I/O completions after which an "
 485                 "interrupt response is generated");
 486
 487 /*
 488 # lpfc_fdmi_on: controls FDMI support.
 489 #       0 = no FDMI support
 490 #       1 = support FDMI without attribute of hostname
 491 #       2 = support FDMI with attribute of hostname
 492 # Value range [0,2]. Default value is 0.
 493 */
 494 LPFC_ATTR_RW(fdmi_on, 0, 0, 2, "Enable FDMI support");
 495
 496 /*
 497 # Specifies the maximum number of ELS cmds we can have outstanding (for
 498 # discovery). Value range is [1,64]. Default value = 32.
 499 */
 500 static int lpfc_discovery_threads = 32;
 501 module_param(lpfc_discovery_threads, int, 0);
 502 MODULE_PARM_DESC(lpfc_discovery_threads, "Maximum number of ELS commands "
 503                  "during discovery");
 504
 505 /*
 506 # lpfc_max_luns: maximum number of LUNs per target driver will support
 507 # Value range is [1,32768]. Default value is 256.
 508 # NOTE: The SCSI layer will scan each target for this many luns
 509 */
 510 LPFC_ATTR_R(max_luns, 256, 1, 32768,
 511              "Maximum number of LUNs per target driver will support");
 512
 513 struct class_device_attribute *lpfc_host_attrs[] = {
 514         &class_device_attr_info,
 515         &class_device_attr_serialnum,
 516         &class_device_attr_modeldesc,
 517         &class_device_attr_modelname,
 518         &class_device_attr_programtype,
 519         &class_device_attr_portnum,
 520         &class_device_attr_fwrev,
 521         &class_device_attr_hdw,
 522         &class_device_attr_option_rom_version,
 523         &class_device_attr_state,
 524         &class_device_attr_num_discovered_ports,
 525         &class_device_attr_lpfc_drvr_version,
 526         &class_device_attr_lpfc_log_verbose,
 527         &class_device_attr_lpfc_lun_queue_depth,
 528         &class_device_attr_lpfc_nodev_tmo,
 529         &class_device_attr_lpfc_fcp_class,
 530         &class_device_attr_lpfc_use_adisc,
 531         &class_device_attr_lpfc_ack0,
 532         &class_device_attr_lpfc_topology,
 533         &class_device_attr_lpfc_scan_down,
 534         &class_device_attr_lpfc_link_speed,
 535         &class_device_attr_lpfc_fdmi_on,
 536         &class_device_attr_lpfc_max_luns,
 537         &class_device_attr_nport_evt_cnt,
 538         &class_device_attr_management_version,
 539         &class_device_attr_issue_lip,
 540         &class_device_attr_board_online,
 541         NULL,
 542 };
 543
 544 static ssize_t
 545 sysfs_ctlreg_write(struct kobject *kobj, char *buf, loff_t off, size_t count)
 546 {
 547         size_t buf_off;
 548         struct Scsi_Host *host = class_to_shost(container_of(kobj,
 549                                              struct class_device, kobj));
 550         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 551
 552         if ((off + count) > FF_REG_AREA_SIZE)
 553                 return -ERANGE;
 554
 555         if (count == 0) return 0;
 556
 557         if (off % 4 || count % 4 || (unsigned long)buf % 4)
 558                 return -EINVAL;
 559
 560         spin_lock_irq(phba->host->host_lock);
 561
 562         if (!(phba->fc_flag & FC_OFFLINE_MODE)) {
 563                 spin_unlock_irq(phba->host->host_lock);
 564                 return -EPERM;
 565         }
 566
 567         for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t))
 568                 writel(*((uint32_t *)(buf + buf_off)),
 569                        phba->ctrl_regs_memmap_p + off + buf_off);
 570
 571         spin_unlock_irq(phba->host->host_lock);
 572
 573         return count;
 574 }
 575
 576 static ssize_t
 577 sysfs_ctlreg_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
 578 {
 579         size_t buf_off;
 580         uint32_t * tmp_ptr;
 581         struct Scsi_Host *host = class_to_shost(container_of(kobj,
 582                                              struct class_device, kobj));
 583         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 584
 585         if (off > FF_REG_AREA_SIZE)
 586                 return -ERANGE;
 587
 588         if ((off + count) > FF_REG_AREA_SIZE)
 589                 count = FF_REG_AREA_SIZE - off;
 590
 591         if (count == 0) return 0;
 592
 593         if (off % 4 || count % 4 || (unsigned long)buf % 4)
 594                 return -EINVAL;
 595
 596         spin_lock_irq(phba->host->host_lock);
 597
 598         for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
 599                 tmp_ptr = (uint32_t *)(buf + buf_off);
 600                 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
 601         }
 602
 603         spin_unlock_irq(phba->host->host_lock);
 604
 605         return count;
 606 }
 607
 608 static struct bin_attribute sysfs_ctlreg_attr = {
 609         .attr = {
 610                 .name = "ctlreg",
 611                 .mode = S_IRUSR | S_IWUSR,
 612                 .owner = THIS_MODULE,
 613         },
 614         .size = 256,
 615         .read = sysfs_ctlreg_read,
 616         .write = sysfs_ctlreg_write,
 617 };
 618
 619
 620 static void
 621 sysfs_mbox_idle (struct lpfc_hba * phba)
 622 {
 623         phba->sysfs_mbox.state = SMBOX_IDLE;
 624         phba->sysfs_mbox.offset = 0;
 625
 626         if (phba->sysfs_mbox.mbox) {
 627                 mempool_free(phba->sysfs_mbox.mbox,
 628                              phba->mbox_mem_pool);
 629                 phba->sysfs_mbox.mbox = NULL;
 630         }
 631 }
 632
 633 static ssize_t
 634 sysfs_mbox_write(struct kobject *kobj, char *buf, loff_t off, size_t count)
 635 {
 636         struct Scsi_Host * host =
 637                 class_to_shost(container_of(kobj, struct class_device, kobj));
 638         struct lpfc_hba * phba = (struct lpfc_hba*)host->hostdata[0];
 639         struct lpfcMboxq * mbox = NULL;
 640
 641         if ((count + off) > MAILBOX_CMD_SIZE)
 642                 return -ERANGE;
 643
 644         if (off % 4 ||  count % 4 || (unsigned long)buf % 4)
 645                 return -EINVAL;
 646
 647         if (count == 0)
 648                 return 0;
 649
 650         if (off == 0) {
 651                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 652                 if (!mbox)
 653                         return -ENOMEM;
 654
 655         }
 656
 657         spin_lock_irq(host->host_lock);
 658
 659         if (off == 0) {
 660                 if (phba->sysfs_mbox.mbox)
 661                         mempool_free(mbox, phba->mbox_mem_pool);
 662                 else
 663                         phba->sysfs_mbox.mbox = mbox;
 664                 phba->sysfs_mbox.state = SMBOX_WRITING;
 665         } else {
 666                 if (phba->sysfs_mbox.state  != SMBOX_WRITING ||
 667                     phba->sysfs_mbox.offset != off           ||
 668                     phba->sysfs_mbox.mbox   == NULL ) {
 669                         sysfs_mbox_idle(phba);
 670                         spin_unlock_irq(host->host_lock);
 671                         return -EINVAL;
 672                 }
 673         }
 674
 675         memcpy((uint8_t *) & phba->sysfs_mbox.mbox->mb + off,
 676                buf, count);
 677
 678         phba->sysfs_mbox.offset = off + count;
 679
 680         spin_unlock_irq(host->host_lock);
 681
 682         return count;
 683 }
 684
 685 static ssize_t
 686 sysfs_mbox_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
 687 {
 688         struct Scsi_Host *host =
 689                 class_to_shost(container_of(kobj, struct class_device,
 690                                             kobj));
 691         struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0];
 692         int rc;
 693
 694         if (off > sizeof(MAILBOX_t))
 695                 return -ERANGE;
 696
 697         if ((count + off) > sizeof(MAILBOX_t))
 698                 count = sizeof(MAILBOX_t) - off;
 699
 700         if (off % 4 ||  count % 4 || (unsigned long)buf % 4)
 701                 return -EINVAL;
 702
 703         if (off && count == 0)
 704                 return 0;
 705
 706         spin_lock_irq(phba->host->host_lock);
 707
 708         if (off == 0 &&
 709             phba->sysfs_mbox.state  == SMBOX_WRITING &&
 710             phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) {
 711
 712                 switch (phba->sysfs_mbox.mbox->mb.mbxCommand) {
 713                         /* Offline only */
 714                 case MBX_WRITE_NV:
 715                 case MBX_INIT_LINK:
 716                 case MBX_DOWN_LINK:
 717                 case MBX_CONFIG_LINK:
 718                 case MBX_CONFIG_RING:
 719                 case MBX_RESET_RING:
 720                 case MBX_UNREG_LOGIN:
 721                 case MBX_CLEAR_LA:
 722                 case MBX_DUMP_CONTEXT:
 723                 case MBX_RUN_DIAGS:
 724                 case MBX_RESTART:
 725                 case MBX_FLASH_WR_ULA:
 726                 case MBX_SET_MASK:
 727                 case MBX_SET_SLIM:
 728                 case MBX_SET_DEBUG:
 729                         if (!(phba->fc_flag & FC_OFFLINE_MODE)) {
 730                                 printk(KERN_WARNING "mbox_read:Command 0x%x "
 731                                        "is illegal in on-line state\n",
 732                                        phba->sysfs_mbox.mbox->mb.mbxCommand);
 733                                 sysfs_mbox_idle(phba);
 734                                 spin_unlock_irq(phba->host->host_lock);
 735                                 return -EPERM;
 736                         }
 737                 case MBX_LOAD_SM:
 738                 case MBX_READ_NV:
 739                 case MBX_READ_CONFIG:
 740                 case MBX_READ_RCONFIG:
 741                 case MBX_READ_STATUS:
 742                 case MBX_READ_XRI:
 743                 case MBX_READ_REV:
 744                 case MBX_READ_LNK_STAT:
 745                 case MBX_DUMP_MEMORY:
 746                 case MBX_DOWN_LOAD:
 747                 case MBX_UPDATE_CFG:
 748                 case MBX_LOAD_AREA:
 749                 case MBX_LOAD_EXP_ROM:
 750                         break;
 751                 case MBX_READ_SPARM64:
 752                 case MBX_READ_LA:
 753                 case MBX_READ_LA64:
 754                 case MBX_REG_LOGIN:
 755                 case MBX_REG_LOGIN64:
 756                 case MBX_CONFIG_PORT:
 757                 case MBX_RUN_BIU_DIAG:
 758                         printk(KERN_WARNING "mbox_read: Illegal Command 0x%x\n",
 759                                phba->sysfs_mbox.mbox->mb.mbxCommand);
 760                         sysfs_mbox_idle(phba);
 761                         spin_unlock_irq(phba->host->host_lock);
 762                         return -EPERM;
 763                 default:
 764                         printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n",
 765                                phba->sysfs_mbox.mbox->mb.mbxCommand);
 766                         sysfs_mbox_idle(phba);
 767                         spin_unlock_irq(phba->host->host_lock);
 768                         return -EPERM;
 769                 }
 770
 771                 if ((phba->fc_flag & FC_OFFLINE_MODE) ||
 772                     (!(phba->sli.sli_flag & LPFC_SLI2_ACTIVE))){
 773
 774                         spin_unlock_irq(phba->host->host_lock);
 775                         rc = lpfc_sli_issue_mbox (phba,
 776                                                   phba->sysfs_mbox.mbox,
 777                                                   MBX_POLL);
 778                         spin_lock_irq(phba->host->host_lock);
 779
 780                 } else {
 781                         spin_unlock_irq(phba->host->host_lock);
 782                         rc = lpfc_sli_issue_mbox_wait (phba,
 783                                                        phba->sysfs_mbox.mbox,
 784                                                        phba->fc_ratov * 2);
 785                         spin_lock_irq(phba->host->host_lock);
 786                 }
 787
 788                 if (rc != MBX_SUCCESS) {
 789                         sysfs_mbox_idle(phba);
 790                         spin_unlock_irq(host->host_lock);
 791                         return -ENODEV;
 792                 }
 793                 phba->sysfs_mbox.state = SMBOX_READING;
 794         }
 795         else if (phba->sysfs_mbox.offset != off ||
 796                  phba->sysfs_mbox.state  != SMBOX_READING) {
 797                 printk(KERN_WARNING  "mbox_read: Bad State\n");
 798                 sysfs_mbox_idle(phba);
 799                 spin_unlock_irq(host->host_lock);
 800                 return -EINVAL;
 801         }
 802
 803         memcpy(buf, (uint8_t *) & phba->sysfs_mbox.mbox->mb + off, count);
 804
 805         phba->sysfs_mbox.offset = off + count;
 806
 807         if (phba->sysfs_mbox.offset == sizeof(MAILBOX_t))
 808                 sysfs_mbox_idle(phba);
 809
 810         spin_unlock_irq(phba->host->host_lock);
 811
 812         return count;
 813 }
 814
 815 static struct bin_attribute sysfs_mbox_attr = {
 816         .attr = {
 817                 .name = "mbox",
 818                 .mode = S_IRUSR | S_IWUSR,
 819                 .owner = THIS_MODULE,
 820         },
 821         .size = sizeof(MAILBOX_t),
 822         .read = sysfs_mbox_read,
 823         .write = sysfs_mbox_write,
 824 };
 825
 826 int
 827 lpfc_alloc_sysfs_attr(struct lpfc_hba *phba)
 828 {
 829         struct Scsi_Host *host = phba->host;
 830         int error;
 831
 832         error = sysfs_create_bin_file(&host->shost_classdev.kobj,
 833                                                         &sysfs_ctlreg_attr);
 834         if (error)
 835                 goto out;
 836
 837         error = sysfs_create_bin_file(&host->shost_classdev.kobj,
 838                                                         &sysfs_mbox_attr);
 839         if (error)
 840                 goto out_remove_ctlreg_attr;
 841
 842         return 0;
 843 out_remove_ctlreg_attr:
 844         sysfs_remove_bin_file(&host->shost_classdev.kobj, &sysfs_ctlreg_attr);
 845 out:
 846         return error;
 847 }
 848
 849 void
 850 lpfc_free_sysfs_attr(struct lpfc_hba *phba)
 851 {
 852         struct Scsi_Host *host = phba->host;
 853
 854         sysfs_remove_bin_file(&host->shost_classdev.kobj, &sysfs_mbox_attr);
 855         sysfs_remove_bin_file(&host->shost_classdev.kobj, &sysfs_ctlreg_attr);
 856 }
 857
 858
 859 /*
 860  * Dynamic FC Host Attributes Support
 861  */
 862
 863 static void
 864 lpfc_get_host_port_id(struct Scsi_Host *shost)
 865 {
 866         struct lpfc_hba *phba = (struct lpfc_hba*)shost->hostdata[0];
 867         /* note: fc_myDID already in cpu endianness */
 868         fc_host_port_id(shost) = phba->fc_myDID;
 869 }
 870
 871 static void
 872 lpfc_get_host_port_type(struct Scsi_Host *shost)
 873 {
 874         struct lpfc_hba *phba = (struct lpfc_hba*)shost->hostdata[0];
 875
 876         spin_lock_irq(shost->host_lock);
 877
 878         if (phba->hba_state == LPFC_HBA_READY) {
 879                 if (phba->fc_topology == TOPOLOGY_LOOP) {
 880                         if (phba->fc_flag & FC_PUBLIC_LOOP)
 881                                 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
 882                         else
 883                                 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
 884                 } else {
 885                         if (phba->fc_flag & FC_FABRIC)
 886                                 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
 887                         else
 888                                 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
 889                 }
 890         } else
 891                 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
 892
 893         spin_unlock_irq(shost->host_lock);
 894 }
 895
 896 static void
 897 lpfc_get_host_port_state(struct Scsi_Host *shost)
 898 {
 899         struct lpfc_hba *phba = (struct lpfc_hba*)shost->hostdata[0];
 900
 901         spin_lock_irq(shost->host_lock);
 902
 903         if (phba->fc_flag & FC_OFFLINE_MODE)
 904                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
 905         else {
 906                 switch (phba->hba_state) {
 907                 case LPFC_INIT_START:
 908                 case LPFC_INIT_MBX_CMDS:
 909                 case LPFC_LINK_DOWN:
 910                         fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
 911                         break;
 912                 case LPFC_LINK_UP:
 913                 case LPFC_LOCAL_CFG_LINK:
 914                 case LPFC_FLOGI:
 915                 case LPFC_FABRIC_CFG_LINK:
 916                 case LPFC_NS_REG:
 917                 case LPFC_NS_QRY:
 918                 case LPFC_BUILD_DISC_LIST:
 919                 case LPFC_DISC_AUTH:
 920                 case LPFC_CLEAR_LA:
 921                 case LPFC_HBA_READY:
 922                         /* Links up, beyond this port_type reports state */
 923                         fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
 924                         break;
 925                 case LPFC_HBA_ERROR:
 926                         fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
 927                         break;
 928                 default:
 929                         fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
 930                         break;
 931                 }
 932         }
 933
 934         spin_unlock_irq(shost->host_lock);
 935 }
 936
 937 static void
 938 lpfc_get_host_speed(struct Scsi_Host *shost)
 939 {
 940         struct lpfc_hba *phba = (struct lpfc_hba*)shost->hostdata[0];
 941
 942         spin_lock_irq(shost->host_lock);
 943
 944         if (phba->hba_state == LPFC_HBA_READY) {
 945                 switch(phba->fc_linkspeed) {
 946                         case LA_1GHZ_LINK:
 947                                 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
 948                         break;
 949                         case LA_2GHZ_LINK:
 950                                 fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
 951                         break;
 952                         case LA_4GHZ_LINK:
 953                                 fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
 954                         break;
 955                         default:
 956                                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
 957                         break;
 958                 }
 959         }
 960
 961         spin_unlock_irq(shost->host_lock);
 962 }
 963
 964 static void
 965 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
 966 {
 967         struct lpfc_hba *phba = (struct lpfc_hba*)shost->hostdata[0];
 968         u64 nodename;
 969
 970         spin_lock_irq(shost->host_lock);
 971
 972         if ((phba->fc_flag & FC_FABRIC) ||
 973             ((phba->fc_topology == TOPOLOGY_LOOP) &&
 974              (phba->fc_flag & FC_PUBLIC_LOOP)))
 975                 memcpy(&nodename, &phba->fc_fabparam.nodeName, sizeof(u64));
 976         else
 977                 /* fabric is local port if there is no F/FL_Port */
 978                 memcpy(&nodename, &phba->fc_nodename, sizeof(u64));
 979
 980         spin_unlock_irq(shost->host_lock);
 981
 982         fc_host_fabric_name(shost) = be64_to_cpu(nodename);
 983 }
 984
 985
 986 static struct fc_host_statistics *
 987 lpfc_get_stats(struct Scsi_Host *shost)
 988 {
 989         struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata[0];
 990         struct lpfc_sli *psli = &phba->sli;
 991         struct fc_host_statistics *hs =
 992                         (struct fc_host_statistics *)phba->link_stats;
 993         LPFC_MBOXQ_t *pmboxq;
 994         MAILBOX_t *pmb;
 995         int rc=0;
 996
 997         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 998         if (!pmboxq)
 999                 return NULL;
1000         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1001
1002         pmb = &pmboxq->mb;
1003         pmb->mbxCommand = MBX_READ_STATUS;
1004         pmb->mbxOwner = OWN_HOST;
1005         pmboxq->context1 = NULL;
1006
1007         if ((phba->fc_flag & FC_OFFLINE_MODE) ||
1008             (!(psli->sli_flag & LPFC_SLI2_ACTIVE))){
1009                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
1010         } else
1011                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
1012
1013         if (rc != MBX_SUCCESS) {
1014                 if (pmboxq) {
1015                         if (rc == MBX_TIMEOUT)
1016                                 pmboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
1017                         else
1018                                 mempool_free( pmboxq, phba->mbox_mem_pool);
1019                 }
1020                 return NULL;
1021         }
1022
1023         hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
1024         hs->tx_words = (pmb->un.varRdStatus.xmitByteCnt * 256);
1025         hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
1026         hs->rx_words = (pmb->un.varRdStatus.rcvByteCnt * 256);
1027
1028         memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1029         pmb->mbxCommand = MBX_READ_LNK_STAT;
1030         pmb->mbxOwner = OWN_HOST;
1031         pmboxq->context1 = NULL;
1032
1033         if ((phba->fc_flag & FC_OFFLINE_MODE) ||
1034             (!(psli->sli_flag & LPFC_SLI2_ACTIVE))) {
1035                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
1036         } else
1037                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
1038
1039         if (rc != MBX_SUCCESS) {
1040                 if (pmboxq) {
1041                         if (rc == MBX_TIMEOUT)
1042                                 pmboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
1043                         else
1044                                 mempool_free( pmboxq, phba->mbox_mem_pool);
1045                 }
1046                 return NULL;
1047         }
1048
1049         hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
1050         hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
1051         hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
1052         hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
1053         hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
1054         hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
1055         hs->error_frames = pmb->un.varRdLnk.crcCnt;
1056
1057         if (phba->fc_topology == TOPOLOGY_LOOP) {
1058                 hs->lip_count = (phba->fc_eventTag >> 1);
1059                 hs->nos_count = -1;
1060         } else {
1061                 hs->lip_count = -1;
1062                 hs->nos_count = (phba->fc_eventTag >> 1);
1063         }
1064
1065         hs->dumped_frames = -1;
1066
1067 /* FIX ME */
1068         /*hs->SecondsSinceLastReset = (jiffies - lpfc_loadtime) / HZ;*/
1069
1070         return hs;
1071 }
1072
1073
1074 /*
1075  * The LPFC driver treats linkdown handling as target loss events so there
1076  * are no sysfs handlers for link_down_tmo.
1077  */
1078 static void
1079 lpfc_get_starget_port_id(struct scsi_target *starget)
1080 {
1081         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1082         struct lpfc_hba *phba = (struct lpfc_hba *) shost->hostdata[0];
1083         uint32_t did = -1;
1084         struct lpfc_nodelist *ndlp = NULL;
1085
1086         spin_lock_irq(shost->host_lock);
1087         /* Search the mapped list for this target ID */
1088         list_for_each_entry(ndlp, &phba->fc_nlpmap_list, nlp_listp) {
1089                 if (starget->id == ndlp->nlp_sid) {
1090                         did = ndlp->nlp_DID;
1091                         break;
1092                 }
1093         }
1094         spin_unlock_irq(shost->host_lock);
1095
1096         fc_starget_port_id(starget) = did;
1097 }
1098
1099 static void
1100 lpfc_get_starget_node_name(struct scsi_target *starget)
1101 {
1102         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1103         struct lpfc_hba *phba = (struct lpfc_hba *) shost->hostdata[0];
1104         uint64_t node_name = 0;
1105         struct lpfc_nodelist *ndlp = NULL;
1106
1107         spin_lock_irq(shost->host_lock);
1108         /* Search the mapped list for this target ID */
1109         list_for_each_entry(ndlp, &phba->fc_nlpmap_list, nlp_listp) {
1110                 if (starget->id == ndlp->nlp_sid) {
1111                         memcpy(&node_name, &ndlp->nlp_nodename,
1112                                                 sizeof(struct lpfc_name));
1113                         break;
1114                 }
1115         }
1116         spin_unlock_irq(shost->host_lock);
1117
1118         fc_starget_node_name(starget) = be64_to_cpu(node_name);
1119 }
1120
1121 static void
1122 lpfc_get_starget_port_name(struct scsi_target *starget)
1123 {
1124         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1125         struct lpfc_hba *phba = (struct lpfc_hba *) shost->hostdata[0];
1126         uint64_t port_name = 0;
1127         struct lpfc_nodelist *ndlp = NULL;
1128
1129         spin_lock_irq(shost->host_lock);
1130         /* Search the mapped list for this target ID */
1131         list_for_each_entry(ndlp, &phba->fc_nlpmap_list, nlp_listp) {
1132                 if (starget->id == ndlp->nlp_sid) {
1133                         memcpy(&port_name, &ndlp->nlp_portname,
1134                                                 sizeof(struct lpfc_name));
1135                         break;
1136                 }
1137         }
1138         spin_unlock_irq(shost->host_lock);
1139
1140         fc_starget_port_name(starget) = be64_to_cpu(port_name);
1141 }
1142
1143 static void
1144 lpfc_get_rport_loss_tmo(struct fc_rport *rport)
1145 {
1146         /*
1147          * Return the driver's global value for device loss timeout plus
1148          * five seconds to allow the driver's nodev timer to run.
1149          */
1150         rport->dev_loss_tmo = lpfc_nodev_tmo + 5;
1151 }
1152
1153 static void
1154 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
1155 {
1156         /*
1157          * The driver doesn't have a per-target timeout setting.  Set
1158          * this value globally. lpfc_nodev_tmo should be greater then 0.
1159          */
1160         if (timeout)
1161                 lpfc_nodev_tmo = timeout;
1162         else
1163                 lpfc_nodev_tmo = 1;
1164         rport->dev_loss_tmo = lpfc_nodev_tmo + 5;
1165 }
1166
1167
1168 #define lpfc_rport_show_function(field, format_string, sz, cast)        \
1169 static ssize_t                                                          \
1170 lpfc_show_rport_##field (struct class_device *cdev, char *buf)          \
1171 {                                                                       \
1172         struct fc_rport *rport = transport_class_to_rport(cdev);        \
1173         struct lpfc_rport_data *rdata = rport->hostdata;                \
1174         return snprintf(buf, sz, format_string,                         \
1175                 (rdata->target) ? cast rdata->target->field : 0);       \
1176 }
1177
1178 #define lpfc_rport_rd_attr(field, format_string, sz)                    \
1179         lpfc_rport_show_function(field, format_string, sz, )            \
1180 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
1181
1182
1183 struct fc_function_template lpfc_transport_functions = {
1184         /* fixed attributes the driver supports */
1185         .show_host_node_name = 1,
1186         .show_host_port_name = 1,
1187         .show_host_supported_classes = 1,
1188         .show_host_supported_fc4s = 1,
1189         .show_host_symbolic_name = 1,
1190         .show_host_supported_speeds = 1,
1191         .show_host_maxframe_size = 1,
1192
1193         /* dynamic attributes the driver supports */
1194         .get_host_port_id = lpfc_get_host_port_id,
1195         .show_host_port_id = 1,
1196
1197         .get_host_port_type = lpfc_get_host_port_type,
1198         .show_host_port_type = 1,
1199
1200         .get_host_port_state = lpfc_get_host_port_state,
1201         .show_host_port_state = 1,
1202
1203         /* active_fc4s is shown but doesn't change (thus no get function) */
1204         .show_host_active_fc4s = 1,
1205
1206         .get_host_speed = lpfc_get_host_speed,
1207         .show_host_speed = 1,
1208
1209         .get_host_fabric_name = lpfc_get_host_fabric_name,
1210         .show_host_fabric_name = 1,
1211
1212         /*
1213          * The LPFC driver treats linkdown handling as target loss events
1214          * so there are no sysfs handlers for link_down_tmo.
1215          */
1216
1217         .get_fc_host_stats = lpfc_get_stats,
1218
1219         /* the LPFC driver doesn't support resetting stats yet */
1220
1221         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
1222         .show_rport_maxframe_size = 1,
1223         .show_rport_supported_classes = 1,
1224
1225         .get_rport_dev_loss_tmo = lpfc_get_rport_loss_tmo,
1226         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
1227         .show_rport_dev_loss_tmo = 1,
1228
1229         .get_starget_port_id  = lpfc_get_starget_port_id,
1230         .show_starget_port_id = 1,
1231
1232         .get_starget_node_name = lpfc_get_starget_node_name,
1233         .show_starget_node_name = 1,
1234
1235         .get_starget_port_name = lpfc_get_starget_port_name,
1236         .show_starget_port_name = 1,
1237 };
1238
1239 void
1240 lpfc_get_cfgparam(struct lpfc_hba *phba)
1241 {
1242         phba->cfg_log_verbose = lpfc_log_verbose;
1243         phba->cfg_cr_delay = lpfc_cr_delay;
1244         phba->cfg_cr_count = lpfc_cr_count;
1245         phba->cfg_lun_queue_depth = lpfc_lun_queue_depth;
1246         phba->cfg_fcp_class = lpfc_fcp_class;
1247         phba->cfg_use_adisc = lpfc_use_adisc;
1248         phba->cfg_ack0 = lpfc_ack0;
1249         phba->cfg_topology = lpfc_topology;
1250         phba->cfg_scan_down = lpfc_scan_down;
1251         phba->cfg_nodev_tmo = lpfc_nodev_tmo;
1252         phba->cfg_link_speed = lpfc_link_speed;
1253         phba->cfg_fdmi_on = lpfc_fdmi_on;
1254         phba->cfg_discovery_threads = lpfc_discovery_threads;
1255         phba->cfg_max_luns = lpfc_max_luns;
1256
1257         /*
1258          * The total number of segments is the configuration value plus 2
1259          * since the IOCB need a command and response bde.
1260          */
1261         phba->cfg_sg_seg_cnt = LPFC_SG_SEG_CNT + 2;
1262
1263         /*
1264          * Since the sg_tablesize is module parameter, the sg_dma_buf_size
1265          * used to create the sg_dma_buf_pool must be dynamically calculated
1266          */
1267         phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
1268                         sizeof(struct fcp_rsp) +
1269                         (phba->cfg_sg_seg_cnt * sizeof(struct ulp_bde64));
1270
1271         switch (phba->pcidev->device) {
1272         case PCI_DEVICE_ID_LP101:
1273         case PCI_DEVICE_ID_BSMB:
1274         case PCI_DEVICE_ID_ZSMB:
1275                 phba->cfg_hba_queue_depth = LPFC_LP101_HBA_Q_DEPTH;
1276                 break;
1277         case PCI_DEVICE_ID_RFLY:
1278         case PCI_DEVICE_ID_PFLY:
1279         case PCI_DEVICE_ID_BMID:
1280         case PCI_DEVICE_ID_ZMID:
1281         case PCI_DEVICE_ID_TFLY:
1282                 phba->cfg_hba_queue_depth = LPFC_LC_HBA_Q_DEPTH;
1283                 break;
1284         default:
1285                 phba->cfg_hba_queue_depth = LPFC_DFT_HBA_Q_DEPTH;
1286         }
1287         return;
1288 }