2005-04-18 05:05:31 +08:00
|
|
|
/*******************************************************************
|
|
|
|
* This file is part of the Emulex Linux Device Driver for *
|
2005-06-25 22:34:39 +08:00
|
|
|
* Fibre Channel Host Bus Adapters. *
|
2008-01-11 14:52:54 +08:00
|
|
|
* Copyright (C) 2004-2008 Emulex. All rights reserved. *
|
2005-06-25 22:34:39 +08:00
|
|
|
* EMULEX and SLI are trademarks of Emulex. *
|
2005-04-18 05:05:31 +08:00
|
|
|
* www.emulex.com *
|
2005-06-25 22:34:39 +08:00
|
|
|
* Portions Copyright (C) 2004-2005 Christoph Hellwig *
|
2005-04-18 05:05:31 +08:00
|
|
|
* *
|
|
|
|
* This program is free software; you can redistribute it and/or *
|
2005-06-25 22:34:39 +08:00
|
|
|
* modify it under the terms of version 2 of the GNU General *
|
|
|
|
* Public License as published by the Free Software Foundation. *
|
|
|
|
* This program is distributed in the hope that it will be useful. *
|
|
|
|
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
|
|
|
|
* WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
|
|
|
|
* DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
|
|
|
|
* TO BE LEGALLY INVALID. See the GNU General Public License for *
|
|
|
|
* more details, a copy of which can be found in the file COPYING *
|
|
|
|
* included with this package. *
|
2005-04-18 05:05:31 +08:00
|
|
|
*******************************************************************/
|
|
|
|
|
|
|
|
#include <linux/ctype.h>
|
2007-04-25 21:51:45 +08:00
|
|
|
#include <linux/delay.h>
|
2005-04-18 05:05:31 +08:00
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
2005-08-11 03:03:09 +08:00
|
|
|
#include <scsi/scsi.h>
|
2005-04-18 05:05:31 +08:00
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
#include <scsi/scsi_tcq.h>
|
|
|
|
#include <scsi/scsi_transport_fc.h>
|
|
|
|
|
|
|
|
#include "lpfc_hw.h"
|
|
|
|
#include "lpfc_sli.h"
|
2008-09-07 23:52:10 +08:00
|
|
|
#include "lpfc_nl.h"
|
2005-04-18 05:05:31 +08:00
|
|
|
#include "lpfc_disc.h"
|
|
|
|
#include "lpfc_scsi.h"
|
|
|
|
#include "lpfc.h"
|
|
|
|
#include "lpfc_logmsg.h"
|
|
|
|
#include "lpfc_version.h"
|
|
|
|
#include "lpfc_compat.h"
|
|
|
|
#include "lpfc_crtn.h"
|
2007-06-18 08:56:38 +08:00
|
|
|
#include "lpfc_vport.h"
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2006-08-19 05:47:08 +08:00
|
|
|
#define LPFC_DEF_DEVLOSS_TMO 30
|
|
|
|
#define LPFC_MIN_DEVLOSS_TMO 1
|
|
|
|
#define LPFC_MAX_DEVLOSS_TMO 255
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2008-01-11 14:53:09 +08:00
|
|
|
#define LPFC_MAX_LINK_SPEED 8
|
|
|
|
#define LPFC_LINK_SPEED_BITMAP 0x00000117
|
|
|
|
#define LPFC_LINK_SPEED_STRING "0, 1, 2, 4, 8"
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_jedec_to_ascii: Hex to ascii convertor according to JEDEC rules.
|
|
|
|
* @incr: integer to convert.
|
|
|
|
* @hdw: ascii string holding converted integer plus a string terminator.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* JEDEC Joint Electron Device Engineering Council.
|
|
|
|
* Convert a 32 bit integer composed of 8 nibbles into an 8 byte ascii
|
|
|
|
* character string. The string is then terminated with a NULL in byte 9.
|
|
|
|
* Hex 0-9 becomes ascii '0' to '9'.
|
|
|
|
* Hex a-f becomes ascii '=' to 'B' capital B.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* Coded for 32 bit integers only.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
lpfc_jedec_to_ascii(int incr, char hdw[])
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
j = (incr & 0xf);
|
|
|
|
if (j <= 9)
|
|
|
|
hdw[7 - i] = 0x30 + j;
|
|
|
|
else
|
|
|
|
hdw[7 - i] = 0x61 + j - 10;
|
|
|
|
incr = (incr >> 4);
|
|
|
|
}
|
|
|
|
hdw[8] = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_drvr_version_show: Return the Emulex driver string with version number.
|
|
|
|
* @dev: class unused variable.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the module description text.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
|
|
|
return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_info_show: Return some pci info about the host in ascii.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the formatted text from lpfc_info().
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_info_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *host = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_serialnum_show: Return the hba serial number in ascii.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the formatted text serial number.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_temp_sensor_show: Return the temperature sensor level.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the formatted support level.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Returns a number indicating the temperature sensor level currently
|
|
|
|
* supported, zero or one in ascii.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2007-10-28 01:37:05 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2007-10-28 01:37:05 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-10-28 01:37:05 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_modeldesc_show: Return the model description of the hba.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the scsi vpd model description.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_modelname_show: Return the model name of the hba.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the scsi vpd model name.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_programtype_show: Return the program type of the hba.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the scsi vpd program type.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:50:06 +08:00
|
|
|
/**
|
|
|
|
* lpfc_mlomgmt_show: Return the Menlo Maintenance sli flag.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the Menlo Maintenance sli flag.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
|
|
|
static ssize_t
|
|
|
|
lpfc_mlomgmt_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n",
|
|
|
|
(phba->sli.sli_flag & LPFC_MENLO_MAINT));
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_vportnum_show: Return the port number in ascii of the hba.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains scsi vpd program type.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_fwrev_show: Return the firmware rev running in the hba.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the scsi vpd program type.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
char fwrev[32];
|
2007-06-18 08:56:36 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
lpfc_decode_firmware_rev(phba, fwrev, 1);
|
2007-06-18 08:56:38 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s, sli-%d\n", fwrev, phba->sli_rev);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_hdw_show: Return the jedec information about the hba.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the scsi vpd program type.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
|
|
|
char hdw[9];
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
lpfc_vpd_t *vp = &phba->vpd;
|
2007-06-18 08:56:36 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
|
|
|
|
}
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* lpfc_option_rom_version_show: Return the adapter ROM FCode version.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the ROM and FCode ascii strings.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
|
|
|
|
}
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* lpfc_state_show: Return the link state of the port.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains text describing the state of the link.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* The switch statement has no default so zero will be returned.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-03-18 21:32:28 +08:00
|
|
|
lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
switch (phba->link_state) {
|
|
|
|
case LPFC_LINK_UNKNOWN:
|
2006-03-01 08:25:27 +08:00
|
|
|
case LPFC_WARM_START:
|
2005-04-18 05:05:31 +08:00
|
|
|
case LPFC_INIT_START:
|
|
|
|
case LPFC_INIT_MBX_CMDS:
|
|
|
|
case LPFC_LINK_DOWN:
|
2007-06-18 08:56:36 +08:00
|
|
|
case LPFC_HBA_ERROR:
|
2005-04-18 05:05:31 +08:00
|
|
|
len += snprintf(buf + len, PAGE_SIZE-len, "Link Down\n");
|
|
|
|
break;
|
|
|
|
case LPFC_LINK_UP:
|
|
|
|
case LPFC_CLEAR_LA:
|
|
|
|
case LPFC_HBA_READY:
|
2007-10-28 01:37:53 +08:00
|
|
|
len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
|
2007-06-18 08:56:36 +08:00
|
|
|
|
|
|
|
switch (vport->port_state) {
|
|
|
|
case LPFC_LOCAL_CFG_LINK:
|
|
|
|
len += snprintf(buf + len, PAGE_SIZE-len,
|
2007-06-18 08:56:38 +08:00
|
|
|
"Configuring Link\n");
|
2007-06-18 08:56:36 +08:00
|
|
|
break;
|
2007-06-18 08:56:38 +08:00
|
|
|
case LPFC_FDISC:
|
2007-06-18 08:56:36 +08:00
|
|
|
case LPFC_FLOGI:
|
|
|
|
case LPFC_FABRIC_CFG_LINK:
|
|
|
|
case LPFC_NS_REG:
|
|
|
|
case LPFC_NS_QRY:
|
|
|
|
case LPFC_BUILD_DISC_LIST:
|
|
|
|
case LPFC_DISC_AUTH:
|
|
|
|
len += snprintf(buf + len, PAGE_SIZE - len,
|
|
|
|
"Discovery\n");
|
|
|
|
break;
|
|
|
|
case LPFC_VPORT_READY:
|
|
|
|
len += snprintf(buf + len, PAGE_SIZE - len, "Ready\n");
|
|
|
|
break;
|
|
|
|
|
2007-06-18 08:56:38 +08:00
|
|
|
case LPFC_VPORT_FAILED:
|
|
|
|
len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LPFC_VPORT_UNKNOWN:
|
2007-06-18 08:56:36 +08:00
|
|
|
len += snprintf(buf + len, PAGE_SIZE - len,
|
|
|
|
"Unknown\n");
|
|
|
|
break;
|
|
|
|
}
|
2008-08-25 09:50:06 +08:00
|
|
|
if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
|
|
|
|
len += snprintf(buf + len, PAGE_SIZE-len,
|
|
|
|
" Menlo Maint Mode\n");
|
|
|
|
else if (phba->fc_topology == TOPOLOGY_LOOP) {
|
2007-06-18 08:56:36 +08:00
|
|
|
if (vport->fc_flag & FC_PUBLIC_LOOP)
|
2005-04-18 05:05:31 +08:00
|
|
|
len += snprintf(buf + len, PAGE_SIZE-len,
|
|
|
|
" Public Loop\n");
|
|
|
|
else
|
|
|
|
len += snprintf(buf + len, PAGE_SIZE-len,
|
|
|
|
" Private Loop\n");
|
|
|
|
} else {
|
2007-06-18 08:56:36 +08:00
|
|
|
if (vport->fc_flag & FC_FABRIC)
|
2005-04-18 05:05:31 +08:00
|
|
|
len += snprintf(buf + len, PAGE_SIZE-len,
|
|
|
|
" Fabric\n");
|
|
|
|
else
|
|
|
|
len += snprintf(buf + len, PAGE_SIZE-len,
|
|
|
|
" Point-2-Point\n");
|
|
|
|
}
|
|
|
|
}
|
2007-06-18 08:56:36 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_num_discovered_ports_show: Return sum of mapped and unmapped vports.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the sum of fc mapped and unmapped.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Returns the ascii text number of the sum of the fc mapped and unmapped
|
|
|
|
* vport counts.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_num_discovered_ports_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n",
|
|
|
|
vport->fc_map_cnt + vport->fc_unmap_cnt);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_issue_lip: Misnomer, name carried over from long ago.
|
|
|
|
* @shost: Scsi_Host pointer.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Bring the link down gracefully then re-init the link. The firmware will
|
|
|
|
* re-init the fiber channel interface as required. Does not issue a LIP.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -EPERM port offline or management commands are being blocked
|
|
|
|
* -ENOMEM cannot allocate memory for the mailbox command
|
|
|
|
* -EIO error sending the mailbox command
|
|
|
|
* zero for success
|
|
|
|
**/
|
2005-10-28 07:03:37 +08:00
|
|
|
static int
|
2007-06-18 08:56:36 +08:00
|
|
|
lpfc_issue_lip(struct Scsi_Host *shost)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
LPFC_MBOXQ_t *pmboxq;
|
|
|
|
int mbxstatus = MBXERR_ERROR;
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if ((vport->fc_flag & FC_OFFLINE_MODE) ||
|
2008-01-11 14:53:09 +08:00
|
|
|
(phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
|
2005-04-18 05:05:31 +08:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
|
|
|
|
|
|
|
|
if (!pmboxq)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
|
2006-07-07 03:49:49 +08:00
|
|
|
pmboxq->mb.mbxCommand = MBX_DOWN_LINK;
|
|
|
|
pmboxq->mb.mbxOwner = OWN_HOST;
|
|
|
|
|
2006-08-17 23:57:58 +08:00
|
|
|
mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2006-07-07 03:49:49 +08:00
|
|
|
if ((mbxstatus == MBX_SUCCESS) && (pmboxq->mb.mbxStatus == 0)) {
|
|
|
|
memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
|
|
|
|
lpfc_init_link(phba, pmboxq, phba->cfg_topology,
|
|
|
|
phba->cfg_link_speed);
|
|
|
|
mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
|
|
|
|
phba->fc_ratov * 2);
|
|
|
|
}
|
|
|
|
|
2007-04-25 21:52:49 +08:00
|
|
|
lpfc_set_loopback_flag(phba);
|
2007-06-18 08:56:39 +08:00
|
|
|
if (mbxstatus != MBX_TIMEOUT)
|
2005-10-29 08:28:56 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
if (mbxstatus == MBXERR_ERROR)
|
|
|
|
return -EIO;
|
|
|
|
|
2005-10-28 07:03:37 +08:00
|
|
|
return 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_do_offline: Issues a mailbox command to bring the link down.
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
* @type: LPFC_EVT_OFFLINE, LPFC_EVT_WARM_START, LPFC_EVT_KILL.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* Assumes any error from lpfc_do_offline() will be negative.
|
|
|
|
* Can wait up to 5 seconds for the port ring buffers count
|
|
|
|
* to reach zero, prints a warning if it is not zero and continues.
|
|
|
|
* lpfc_workq_post_event() returns a non-zero return coce if call fails.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -EIO error posting the event
|
|
|
|
* zero for success
|
|
|
|
**/
|
2006-07-07 03:50:22 +08:00
|
|
|
static int
|
2007-04-25 21:51:45 +08:00
|
|
|
lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
|
2006-07-07 03:50:22 +08:00
|
|
|
{
|
|
|
|
struct completion online_compl;
|
2007-04-25 21:51:45 +08:00
|
|
|
struct lpfc_sli_ring *pring;
|
|
|
|
struct lpfc_sli *psli;
|
2006-07-07 03:50:22 +08:00
|
|
|
int status = 0;
|
2007-04-25 21:51:45 +08:00
|
|
|
int cnt = 0;
|
|
|
|
int i;
|
2006-07-07 03:50:22 +08:00
|
|
|
|
|
|
|
init_completion(&online_compl);
|
|
|
|
lpfc_workq_post_event(phba, &status, &online_compl,
|
2007-04-25 21:51:45 +08:00
|
|
|
LPFC_EVT_OFFLINE_PREP);
|
|
|
|
wait_for_completion(&online_compl);
|
|
|
|
|
|
|
|
if (status != 0)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
psli = &phba->sli;
|
|
|
|
|
2008-01-11 14:52:54 +08:00
|
|
|
/* Wait a little for things to settle down, but not
|
|
|
|
* long enough for dev loss timeout to expire.
|
|
|
|
*/
|
2007-04-25 21:51:45 +08:00
|
|
|
for (i = 0; i < psli->num_rings; i++) {
|
|
|
|
pring = &psli->ring[i];
|
|
|
|
while (pring->txcmplq_cnt) {
|
|
|
|
msleep(10);
|
2008-01-11 14:52:54 +08:00
|
|
|
if (cnt++ > 500) { /* 5 secs */
|
2007-04-25 21:51:45 +08:00
|
|
|
lpfc_printf_log(phba,
|
|
|
|
KERN_WARNING, LOG_INIT,
|
2007-08-02 23:10:09 +08:00
|
|
|
"0466 Outstanding IO when "
|
|
|
|
"bringing Adapter offline\n");
|
2007-04-25 21:51:45 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
init_completion(&online_compl);
|
|
|
|
lpfc_workq_post_event(phba, &status, &online_compl, type);
|
2006-07-07 03:50:22 +08:00
|
|
|
wait_for_completion(&online_compl);
|
|
|
|
|
|
|
|
if (status != 0)
|
|
|
|
return -EIO;
|
|
|
|
|
2007-04-25 21:51:45 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_selective_reset: Offline then onlines the port.
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If the port is configured to allow a reset then the hba is brought
|
|
|
|
* offline then online.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* Assumes any error from lpfc_do_offline() will be negative.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* lpfc_do_offline() return code if not zero
|
|
|
|
* -EIO reset not configured or error posting the event
|
|
|
|
* zero for success
|
|
|
|
**/
|
2007-04-25 21:51:45 +08:00
|
|
|
static int
|
|
|
|
lpfc_selective_reset(struct lpfc_hba *phba)
|
|
|
|
{
|
|
|
|
struct completion online_compl;
|
|
|
|
int status = 0;
|
|
|
|
|
2008-01-11 14:52:48 +08:00
|
|
|
if (!phba->cfg_enable_hba_reset)
|
|
|
|
return -EIO;
|
|
|
|
|
2007-04-25 21:51:45 +08:00
|
|
|
status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
|
|
|
|
|
|
|
|
if (status != 0)
|
|
|
|
return status;
|
|
|
|
|
2006-07-07 03:50:22 +08:00
|
|
|
init_completion(&online_compl);
|
|
|
|
lpfc_workq_post_event(phba, &status, &online_compl,
|
|
|
|
LPFC_EVT_ONLINE);
|
|
|
|
wait_for_completion(&online_compl);
|
|
|
|
|
|
|
|
if (status != 0)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_issue_reset: Selectively resets an adapter.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: containing the string "selective".
|
|
|
|
* @count: unused variable.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If the buf contains the string "selective" then lpfc_selective_reset()
|
|
|
|
* is called to perform the reset.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* Assumes any error from lpfc_selective_reset() will be negative.
|
|
|
|
* If lpfc_selective_reset() returns zero then the length of the buffer
|
|
|
|
* is returned which indicates succcess
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -EINVAL if the buffer does not contain the string "selective"
|
|
|
|
* length of buf if lpfc-selective_reset() if the call succeeds
|
|
|
|
* return value of lpfc_selective_reset() if the call fails
|
|
|
|
**/
|
2006-07-07 03:50:22 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2006-07-07 03:50:22 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
2006-07-07 03:50:22 +08:00
|
|
|
int status = -EINVAL;
|
|
|
|
|
|
|
|
if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
|
|
|
|
status = lpfc_selective_reset(phba);
|
|
|
|
|
|
|
|
if (status == 0)
|
|
|
|
return strlen(buf);
|
|
|
|
else
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_nport_evt_cnt_show: Return the number of nport events.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the ascii number of nport events.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_board_mode_show: Return the state of the board.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the state of the adapter.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2006-03-01 08:25:27 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2006-03-01 08:25:27 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2006-03-01 08:25:27 +08:00
|
|
|
char * state;
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if (phba->link_state == LPFC_HBA_ERROR)
|
2006-03-01 08:25:27 +08:00
|
|
|
state = "error";
|
2007-06-18 08:56:36 +08:00
|
|
|
else if (phba->link_state == LPFC_WARM_START)
|
2006-03-01 08:25:27 +08:00
|
|
|
state = "warm start";
|
2007-06-18 08:56:36 +08:00
|
|
|
else if (phba->link_state == LPFC_INIT_START)
|
2006-03-01 08:25:27 +08:00
|
|
|
state = "offline";
|
|
|
|
else
|
|
|
|
state = "online";
|
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n", state);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_board_mode_store: Puts the hba in online, offline, warm or error state.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: containing one of the strings "online", "offline", "warm" or "error".
|
|
|
|
* @count: unused variable.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -EACCES if enable hba reset not enabled
|
|
|
|
* -EINVAL if the buffer does not contain a valid string (see above)
|
|
|
|
* -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
|
|
|
|
* buf length greater than zero indicates success
|
|
|
|
**/
|
2006-03-01 08:25:27 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2006-03-01 08:25:27 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2006-03-01 08:25:27 +08:00
|
|
|
struct completion online_compl;
|
|
|
|
int status=0;
|
|
|
|
|
2008-01-11 14:52:48 +08:00
|
|
|
if (!phba->cfg_enable_hba_reset)
|
|
|
|
return -EACCES;
|
2006-03-01 08:25:27 +08:00
|
|
|
init_completion(&online_compl);
|
|
|
|
|
2007-04-25 21:51:45 +08:00
|
|
|
if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
|
2006-03-01 08:25:27 +08:00
|
|
|
lpfc_workq_post_event(phba, &status, &online_compl,
|
|
|
|
LPFC_EVT_ONLINE);
|
2007-04-25 21:51:45 +08:00
|
|
|
wait_for_completion(&online_compl);
|
|
|
|
} else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
|
|
|
|
status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
|
2006-03-01 08:25:27 +08:00
|
|
|
else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
|
2007-04-25 21:51:45 +08:00
|
|
|
status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
|
|
|
|
else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
|
|
|
|
status = lpfc_do_offline(phba, LPFC_EVT_KILL);
|
2006-03-01 08:25:27 +08:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!status)
|
|
|
|
return strlen(buf);
|
|
|
|
else
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_hba_info: Return various bits of informaton about the adapter.
|
|
|
|
* @phba: pointer to the adapter structure.
|
|
|
|
* @mxri max xri count.
|
|
|
|
* @axri available xri count.
|
|
|
|
* @mrpi max rpi count.
|
|
|
|
* @arpi available rpi count.
|
|
|
|
* @mvpi max vpi count.
|
|
|
|
* @avpi available vpi count.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If an integer pointer for an count is not null then the value for the
|
|
|
|
* count is returned.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero on error
|
|
|
|
* one for success
|
|
|
|
**/
|
2007-08-02 23:10:37 +08:00
|
|
|
static int
|
2007-06-18 08:56:39 +08:00
|
|
|
lpfc_get_hba_info(struct lpfc_hba *phba,
|
|
|
|
uint32_t *mxri, uint32_t *axri,
|
|
|
|
uint32_t *mrpi, uint32_t *arpi,
|
|
|
|
uint32_t *mvpi, uint32_t *avpi)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
|
|
|
struct lpfc_sli *psli = &phba->sli;
|
|
|
|
LPFC_MBOXQ_t *pmboxq;
|
|
|
|
MAILBOX_t *pmb;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* prevent udev from issuing mailbox commands until the port is
|
|
|
|
* configured.
|
|
|
|
*/
|
|
|
|
if (phba->link_state < LPFC_LINK_DOWN ||
|
|
|
|
!phba->mbox_mem_pool ||
|
|
|
|
(phba->sli.sli_flag & LPFC_SLI2_ACTIVE) == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
|
|
if (!pmboxq)
|
|
|
|
return 0;
|
|
|
|
memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
|
|
|
|
|
|
|
|
pmb = &pmboxq->mb;
|
|
|
|
pmb->mbxCommand = MBX_READ_CONFIG;
|
|
|
|
pmb->mbxOwner = OWN_HOST;
|
|
|
|
pmboxq->context1 = NULL;
|
|
|
|
|
|
|
|
if ((phba->pport->fc_flag & FC_OFFLINE_MODE) ||
|
|
|
|
(!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
|
|
|
|
rc = MBX_NOT_FINISHED;
|
|
|
|
else
|
|
|
|
rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
|
|
|
|
|
|
|
|
if (rc != MBX_SUCCESS) {
|
2007-06-18 08:56:39 +08:00
|
|
|
if (rc != MBX_TIMEOUT)
|
2007-06-18 08:56:38 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mrpi)
|
|
|
|
*mrpi = pmb->un.varRdConfig.max_rpi;
|
|
|
|
if (arpi)
|
|
|
|
*arpi = pmb->un.varRdConfig.avail_rpi;
|
|
|
|
if (mxri)
|
|
|
|
*mxri = pmb->un.varRdConfig.max_xri;
|
|
|
|
if (axri)
|
|
|
|
*axri = pmb->un.varRdConfig.avail_xri;
|
2007-06-18 08:56:39 +08:00
|
|
|
if (mvpi)
|
|
|
|
*mvpi = pmb->un.varRdConfig.max_vpi;
|
|
|
|
if (avpi)
|
|
|
|
*avpi = pmb->un.varRdConfig.avail_vpi;
|
2007-06-18 08:56:38 +08:00
|
|
|
|
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_max_rpi_show: Return maximum rpi.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the maximum rpi count in decimal or "Unknown".
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mrpi count.
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2007-06-18 08:56:38 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:38 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
uint32_t cnt;
|
|
|
|
|
2007-06-18 08:56:39 +08:00
|
|
|
if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
|
2007-06-18 08:56:38 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "Unknown\n");
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_used_rpi_show: Return maximum rpi minus available rpi.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: containing the used rpi count in decimal or "Unknown".
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2007-06-18 08:56:38 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:38 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
uint32_t cnt, acnt;
|
|
|
|
|
2007-06-18 08:56:39 +08:00
|
|
|
if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
|
2007-06-18 08:56:38 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
|
|
|
|
return snprintf(buf, PAGE_SIZE, "Unknown\n");
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_max_xri_show: Return maximum xri.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the maximum xri count in decimal or "Unknown".
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mrpi count.
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2007-06-18 08:56:38 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:38 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
uint32_t cnt;
|
|
|
|
|
2007-06-18 08:56:39 +08:00
|
|
|
if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
|
2007-06-18 08:56:38 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "Unknown\n");
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_used_xri_show: Return maximum xpi minus the available xpi.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the used xri count in decimal or "Unknown".
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2007-06-18 08:56:38 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:38 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
uint32_t cnt, acnt;
|
|
|
|
|
2007-06-18 08:56:39 +08:00
|
|
|
if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
|
|
|
|
return snprintf(buf, PAGE_SIZE, "Unknown\n");
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_max_vpi_show: Return maximum vpi.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the maximum vpi count in decimal or "Unknown".
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mvpi count.
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2007-06-18 08:56:39 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2007-06-18 08:56:39 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:39 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
uint32_t cnt;
|
|
|
|
|
|
|
|
if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "Unknown\n");
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_used_vpi_show: Return maximum vpi minus the available vpi.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the used vpi count in decimal or "Unknown".
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
|
|
|
|
* If lpfc_get_hba_info() returns zero (failure) the buffer text is set
|
|
|
|
* to "Unknown" and the buffer length is returned, therefore the caller
|
|
|
|
* must check for "Unknown" in the buffer to detect a failure.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2007-06-18 08:56:39 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2007-06-18 08:56:39 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:39 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
uint32_t cnt, acnt;
|
|
|
|
|
|
|
|
if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
|
2007-06-18 08:56:38 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
|
|
|
|
return snprintf(buf, PAGE_SIZE, "Unknown\n");
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_npiv_info_show: Return text about NPIV support for the adapter.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: text that must be interpreted to determine if npiv is supported.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Buffer will contain text indicating npiv is not suppoerted on the port,
|
|
|
|
* the port is an NPIV physical port, or it is an npiv virtual port with
|
|
|
|
* the id of the vport.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2007-06-18 08:56:38 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2007-06-18 08:56:38 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:38 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
|
|
|
if (!(phba->max_vpi))
|
|
|
|
return snprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
|
|
|
|
if (vport->port_type == LPFC_PHYSICAL_PORT)
|
|
|
|
return snprintf(buf, PAGE_SIZE, "NPIV Physical\n");
|
|
|
|
return snprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_poll_show: Return text about poll support for the adapter.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the cfg_poll in hex.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* cfg_poll should be a lpfc_polling_flags type.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_poll_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_poll_store: Set the value of cfg_poll for the adapter.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: one or more lpfc_polling_flags values.
|
|
|
|
* @count: not used.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* buf contents converted to integer and checked for a valid value.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -EINVAL if the buffer connot be converted or is out of range
|
|
|
|
* length of the buf on success
|
|
|
|
**/
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_poll_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
uint32_t creg_val;
|
|
|
|
uint32_t old_val;
|
|
|
|
int val=0;
|
|
|
|
|
|
|
|
if (!isdigit(buf[0]))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if ((val & 0x3) != val)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
|
|
|
|
old_val = phba->cfg_poll;
|
|
|
|
|
|
|
|
if (val & ENABLE_FCP_RING_POLLING) {
|
|
|
|
if ((val & DISABLE_FCP_RING_INT) &&
|
|
|
|
!(old_val & DISABLE_FCP_RING_INT)) {
|
|
|
|
creg_val = readl(phba->HCregaddr);
|
|
|
|
creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
|
|
|
|
writel(creg_val, phba->HCregaddr);
|
|
|
|
readl(phba->HCregaddr); /* flush */
|
|
|
|
|
|
|
|
lpfc_poll_start_timer(phba);
|
|
|
|
}
|
|
|
|
} else if (val != 0x0) {
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(val & DISABLE_FCP_RING_INT) &&
|
|
|
|
(old_val & DISABLE_FCP_RING_INT))
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
del_timer(&phba->fcp_poll_timer);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
creg_val = readl(phba->HCregaddr);
|
|
|
|
creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
|
|
|
|
writel(creg_val, phba->HCregaddr);
|
|
|
|
readl(phba->HCregaddr); /* flush */
|
|
|
|
}
|
|
|
|
|
|
|
|
phba->cfg_poll = val;
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_param_show: Return a cfg attribute value in decimal.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_show.
|
|
|
|
*
|
|
|
|
* lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the attribute value in decimal.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
#define lpfc_param_show(attr) \
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
|
|
|
|
char *buf) \
|
2005-04-18 05:05:31 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
|
|
|
struct lpfc_hba *phba = vport->phba;\
|
2005-04-18 05:05:31 +08:00
|
|
|
int val = 0;\
|
2005-10-29 08:29:13 +08:00
|
|
|
val = phba->cfg_##attr;\
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n",\
|
|
|
|
phba->cfg_##attr);\
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_param_hex_show: Return a cfg attribute value in hex.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_show
|
|
|
|
*
|
|
|
|
* lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the attribute value in hexidecimal.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-10-29 08:29:32 +08:00
|
|
|
#define lpfc_param_hex_show(attr) \
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
|
|
|
|
char *buf) \
|
2005-10-29 08:29:32 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
|
|
|
struct lpfc_hba *phba = vport->phba;\
|
2005-10-29 08:29:32 +08:00
|
|
|
int val = 0;\
|
|
|
|
val = phba->cfg_##attr;\
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%#x\n",\
|
|
|
|
phba->cfg_##attr);\
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_param_init: Intializes a cfg attribute.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_init. The macro also
|
|
|
|
* takes a default argument, a minimum and maximum argument.
|
|
|
|
*
|
|
|
|
* lpfc_##attr##_init: Initializes an attribute.
|
|
|
|
* @phba: pointer the the adapter structure.
|
|
|
|
* @val: integer attribute value.
|
|
|
|
*
|
|
|
|
* Validates the min and max values then sets the adapter config field
|
|
|
|
* accordingly, or uses the default if out of range and prints an error message.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero on success
|
|
|
|
* -EINVAL if default used
|
|
|
|
**/
|
2005-10-29 08:29:13 +08:00
|
|
|
#define lpfc_param_init(attr, default, minval, maxval) \
|
|
|
|
static int \
|
|
|
|
lpfc_##attr##_init(struct lpfc_hba *phba, int val) \
|
|
|
|
{ \
|
|
|
|
if (val >= minval && val <= maxval) {\
|
|
|
|
phba->cfg_##attr = val;\
|
|
|
|
return 0;\
|
2005-04-18 05:05:31 +08:00
|
|
|
}\
|
2005-10-29 08:29:13 +08:00
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
|
2007-08-02 23:10:09 +08:00
|
|
|
"0449 lpfc_"#attr" attribute cannot be set to %d, "\
|
|
|
|
"allowed range is ["#minval", "#maxval"]\n", val); \
|
2005-10-29 08:29:13 +08:00
|
|
|
phba->cfg_##attr = default;\
|
|
|
|
return -EINVAL;\
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_param_set: Set a cfg attribute value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_set
|
|
|
|
*
|
|
|
|
* lpfc_##attr##_set: Sets an attribute value.
|
|
|
|
* @phba: pointer the the adapter structure.
|
|
|
|
* @val: integer attribute value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Validates the min and max values then sets the
|
|
|
|
* adapter config field if in the valid range. prints error message
|
|
|
|
* and does not set the parameter if invalid.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero on success
|
|
|
|
* -EINVAL if val is invalid
|
|
|
|
**/
|
2005-10-29 08:29:13 +08:00
|
|
|
#define lpfc_param_set(attr, default, minval, maxval) \
|
|
|
|
static int \
|
|
|
|
lpfc_##attr##_set(struct lpfc_hba *phba, int val) \
|
|
|
|
{ \
|
|
|
|
if (val >= minval && val <= maxval) {\
|
|
|
|
phba->cfg_##attr = val;\
|
|
|
|
return 0;\
|
|
|
|
}\
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
|
2007-08-02 23:10:09 +08:00
|
|
|
"0450 lpfc_"#attr" attribute cannot be set to %d, "\
|
|
|
|
"allowed range is ["#minval", "#maxval"]\n", val); \
|
2005-10-29 08:29:13 +08:00
|
|
|
return -EINVAL;\
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_param_store: Set a vport attribute value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_store.
|
|
|
|
*
|
|
|
|
* lpfc_##attr##_store: Set an sttribute value.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: contains the attribute value in ascii.
|
|
|
|
* @count: not used.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Convert the ascii text number to an integer, then
|
|
|
|
* use the lpfc_##attr##_set function to set the value.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -EINVAL if val is invalid or lpfc_##attr##_set() fails
|
|
|
|
* length of buffer upon success.
|
|
|
|
**/
|
2005-10-29 08:29:13 +08:00
|
|
|
#define lpfc_param_store(attr) \
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
|
|
|
|
const char *buf, size_t count) \
|
2005-04-18 05:05:31 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
|
|
|
struct lpfc_hba *phba = vport->phba;\
|
2005-10-29 08:29:13 +08:00
|
|
|
int val=0;\
|
2005-10-29 08:29:32 +08:00
|
|
|
if (!isdigit(buf[0]))\
|
|
|
|
return -EINVAL;\
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)\
|
|
|
|
return -EINVAL;\
|
2005-10-29 08:29:13 +08:00
|
|
|
if (lpfc_##attr##_set(phba, val) == 0) \
|
2005-10-29 08:29:06 +08:00
|
|
|
return strlen(buf);\
|
2005-10-29 08:29:13 +08:00
|
|
|
else \
|
|
|
|
return -EINVAL;\
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_vport_param_show: Return decimal formatted cfg attribute value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_show
|
|
|
|
*
|
|
|
|
* lpfc_##attr##_show: prints the attribute value in decimal.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the attribute value in decimal.
|
|
|
|
*
|
|
|
|
* Returns: length of formatted string.
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
#define lpfc_vport_param_show(attr) \
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
|
|
|
|
char *buf) \
|
2007-08-02 23:09:59 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-08-02 23:09:59 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
|
|
|
int val = 0;\
|
|
|
|
val = vport->cfg_##attr;\
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_vport_param_hex_show: Return hex formatted attribute value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that given an attr e.g.
|
|
|
|
* hba_queue_depth expands into a function with the name
|
|
|
|
* lpfc_hba_queue_depth_show
|
|
|
|
*
|
|
|
|
* lpfc_##attr##_show: prints the attribute value in hexidecimal.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the attribute value in hexidecimal.
|
|
|
|
*
|
|
|
|
* Returns: length of formatted string.
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
#define lpfc_vport_param_hex_show(attr) \
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
|
|
|
|
char *buf) \
|
2007-08-02 23:09:59 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-08-02 23:09:59 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
|
|
|
int val = 0;\
|
|
|
|
val = vport->cfg_##attr;\
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_vport_param_init: Initialize a vport cfg attribute.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_init. The macro also
|
|
|
|
* takes a default argument, a minimum and maximum argument.
|
|
|
|
*
|
|
|
|
* lpfc_##attr##_init: validates the min and max values then sets the
|
|
|
|
* adapter config field accordingly, or uses the default if out of range
|
|
|
|
* and prints an error message.
|
|
|
|
* @phba: pointer the the adapter structure.
|
|
|
|
* @val: integer attribute value.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero on success
|
|
|
|
* -EINVAL if default used
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
#define lpfc_vport_param_init(attr, default, minval, maxval) \
|
|
|
|
static int \
|
|
|
|
lpfc_##attr##_init(struct lpfc_vport *vport, int val) \
|
|
|
|
{ \
|
|
|
|
if (val >= minval && val <= maxval) {\
|
|
|
|
vport->cfg_##attr = val;\
|
|
|
|
return 0;\
|
|
|
|
}\
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
|
2008-08-25 09:50:00 +08:00
|
|
|
"0423 lpfc_"#attr" attribute cannot be set to %d, "\
|
2007-08-02 23:10:09 +08:00
|
|
|
"allowed range is ["#minval", "#maxval"]\n", val); \
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_##attr = default;\
|
|
|
|
return -EINVAL;\
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_vport_param_set: Set a vport cfg attribute.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth expands
|
|
|
|
* into a function with the name lpfc_hba_queue_depth_set
|
|
|
|
*
|
|
|
|
* lpfc_##attr##_set: validates the min and max values then sets the
|
|
|
|
* adapter config field if in the valid range. prints error message
|
|
|
|
* and does not set the parameter if invalid.
|
|
|
|
* @phba: pointer the the adapter structure.
|
|
|
|
* @val: integer attribute value.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero on success
|
|
|
|
* -EINVAL if val is invalid
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
#define lpfc_vport_param_set(attr, default, minval, maxval) \
|
|
|
|
static int \
|
|
|
|
lpfc_##attr##_set(struct lpfc_vport *vport, int val) \
|
|
|
|
{ \
|
|
|
|
if (val >= minval && val <= maxval) {\
|
|
|
|
vport->cfg_##attr = val;\
|
|
|
|
return 0;\
|
|
|
|
}\
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
|
2008-08-25 09:50:00 +08:00
|
|
|
"0424 lpfc_"#attr" attribute cannot be set to %d, "\
|
2007-08-02 23:10:09 +08:00
|
|
|
"allowed range is ["#minval", "#maxval"]\n", val); \
|
2007-08-02 23:09:59 +08:00
|
|
|
return -EINVAL;\
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_vport_param_store: Set a vport attribute.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that given an attr e.g. hba_queue_depth
|
|
|
|
* expands into a function with the name lpfc_hba_queue_depth_store
|
|
|
|
*
|
|
|
|
* lpfc_##attr##_store: convert the ascii text number to an integer, then
|
|
|
|
* use the lpfc_##attr##_set function to set the value.
|
|
|
|
* @cdev: class device that is converted into a Scsi_host.
|
|
|
|
* @buf: contains the attribute value in decimal.
|
|
|
|
* @count: not used.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -EINVAL if val is invalid or lpfc_##attr##_set() fails
|
|
|
|
* length of buffer upon success.
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
#define lpfc_vport_param_store(attr) \
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
|
|
|
|
const char *buf, size_t count) \
|
2007-08-02 23:09:59 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);\
|
2007-08-02 23:09:59 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
|
|
|
|
int val=0;\
|
|
|
|
if (!isdigit(buf[0]))\
|
|
|
|
return -EINVAL;\
|
|
|
|
if (sscanf(buf, "%i", &val) != 1)\
|
|
|
|
return -EINVAL;\
|
|
|
|
if (lpfc_##attr##_set(vport, val) == 0) \
|
|
|
|
return strlen(buf);\
|
|
|
|
else \
|
|
|
|
return -EINVAL;\
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-10-29 08:29:13 +08:00
|
|
|
#define LPFC_ATTR(name, defval, minval, maxval, desc) \
|
|
|
|
static int lpfc_##name = defval;\
|
2005-04-18 05:05:31 +08:00
|
|
|
module_param(lpfc_##name, int, 0);\
|
|
|
|
MODULE_PARM_DESC(lpfc_##name, desc);\
|
2005-10-29 08:29:13 +08:00
|
|
|
lpfc_param_init(name, defval, minval, maxval)
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
#define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
|
|
|
|
static int lpfc_##name = defval;\
|
|
|
|
module_param(lpfc_##name, int, 0);\
|
|
|
|
MODULE_PARM_DESC(lpfc_##name, desc);\
|
|
|
|
lpfc_param_show(name)\
|
2005-10-29 08:29:13 +08:00
|
|
|
lpfc_param_init(name, defval, minval, maxval)\
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
#define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
|
|
|
|
static int lpfc_##name = defval;\
|
|
|
|
module_param(lpfc_##name, int, 0);\
|
|
|
|
MODULE_PARM_DESC(lpfc_##name, desc);\
|
|
|
|
lpfc_param_show(name)\
|
2005-10-29 08:29:13 +08:00
|
|
|
lpfc_param_init(name, defval, minval, maxval)\
|
|
|
|
lpfc_param_set(name, defval, minval, maxval)\
|
|
|
|
lpfc_param_store(name)\
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
|
|
|
|
lpfc_##name##_show, lpfc_##name##_store)
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2005-10-29 08:29:32 +08:00
|
|
|
#define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
|
|
|
|
static int lpfc_##name = defval;\
|
|
|
|
module_param(lpfc_##name, int, 0);\
|
|
|
|
MODULE_PARM_DESC(lpfc_##name, desc);\
|
|
|
|
lpfc_param_hex_show(name)\
|
|
|
|
lpfc_param_init(name, defval, minval, maxval)\
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
|
2005-10-29 08:29:32 +08:00
|
|
|
|
|
|
|
#define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
|
|
|
|
static int lpfc_##name = defval;\
|
|
|
|
module_param(lpfc_##name, int, 0);\
|
|
|
|
MODULE_PARM_DESC(lpfc_##name, desc);\
|
|
|
|
lpfc_param_hex_show(name)\
|
|
|
|
lpfc_param_init(name, defval, minval, maxval)\
|
|
|
|
lpfc_param_set(name, defval, minval, maxval)\
|
|
|
|
lpfc_param_store(name)\
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
|
|
|
|
lpfc_##name##_show, lpfc_##name##_store)
|
2005-10-29 08:29:32 +08:00
|
|
|
|
2007-08-02 23:09:59 +08:00
|
|
|
#define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
|
|
|
|
static int lpfc_##name = defval;\
|
|
|
|
module_param(lpfc_##name, int, 0);\
|
|
|
|
MODULE_PARM_DESC(lpfc_##name, desc);\
|
|
|
|
lpfc_vport_param_init(name, defval, minval, maxval)
|
|
|
|
|
|
|
|
#define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
|
|
|
|
static int lpfc_##name = defval;\
|
|
|
|
module_param(lpfc_##name, int, 0);\
|
|
|
|
MODULE_PARM_DESC(lpfc_##name, desc);\
|
|
|
|
lpfc_vport_param_show(name)\
|
|
|
|
lpfc_vport_param_init(name, defval, minval, maxval)\
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
|
2007-08-02 23:09:59 +08:00
|
|
|
|
|
|
|
#define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
|
|
|
|
static int lpfc_##name = defval;\
|
|
|
|
module_param(lpfc_##name, int, 0);\
|
|
|
|
MODULE_PARM_DESC(lpfc_##name, desc);\
|
|
|
|
lpfc_vport_param_show(name)\
|
|
|
|
lpfc_vport_param_init(name, defval, minval, maxval)\
|
|
|
|
lpfc_vport_param_set(name, defval, minval, maxval)\
|
|
|
|
lpfc_vport_param_store(name)\
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
|
|
|
|
lpfc_##name##_show, lpfc_##name##_store)
|
2007-08-02 23:09:59 +08:00
|
|
|
|
|
|
|
#define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
|
|
|
|
static int lpfc_##name = defval;\
|
|
|
|
module_param(lpfc_##name, int, 0);\
|
|
|
|
MODULE_PARM_DESC(lpfc_##name, desc);\
|
|
|
|
lpfc_vport_param_hex_show(name)\
|
|
|
|
lpfc_vport_param_init(name, defval, minval, maxval)\
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
|
2007-08-02 23:09:59 +08:00
|
|
|
|
|
|
|
#define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
|
|
|
|
static int lpfc_##name = defval;\
|
|
|
|
module_param(lpfc_##name, int, 0);\
|
|
|
|
MODULE_PARM_DESC(lpfc_##name, desc);\
|
|
|
|
lpfc_vport_param_hex_show(name)\
|
|
|
|
lpfc_vport_param_init(name, defval, minval, maxval)\
|
|
|
|
lpfc_vport_param_set(name, defval, minval, maxval)\
|
|
|
|
lpfc_vport_param_store(name)\
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
|
|
|
|
lpfc_##name##_show, lpfc_##name##_store)
|
|
|
|
|
|
|
|
static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
|
|
|
|
static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
|
|
|
|
static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
|
|
|
|
static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
|
|
|
|
static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
|
|
|
|
static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
|
|
|
|
static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
|
|
|
|
static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
|
2008-03-18 21:32:28 +08:00
|
|
|
static DEVICE_ATTR(link_state, S_IRUGO, lpfc_link_state_show, NULL);
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(option_rom_version, S_IRUGO,
|
|
|
|
lpfc_option_rom_version_show, NULL);
|
|
|
|
static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
|
|
|
|
lpfc_num_discovered_ports_show, NULL);
|
2008-08-25 09:50:06 +08:00
|
|
|
static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
|
|
|
|
static DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, NULL);
|
|
|
|
static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
|
|
|
|
lpfc_board_mode_show, lpfc_board_mode_store);
|
|
|
|
static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
|
|
|
|
static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
|
|
|
|
static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
|
|
|
|
static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
|
|
|
|
static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
|
|
|
|
static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
|
|
|
|
static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
|
|
|
|
static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
|
|
|
|
static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2006-08-19 05:47:18 +08:00
|
|
|
|
2006-12-03 02:35:30 +08:00
|
|
|
static char *lpfc_soft_wwn_key = "C99G71SL8032A";
|
2006-08-19 05:47:18 +08:00
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_soft_wwn_enable_store: Allows setting of the wwn if the key is valid.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: containing the string lpfc_soft_wwn_key.
|
|
|
|
* @count: must be size of lpfc_soft_wwn_key.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -EINVAL if the buffer does not contain lpfc_soft_wwn_key
|
|
|
|
* length of buf indicates success
|
|
|
|
**/
|
2006-08-19 05:47:18 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2006-08-19 05:47:18 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2006-08-19 05:47:18 +08:00
|
|
|
unsigned int cnt = count;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We're doing a simple sanity check for soft_wwpn setting.
|
|
|
|
* We require that the user write a specific key to enable
|
|
|
|
* the soft_wwpn attribute to be settable. Once the attribute
|
|
|
|
* is written, the enable key resets. If further updates are
|
|
|
|
* desired, the key must be written again to re-enable the
|
|
|
|
* attribute.
|
|
|
|
*
|
|
|
|
* The "key" is not secret - it is a hardcoded string shown
|
|
|
|
* here. The intent is to protect against the random user or
|
|
|
|
* application that is just writing attributes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* count may include a LF at end of string */
|
|
|
|
if (buf[cnt-1] == '\n')
|
|
|
|
cnt--;
|
|
|
|
|
2006-12-03 02:35:30 +08:00
|
|
|
if ((cnt != strlen(lpfc_soft_wwn_key)) ||
|
|
|
|
(strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0))
|
2006-08-19 05:47:18 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2006-12-03 02:35:30 +08:00
|
|
|
phba->soft_wwn_enable = 1;
|
2006-08-19 05:47:18 +08:00
|
|
|
return count;
|
|
|
|
}
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
|
|
|
|
lpfc_soft_wwn_enable_store);
|
2006-08-19 05:47:18 +08:00
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_soft_wwpn_show: Return the cfg soft ww port name of the adapter.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the wwpn in hexidecimal.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2006-08-19 05:47:18 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2006-08-19 05:47:18 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
|
2006-10-24 12:47:13 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "0x%llx\n",
|
|
|
|
(unsigned long long)phba->cfg_soft_wwpn);
|
2006-08-19 05:47:18 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_soft_wwpn_store: Set the ww port name of the adapter.
|
|
|
|
* @dev class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: contains the wwpn in hexidecimal.
|
|
|
|
* @count: number of wwpn bytes in buf
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -EACCES hba reset not enabled, adapter over temp
|
|
|
|
* -EINVAL soft wwn not enabled, count is invalid, invalid wwpn byte invalid
|
|
|
|
* -EIO error taking adapter offline or online
|
|
|
|
* value of count on success
|
|
|
|
**/
|
2006-08-19 05:47:18 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2006-08-19 05:47:18 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2006-08-19 05:47:18 +08:00
|
|
|
struct completion online_compl;
|
|
|
|
int stat1=0, stat2=0;
|
|
|
|
unsigned int i, j, cnt=count;
|
|
|
|
u8 wwpn[8];
|
|
|
|
|
2008-01-11 14:52:48 +08:00
|
|
|
if (!phba->cfg_enable_hba_reset)
|
|
|
|
return -EACCES;
|
2007-10-28 01:38:11 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
|
|
|
if (phba->over_temp_state == HBA_OVER_TEMP) {
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2008-01-11 14:52:54 +08:00
|
|
|
return -EACCES;
|
2007-10-28 01:38:11 +08:00
|
|
|
}
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2006-08-19 05:47:18 +08:00
|
|
|
/* count may include a LF at end of string */
|
|
|
|
if (buf[cnt-1] == '\n')
|
|
|
|
cnt--;
|
|
|
|
|
2006-12-03 02:35:30 +08:00
|
|
|
if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
|
2006-08-19 05:47:18 +08:00
|
|
|
((cnt == 17) && (*buf++ != 'x')) ||
|
|
|
|
((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-12-03 02:35:30 +08:00
|
|
|
phba->soft_wwn_enable = 0;
|
2006-08-19 05:47:18 +08:00
|
|
|
|
|
|
|
memset(wwpn, 0, sizeof(wwpn));
|
|
|
|
|
|
|
|
/* Validate and store the new name */
|
|
|
|
for (i=0, j=0; i < 16; i++) {
|
|
|
|
if ((*buf >= 'a') && (*buf <= 'f'))
|
|
|
|
j = ((j << 4) | ((*buf++ -'a') + 10));
|
|
|
|
else if ((*buf >= 'A') && (*buf <= 'F'))
|
|
|
|
j = ((j << 4) | ((*buf++ -'A') + 10));
|
|
|
|
else if ((*buf >= '0') && (*buf <= '9'))
|
|
|
|
j = ((j << 4) | (*buf++ -'0'));
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
if (i % 2) {
|
|
|
|
wwpn[i/2] = j & 0xff;
|
|
|
|
j = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
phba->cfg_soft_wwpn = wwn_to_u64(wwpn);
|
2007-06-18 08:56:36 +08:00
|
|
|
fc_host_port_name(shost) = phba->cfg_soft_wwpn;
|
2006-12-03 02:35:30 +08:00
|
|
|
if (phba->cfg_soft_wwnn)
|
2007-06-18 08:56:36 +08:00
|
|
|
fc_host_node_name(shost) = phba->cfg_soft_wwnn;
|
2006-08-19 05:47:18 +08:00
|
|
|
|
|
|
|
dev_printk(KERN_NOTICE, &phba->pcidev->dev,
|
|
|
|
"lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no);
|
|
|
|
|
2007-04-25 21:51:45 +08:00
|
|
|
stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
|
2006-08-19 05:47:18 +08:00
|
|
|
if (stat1)
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
2007-08-02 23:10:09 +08:00
|
|
|
"0463 lpfc_soft_wwpn attribute set failed to "
|
|
|
|
"reinit adapter - %d\n", stat1);
|
2006-08-19 05:47:18 +08:00
|
|
|
init_completion(&online_compl);
|
|
|
|
lpfc_workq_post_event(phba, &stat2, &online_compl, LPFC_EVT_ONLINE);
|
|
|
|
wait_for_completion(&online_compl);
|
|
|
|
if (stat2)
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
2007-08-02 23:10:09 +08:00
|
|
|
"0464 lpfc_soft_wwpn attribute set failed to "
|
|
|
|
"reinit adapter - %d\n", stat2);
|
2006-08-19 05:47:18 +08:00
|
|
|
return (stat1 || stat2) ? -EIO : count;
|
|
|
|
}
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\
|
|
|
|
lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
|
2006-08-19 05:47:18 +08:00
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_soft_wwnn_show: Return the cfg soft ww node name for the adapter.
|
|
|
|
* @dev: class device that is converted into a Scsi_host.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the wwnn in hexidecimal.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2006-12-03 02:35:30 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2006-12-03 02:35:30 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-08-02 23:10:31 +08:00
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
2006-12-03 02:35:30 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "0x%llx\n",
|
|
|
|
(unsigned long long)phba->cfg_soft_wwnn);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_soft_wwnn_store: sets the ww node name of the adapter.
|
|
|
|
* @cdev: class device that is converted into a Scsi_host.
|
|
|
|
* @buf: contains the ww node name in hexidecimal.
|
|
|
|
* @count: number of wwnn bytes in buf.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -EINVAL soft wwn not enabled, count is invalid, invalid wwnn byte invalid
|
|
|
|
* value of count on success
|
|
|
|
**/
|
2006-12-03 02:35:30 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2006-12-03 02:35:30 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-08-02 23:10:31 +08:00
|
|
|
struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
|
2006-12-03 02:35:30 +08:00
|
|
|
unsigned int i, j, cnt=count;
|
|
|
|
u8 wwnn[8];
|
|
|
|
|
|
|
|
/* count may include a LF at end of string */
|
|
|
|
if (buf[cnt-1] == '\n')
|
|
|
|
cnt--;
|
|
|
|
|
|
|
|
if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
|
|
|
|
((cnt == 17) && (*buf++ != 'x')) ||
|
|
|
|
((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allow wwnn to be set many times, as long as the enable is set.
|
|
|
|
* However, once the wwpn is set, everything locks.
|
|
|
|
*/
|
|
|
|
|
|
|
|
memset(wwnn, 0, sizeof(wwnn));
|
|
|
|
|
|
|
|
/* Validate and store the new name */
|
|
|
|
for (i=0, j=0; i < 16; i++) {
|
|
|
|
if ((*buf >= 'a') && (*buf <= 'f'))
|
|
|
|
j = ((j << 4) | ((*buf++ -'a') + 10));
|
|
|
|
else if ((*buf >= 'A') && (*buf <= 'F'))
|
|
|
|
j = ((j << 4) | ((*buf++ -'A') + 10));
|
|
|
|
else if ((*buf >= '0') && (*buf <= '9'))
|
|
|
|
j = ((j << 4) | (*buf++ -'0'));
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
if (i % 2) {
|
|
|
|
wwnn[i/2] = j & 0xff;
|
|
|
|
j = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
phba->cfg_soft_wwnn = wwn_to_u64(wwnn);
|
|
|
|
|
|
|
|
dev_printk(KERN_NOTICE, &phba->pcidev->dev,
|
|
|
|
"lpfc%d: soft_wwnn set. Value will take effect upon "
|
|
|
|
"setting of the soft_wwpn\n", phba->brd_no);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\
|
|
|
|
lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
|
2006-12-03 02:35:30 +08:00
|
|
|
|
2006-08-19 05:47:18 +08:00
|
|
|
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
static int lpfc_poll = 0;
|
|
|
|
module_param(lpfc_poll, int, 0);
|
|
|
|
MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
|
|
|
|
" 0 - none,"
|
|
|
|
" 1 - poll with interrupts enabled"
|
|
|
|
" 3 - poll and disable FCP ring interrupts");
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
|
|
|
|
lpfc_poll_show, lpfc_poll_store);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-06-18 08:56:38 +08:00
|
|
|
int lpfc_sli_mode = 0;
|
|
|
|
module_param(lpfc_sli_mode, int, 0);
|
|
|
|
MODULE_PARM_DESC(lpfc_sli_mode, "SLI mode selector:"
|
|
|
|
" 0 - auto (SLI-3 if supported),"
|
|
|
|
" 2 - select SLI-2 even on SLI-3 capable HBAs,"
|
|
|
|
" 3 - select SLI-3");
|
|
|
|
|
2007-10-28 01:37:17 +08:00
|
|
|
int lpfc_enable_npiv = 0;
|
|
|
|
module_param(lpfc_enable_npiv, int, 0);
|
|
|
|
MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality");
|
|
|
|
lpfc_param_show(enable_npiv);
|
|
|
|
lpfc_param_init(enable_npiv, 0, 0, 1);
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO,
|
2007-10-28 01:37:17 +08:00
|
|
|
lpfc_enable_npiv_show, NULL);
|
2007-06-18 08:56:38 +08:00
|
|
|
|
2006-08-19 05:47:08 +08:00
|
|
|
/*
|
|
|
|
# lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
|
|
|
|
# until the timer expires. Value range is [0,255]. Default value is 30.
|
|
|
|
*/
|
|
|
|
static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
|
|
|
|
static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
|
|
|
|
module_param(lpfc_nodev_tmo, int, 0);
|
|
|
|
MODULE_PARM_DESC(lpfc_nodev_tmo,
|
|
|
|
"Seconds driver will hold I/O waiting "
|
|
|
|
"for a device to come back");
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* lpfc_nodev_tmo_show: Return the hba dev loss timeout value.
|
|
|
|
* @dev: class converted to a Scsi_host structure.
|
|
|
|
* @attr: device attribute, not used.
|
|
|
|
* @buf: on return contains the dev loss timeout in decimal.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2006-08-19 05:47:08 +08:00
|
|
|
static ssize_t
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2006-08-19 05:47:08 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
2006-08-19 05:47:08 +08:00
|
|
|
int val = 0;
|
2007-08-02 23:09:59 +08:00
|
|
|
val = vport->cfg_devloss_tmo;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
|
2006-08-19 05:47:08 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_nodev_tmo_init: Set the hba nodev timeout value.
|
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
* @val: contains the nodev timeout value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If the devloss tmo is already set then nodev tmo is set to devloss tmo,
|
|
|
|
* a kernel error message is printed and zero is returned.
|
|
|
|
* Else if val is in range then nodev tmo and devloss tmo are set to val.
|
|
|
|
* Otherwise nodev tmo is set to the default value.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero if already set or if val is in range
|
|
|
|
* -EINVAL val out of range
|
|
|
|
**/
|
2006-08-19 05:47:08 +08:00
|
|
|
static int
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
|
|
|
|
{
|
|
|
|
if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
|
|
|
|
vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
|
|
|
|
if (val != LPFC_DEF_DEVLOSS_TMO)
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2008-08-25 09:50:00 +08:00
|
|
|
"0407 Ignoring nodev_tmo module "
|
2007-08-02 23:10:09 +08:00
|
|
|
"parameter because devloss_tmo is "
|
|
|
|
"set.\n");
|
2006-08-19 05:47:08 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_nodev_tmo = val;
|
|
|
|
vport->cfg_devloss_tmo = val;
|
2006-08-19 05:47:08 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
|
|
|
"0400 lpfc_nodev_tmo attribute cannot be set to"
|
|
|
|
" %d, allowed range is [%d, %d]\n",
|
|
|
|
val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
|
2006-08-19 05:47:08 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_update_rport_devloss_tmo: Update dev loss tmo value.
|
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Update all the ndlp's dev loss tmo with the vport devloss tmo value.
|
|
|
|
**/
|
2007-04-25 21:52:34 +08:00
|
|
|
static void
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
|
2007-04-25 21:52:34 +08:00
|
|
|
{
|
2007-06-18 08:56:39 +08:00
|
|
|
struct Scsi_Host *shost;
|
2007-04-25 21:52:34 +08:00
|
|
|
struct lpfc_nodelist *ndlp;
|
|
|
|
|
2007-08-02 23:10:31 +08:00
|
|
|
shost = lpfc_shost_from_vport(vport);
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
|
2008-02-09 07:49:26 +08:00
|
|
|
if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport)
|
2007-08-02 23:10:31 +08:00
|
|
|
ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
2007-04-25 21:52:34 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_nodev_tmo_set: Set the vport nodev tmo and devloss tmo values.
|
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
* @val: contains the tmo value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If the devloss tmo is already set or the vport dev loss tmo has changed
|
|
|
|
* then a kernel error message is printed and zero is returned.
|
|
|
|
* Else if val is in range then nodev tmo and devloss tmo are set to val.
|
|
|
|
* Otherwise nodev tmo is set to the default value.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero if already set or if val is in range
|
|
|
|
* -EINVAL val out of range
|
|
|
|
**/
|
2006-08-19 05:47:08 +08:00
|
|
|
static int
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
|
2006-08-19 05:47:08 +08:00
|
|
|
{
|
2007-08-02 23:09:59 +08:00
|
|
|
if (vport->dev_loss_tmo_changed ||
|
|
|
|
(lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
|
|
|
"0401 Ignoring change to nodev_tmo "
|
|
|
|
"because devloss_tmo is set.\n");
|
2006-08-19 05:47:08 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_nodev_tmo = val;
|
|
|
|
vport->cfg_devloss_tmo = val;
|
|
|
|
lpfc_update_rport_devloss_tmo(vport);
|
2006-08-19 05:47:08 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
|
|
|
"0403 lpfc_nodev_tmo attribute cannot be set to"
|
|
|
|
"%d, allowed range is [%d, %d]\n",
|
|
|
|
val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
|
2006-08-19 05:47:08 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_vport_param_store(nodev_tmo)
|
2006-08-19 05:47:08 +08:00
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
|
|
|
|
lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
|
2006-08-19 05:47:08 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
# lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
|
|
|
|
# disappear until the timer expires. Value range is [0,255]. Default
|
|
|
|
# value is 30.
|
|
|
|
*/
|
|
|
|
module_param(lpfc_devloss_tmo, int, 0);
|
|
|
|
MODULE_PARM_DESC(lpfc_devloss_tmo,
|
|
|
|
"Seconds driver will hold I/O waiting "
|
|
|
|
"for a device to come back");
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
|
|
|
|
LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
|
|
|
|
lpfc_vport_param_show(devloss_tmo)
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* lpfc_devloss_tmo_set: Sets vport nodev tmo, devloss tmo values, changed bit.
|
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
* @val: contains the tmo value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If val is in a valid range then set the vport nodev tmo,
|
|
|
|
* devloss tmo, also set the vport dev loss tmo changed flag.
|
|
|
|
* Else a kernel error message is printed.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero if val is in range
|
|
|
|
* -EINVAL val out of range
|
|
|
|
**/
|
2006-08-19 05:47:08 +08:00
|
|
|
static int
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
|
2006-08-19 05:47:08 +08:00
|
|
|
{
|
|
|
|
if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_nodev_tmo = val;
|
|
|
|
vport->cfg_devloss_tmo = val;
|
|
|
|
vport->dev_loss_tmo_changed = 1;
|
|
|
|
lpfc_update_rport_devloss_tmo(vport);
|
2006-08-19 05:47:08 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
|
|
|
"0404 lpfc_devloss_tmo attribute cannot be set to"
|
|
|
|
" %d, allowed range is [%d, %d]\n",
|
|
|
|
val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
|
2006-08-19 05:47:08 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_vport_param_store(devloss_tmo)
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
|
|
|
|
lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
|
2006-08-19 05:47:08 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
# lpfc_log_verbose: Only turn this flag on if you are willing to risk being
|
|
|
|
# deluged with LOTS of information.
|
|
|
|
# You can set a bit mask to record specific types of verbose messages:
|
|
|
|
#
|
|
|
|
# LOG_ELS 0x1 ELS events
|
|
|
|
# LOG_DISCOVERY 0x2 Link discovery events
|
|
|
|
# LOG_MBOX 0x4 Mailbox events
|
|
|
|
# LOG_INIT 0x8 Initialization events
|
|
|
|
# LOG_LINK_EVENT 0x10 Link events
|
|
|
|
# LOG_FCP 0x40 FCP traffic history
|
|
|
|
# LOG_NODE 0x80 Node table events
|
|
|
|
# LOG_MISC 0x400 Miscellaneous events
|
|
|
|
# LOG_SLI 0x800 SLI events
|
2006-12-03 02:34:42 +08:00
|
|
|
# LOG_FCP_ERROR 0x1000 Only log FCP errors
|
2005-04-18 05:05:31 +08:00
|
|
|
# LOG_LIBDFC 0x2000 LIBDFC events
|
|
|
|
# LOG_ALL_MSG 0xffff LOG all messages
|
|
|
|
*/
|
2007-08-02 23:10:09 +08:00
|
|
|
LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffff,
|
|
|
|
"Verbose logging bit-mask");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-10-28 01:37:17 +08:00
|
|
|
/*
|
|
|
|
# lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
|
|
|
|
# objects that have been registered with the nameserver after login.
|
|
|
|
*/
|
|
|
|
LPFC_VPORT_ATTR_R(enable_da_id, 0, 0, 1,
|
|
|
|
"Deregister nameserver objects before LOGO");
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
# lun_queue_depth: This parameter is used to limit the number of outstanding
|
|
|
|
# commands per FCP LUN. Value range is [1,128]. Default value is 30.
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 128,
|
|
|
|
"Max number of FCP commands we can queue to a specific LUN");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2006-03-01 08:25:21 +08:00
|
|
|
/*
|
|
|
|
# hba_queue_depth: This parameter is used to limit the number of outstanding
|
|
|
|
# commands per lpfc HBA. Value range is [32,8192]. If this parameter
|
|
|
|
# value is greater than the maximum number of exchanges supported by the HBA,
|
|
|
|
# then maximum number of exchanges supported by the HBA is used to determine
|
|
|
|
# the hba_queue_depth.
|
|
|
|
*/
|
|
|
|
LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
|
|
|
|
"Max number of FCP commands we can queue to a lpfc HBA");
|
|
|
|
|
2007-06-18 08:56:38 +08:00
|
|
|
/*
|
|
|
|
# peer_port_login: This parameter allows/prevents logins
|
|
|
|
# between peer ports hosted on the same physical port.
|
|
|
|
# When this parameter is set 0 peer ports of same physical port
|
|
|
|
# are not allowed to login to each other.
|
|
|
|
# When this parameter is set 1 peer ports of same physical port
|
|
|
|
# are allowed to login to each other.
|
|
|
|
# Default value of this parameter is 0.
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
|
|
|
|
"Allow peer ports on the same physical port to login to each "
|
|
|
|
"other.");
|
2007-06-18 08:56:38 +08:00
|
|
|
|
|
|
|
/*
|
2007-08-02 23:09:59 +08:00
|
|
|
# restrict_login: This parameter allows/prevents logins
|
2007-06-18 08:56:38 +08:00
|
|
|
# between Virtual Ports and remote initiators.
|
|
|
|
# When this parameter is not set (0) Virtual Ports will accept PLOGIs from
|
|
|
|
# other initiators and will attempt to PLOGI all remote ports.
|
|
|
|
# When this parameter is set (1) Virtual Ports will reject PLOGIs from
|
|
|
|
# remote ports and will not attempt to PLOGI to other initiators.
|
|
|
|
# This parameter does not restrict to the physical port.
|
|
|
|
# This parameter does not restrict logins to Fabric resident remote ports.
|
|
|
|
# Default value of this parameter is 1.
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
static int lpfc_restrict_login = 1;
|
|
|
|
module_param(lpfc_restrict_login, int, 0);
|
|
|
|
MODULE_PARM_DESC(lpfc_restrict_login,
|
|
|
|
"Restrict virtual ports login to remote initiators.");
|
|
|
|
lpfc_vport_param_show(restrict_login);
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_restrict_login_init: Set the vport restrict login flag.
|
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
* @val: contains the restrict login value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If val is not in a valid range then log a kernel error message and set
|
|
|
|
* the vport restrict login to one.
|
|
|
|
* If the port type is physical clear the restrict login flag and return.
|
|
|
|
* Else set the restrict login flag to val.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero if val is in range
|
|
|
|
* -EINVAL val out of range
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
static int
|
|
|
|
lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
|
|
|
|
{
|
|
|
|
if (val < 0 || val > 1) {
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2008-08-25 09:50:00 +08:00
|
|
|
"0422 lpfc_restrict_login attribute cannot "
|
2007-08-02 23:10:09 +08:00
|
|
|
"be set to %d, allowed range is [0, 1]\n",
|
|
|
|
val);
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_restrict_login = 1;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (vport->port_type == LPFC_PHYSICAL_PORT) {
|
|
|
|
vport->cfg_restrict_login = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
vport->cfg_restrict_login = val;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_restrict_login_set: Set the vport restrict login flag.
|
|
|
|
* @vport: lpfc vport structure pointer.
|
|
|
|
* @val: contains the restrict login value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If val is not in a valid range then log a kernel error message and set
|
|
|
|
* the vport restrict login to one.
|
|
|
|
* If the port type is physical and the val is not zero log a kernel
|
|
|
|
* error message, clear the restrict login flag and return zero.
|
|
|
|
* Else set the restrict login flag to val.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero if val is in range
|
|
|
|
* -EINVAL val out of range
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
static int
|
|
|
|
lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
|
|
|
|
{
|
|
|
|
if (val < 0 || val > 1) {
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
2008-08-25 09:50:00 +08:00
|
|
|
"0425 lpfc_restrict_login attribute cannot "
|
2007-08-02 23:10:09 +08:00
|
|
|
"be set to %d, allowed range is [0, 1]\n",
|
|
|
|
val);
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_restrict_login = 1;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
|
|
|
|
"0468 lpfc_restrict_login must be 0 for "
|
|
|
|
"Physical ports.\n");
|
2007-08-02 23:09:59 +08:00
|
|
|
vport->cfg_restrict_login = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
vport->cfg_restrict_login = val;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
lpfc_vport_param_store(restrict_login);
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
|
|
|
|
lpfc_restrict_login_show, lpfc_restrict_login_store);
|
2007-06-18 08:56:38 +08:00
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
# Some disk devices have a "select ID" or "select Target" capability.
|
|
|
|
# From a protocol standpoint "select ID" usually means select the
|
|
|
|
# Fibre channel "ALPA". In the FC-AL Profile there is an "informative
|
|
|
|
# annex" which contains a table that maps a "select ID" (a number
|
|
|
|
# between 0 and 7F) to an ALPA. By default, for compatibility with
|
|
|
|
# older drivers, the lpfc driver scans this table from low ALPA to high
|
|
|
|
# ALPA.
|
|
|
|
#
|
|
|
|
# Turning on the scan-down variable (on = 1, off = 0) will
|
|
|
|
# cause the lpfc driver to use an inverted table, effectively
|
|
|
|
# scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
|
|
|
|
#
|
|
|
|
# (Note: This "select ID" functionality is a LOOP ONLY characteristic
|
|
|
|
# and will not work across a fabric. Also this parameter will take
|
|
|
|
# effect only in the case when ALPA map is not available.)
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
|
|
|
|
"Start scanning for devices from highest ALPA to lowest");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
# lpfc_topology: link topology for init link
|
|
|
|
# 0x0 = attempt loop mode then point-to-point
|
2006-03-01 08:25:32 +08:00
|
|
|
# 0x01 = internal loopback mode
|
2005-04-18 05:05:31 +08:00
|
|
|
# 0x02 = attempt point-to-point mode only
|
|
|
|
# 0x04 = attempt loop mode only
|
|
|
|
# 0x06 = attempt point-to-point mode then loop
|
|
|
|
# Set point-to-point mode if you want to run as an N_Port.
|
|
|
|
# Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
|
|
|
|
# Default value is 0.
|
|
|
|
*/
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* lpfc_topology_set: Set the adapters topology field.
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
* @val: topology value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If val is in a valid range then set the adapter's topology field and
|
|
|
|
* issue a lip; if the lip fails reset the topology to the old value.
|
|
|
|
*
|
|
|
|
* If the value is not in range log a kernel error message and return an error.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero if val is in range and lip okay
|
|
|
|
* non-zero return value from lpfc_issue_lip()
|
|
|
|
* -EINVAL val out of range
|
|
|
|
**/
|
2008-01-11 14:53:09 +08:00
|
|
|
static int
|
|
|
|
lpfc_topology_set(struct lpfc_hba *phba, int val)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
uint32_t prev_val;
|
|
|
|
if (val >= 0 && val <= 6) {
|
|
|
|
prev_val = phba->cfg_topology;
|
|
|
|
phba->cfg_topology = val;
|
|
|
|
err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
|
|
|
|
if (err)
|
|
|
|
phba->cfg_topology = prev_val;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
"%d:0467 lpfc_topology attribute cannot be set to %d, "
|
|
|
|
"allowed range is [0, 6]\n",
|
|
|
|
phba->brd_no, val);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
static int lpfc_topology = 0;
|
|
|
|
module_param(lpfc_topology, int, 0);
|
|
|
|
MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology");
|
|
|
|
lpfc_param_show(topology)
|
|
|
|
lpfc_param_init(topology, 0, 0, 6)
|
|
|
|
lpfc_param_store(topology)
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR,
|
2008-01-11 14:53:09 +08:00
|
|
|
lpfc_topology_show, lpfc_topology_store);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2008-09-07 23:52:10 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* lpfc_stat_data_ctrl_store: write call back for lpfc_stat_data_ctrl
|
|
|
|
* sysfs file.
|
|
|
|
* @dev: Pointer to class device.
|
|
|
|
* @buf: Data buffer.
|
|
|
|
* @count: Size of the data buffer.
|
|
|
|
*
|
|
|
|
* This function get called when an user write to the lpfc_stat_data_ctrl
|
|
|
|
* sysfs file. This function parse the command written to the sysfs file
|
|
|
|
* and take appropriate action. These commands are used for controlling
|
|
|
|
* driver statistical data collection.
|
|
|
|
* Following are the command this function handles.
|
|
|
|
*
|
|
|
|
* setbucket <bucket_type> <base> <step>
|
|
|
|
* = Set the latency buckets.
|
|
|
|
* destroybucket = destroy all the buckets.
|
|
|
|
* start = start data collection
|
|
|
|
* stop = stop data collection
|
|
|
|
* reset = reset the collected data
|
|
|
|
**/
|
|
|
|
static ssize_t
|
|
|
|
lpfc_stat_data_ctrl_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
#define LPFC_MAX_DATA_CTRL_LEN 1024
|
|
|
|
static char bucket_data[LPFC_MAX_DATA_CTRL_LEN];
|
|
|
|
unsigned long i;
|
|
|
|
char *str_ptr, *token;
|
|
|
|
struct lpfc_vport **vports;
|
|
|
|
struct Scsi_Host *v_shost;
|
|
|
|
char *bucket_type_str, *base_str, *step_str;
|
|
|
|
unsigned long base, step, bucket_type;
|
|
|
|
|
|
|
|
if (!strncmp(buf, "setbucket", strlen("setbucket"))) {
|
|
|
|
if (strlen(buf) > LPFC_MAX_DATA_CTRL_LEN)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
strcpy(bucket_data, buf);
|
|
|
|
str_ptr = &bucket_data[0];
|
|
|
|
/* Ignore this token - this is command token */
|
|
|
|
token = strsep(&str_ptr, "\t ");
|
|
|
|
if (!token)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
bucket_type_str = strsep(&str_ptr, "\t ");
|
|
|
|
if (!bucket_type_str)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!strncmp(bucket_type_str, "linear", strlen("linear")))
|
|
|
|
bucket_type = LPFC_LINEAR_BUCKET;
|
|
|
|
else if (!strncmp(bucket_type_str, "power2", strlen("power2")))
|
|
|
|
bucket_type = LPFC_POWER2_BUCKET;
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
base_str = strsep(&str_ptr, "\t ");
|
|
|
|
if (!base_str)
|
|
|
|
return -EINVAL;
|
|
|
|
base = simple_strtoul(base_str, NULL, 0);
|
|
|
|
|
|
|
|
step_str = strsep(&str_ptr, "\t ");
|
|
|
|
if (!step_str)
|
|
|
|
return -EINVAL;
|
|
|
|
step = simple_strtoul(step_str, NULL, 0);
|
|
|
|
if (!step)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Block the data collection for every vport */
|
|
|
|
vports = lpfc_create_vport_work_array(phba);
|
|
|
|
if (vports == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
|
|
|
|
v_shost = lpfc_shost_from_vport(vports[i]);
|
|
|
|
spin_lock_irq(v_shost->host_lock);
|
|
|
|
/* Block and reset data collection */
|
|
|
|
vports[i]->stat_data_blocked = 1;
|
|
|
|
if (vports[i]->stat_data_enabled)
|
|
|
|
lpfc_vport_reset_stat_data(vports[i]);
|
|
|
|
spin_unlock_irq(v_shost->host_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set the bucket attributes */
|
|
|
|
phba->bucket_type = bucket_type;
|
|
|
|
phba->bucket_base = base;
|
|
|
|
phba->bucket_step = step;
|
|
|
|
|
|
|
|
for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
|
|
|
|
v_shost = lpfc_shost_from_vport(vports[i]);
|
|
|
|
|
|
|
|
/* Unblock data collection */
|
|
|
|
spin_lock_irq(v_shost->host_lock);
|
|
|
|
vports[i]->stat_data_blocked = 0;
|
|
|
|
spin_unlock_irq(v_shost->host_lock);
|
|
|
|
}
|
|
|
|
lpfc_destroy_vport_work_array(phba, vports);
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strncmp(buf, "destroybucket", strlen("destroybucket"))) {
|
|
|
|
vports = lpfc_create_vport_work_array(phba);
|
|
|
|
if (vports == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
|
|
|
|
v_shost = lpfc_shost_from_vport(vports[i]);
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
vports[i]->stat_data_blocked = 1;
|
|
|
|
lpfc_free_bucket(vport);
|
|
|
|
vport->stat_data_enabled = 0;
|
|
|
|
vports[i]->stat_data_blocked = 0;
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
}
|
|
|
|
lpfc_destroy_vport_work_array(phba, vports);
|
|
|
|
phba->bucket_type = LPFC_NO_BUCKET;
|
|
|
|
phba->bucket_base = 0;
|
|
|
|
phba->bucket_step = 0;
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strncmp(buf, "start", strlen("start"))) {
|
|
|
|
/* If no buckets configured return error */
|
|
|
|
if (phba->bucket_type == LPFC_NO_BUCKET)
|
|
|
|
return -EINVAL;
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
if (vport->stat_data_enabled) {
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
lpfc_alloc_bucket(vport);
|
|
|
|
vport->stat_data_enabled = 1;
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strncmp(buf, "stop", strlen("stop"))) {
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
if (vport->stat_data_enabled == 0) {
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
lpfc_free_bucket(vport);
|
|
|
|
vport->stat_data_enabled = 0;
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strncmp(buf, "reset", strlen("reset"))) {
|
|
|
|
if ((phba->bucket_type == LPFC_NO_BUCKET)
|
|
|
|
|| !vport->stat_data_enabled)
|
|
|
|
return strlen(buf);
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
vport->stat_data_blocked = 1;
|
|
|
|
lpfc_vport_reset_stat_data(vport);
|
|
|
|
vport->stat_data_blocked = 0;
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* lpfc_stat_data_ctrl_show: Read callback function for
|
|
|
|
* lpfc_stat_data_ctrl sysfs file.
|
|
|
|
* @dev: Pointer to class device object.
|
|
|
|
* @buf: Data buffer.
|
|
|
|
*
|
|
|
|
* This function is the read call back function for
|
|
|
|
* lpfc_stat_data_ctrl sysfs file. This function report the
|
|
|
|
* current statistical data collection state.
|
|
|
|
**/
|
|
|
|
static ssize_t
|
|
|
|
lpfc_stat_data_ctrl_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
int index = 0;
|
|
|
|
int i;
|
|
|
|
char *bucket_type;
|
|
|
|
unsigned long bucket_value;
|
|
|
|
|
|
|
|
switch (phba->bucket_type) {
|
|
|
|
case LPFC_LINEAR_BUCKET:
|
|
|
|
bucket_type = "linear";
|
|
|
|
break;
|
|
|
|
case LPFC_POWER2_BUCKET:
|
|
|
|
bucket_type = "power2";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
bucket_type = "No Bucket";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
sprintf(&buf[index], "Statistical Data enabled :%d, "
|
|
|
|
"blocked :%d, Bucket type :%s, Bucket base :%d,"
|
|
|
|
" Bucket step :%d\nLatency Ranges :",
|
|
|
|
vport->stat_data_enabled, vport->stat_data_blocked,
|
|
|
|
bucket_type, phba->bucket_base, phba->bucket_step);
|
|
|
|
index = strlen(buf);
|
|
|
|
if (phba->bucket_type != LPFC_NO_BUCKET) {
|
|
|
|
for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
|
|
|
|
if (phba->bucket_type == LPFC_LINEAR_BUCKET)
|
|
|
|
bucket_value = phba->bucket_base +
|
|
|
|
phba->bucket_step * i;
|
|
|
|
else
|
|
|
|
bucket_value = phba->bucket_base +
|
|
|
|
(1 << i) * phba->bucket_step;
|
|
|
|
|
|
|
|
if (index + 10 > PAGE_SIZE)
|
|
|
|
break;
|
|
|
|
sprintf(&buf[index], "%08ld ", bucket_value);
|
|
|
|
index = strlen(buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sprintf(&buf[index], "\n");
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sysfs attribute to control the statistical data collection.
|
|
|
|
*/
|
|
|
|
static DEVICE_ATTR(lpfc_stat_data_ctrl, S_IRUGO | S_IWUSR,
|
|
|
|
lpfc_stat_data_ctrl_show, lpfc_stat_data_ctrl_store);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lpfc_drvr_stat_data: sysfs attr to get driver statistical data.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Each Bucket takes 11 characters and 1 new line + 17 bytes WWN
|
|
|
|
* for each target.
|
|
|
|
*/
|
|
|
|
#define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18)
|
|
|
|
#define MAX_STAT_DATA_SIZE_PER_TARGET \
|
|
|
|
STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT)
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sysfs_drvr_stat_data_read: Read callback function for lpfc_drvr_stat_data
|
|
|
|
* sysfs attribute.
|
|
|
|
* @kobj: Pointer to the kernel object
|
|
|
|
* @bin_attr: Attribute object
|
|
|
|
* @buff: Buffer pointer
|
|
|
|
* @off: File offset
|
|
|
|
* @count: Buffer size
|
|
|
|
*
|
|
|
|
* This function is the read call back function for lpfc_drvr_stat_data
|
|
|
|
* sysfs file. This function export the statistical data to user
|
|
|
|
* applications.
|
|
|
|
**/
|
|
|
|
static ssize_t
|
|
|
|
sysfs_drvr_stat_data_read(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
|
|
|
{
|
|
|
|
struct device *dev = container_of(kobj, struct device,
|
|
|
|
kobj);
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
int i = 0, index = 0;
|
|
|
|
unsigned long nport_index;
|
|
|
|
struct lpfc_nodelist *ndlp = NULL;
|
|
|
|
nport_index = (unsigned long)off /
|
|
|
|
MAX_STAT_DATA_SIZE_PER_TARGET;
|
|
|
|
|
|
|
|
if (!vport->stat_data_enabled || vport->stat_data_blocked
|
|
|
|
|| (phba->bucket_type == LPFC_NO_BUCKET))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
|
|
|
|
if (!NLP_CHK_NODE_ACT(ndlp) || !ndlp->lat_data)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (nport_index > 0) {
|
|
|
|
nport_index--;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((index + MAX_STAT_DATA_SIZE_PER_TARGET)
|
|
|
|
> count)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!ndlp->lat_data)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Print the WWN */
|
|
|
|
sprintf(&buf[index], "%02x%02x%02x%02x%02x%02x%02x%02x:",
|
|
|
|
ndlp->nlp_portname.u.wwn[0],
|
|
|
|
ndlp->nlp_portname.u.wwn[1],
|
|
|
|
ndlp->nlp_portname.u.wwn[2],
|
|
|
|
ndlp->nlp_portname.u.wwn[3],
|
|
|
|
ndlp->nlp_portname.u.wwn[4],
|
|
|
|
ndlp->nlp_portname.u.wwn[5],
|
|
|
|
ndlp->nlp_portname.u.wwn[6],
|
|
|
|
ndlp->nlp_portname.u.wwn[7]);
|
|
|
|
|
|
|
|
index = strlen(buf);
|
|
|
|
|
|
|
|
for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
|
|
|
|
sprintf(&buf[index], "%010u,",
|
|
|
|
ndlp->lat_data[i].cmd_count);
|
|
|
|
index = strlen(buf);
|
|
|
|
}
|
|
|
|
sprintf(&buf[index], "\n");
|
|
|
|
index = strlen(buf);
|
|
|
|
}
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct bin_attribute sysfs_drvr_stat_data_attr = {
|
|
|
|
.attr = {
|
|
|
|
.name = "lpfc_drvr_stat_data",
|
|
|
|
.mode = S_IRUSR,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
},
|
|
|
|
.size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET,
|
|
|
|
.read = sysfs_drvr_stat_data_read,
|
|
|
|
.write = NULL,
|
|
|
|
};
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
# lpfc_link_speed: Link speed selection for initializing the Fibre Channel
|
|
|
|
# connection.
|
|
|
|
# 0 = auto select (default)
|
|
|
|
# 1 = 1 Gigabaud
|
|
|
|
# 2 = 2 Gigabaud
|
|
|
|
# 4 = 4 Gigabaud
|
2007-04-25 21:53:28 +08:00
|
|
|
# 8 = 8 Gigabaud
|
|
|
|
# Value range is [0,8]. Default value is 0.
|
2005-04-18 05:05:31 +08:00
|
|
|
*/
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* lpfc_link_speed_set: Set the adapters link speed.
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
* @val: link speed value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If val is in a valid range then set the adapter's link speed field and
|
|
|
|
* issue a lip; if the lip fails reset the link speed to the old value.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* If the value is not in range log a kernel error message and return an error.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero if val is in range and lip okay.
|
|
|
|
* non-zero return value from lpfc_issue_lip()
|
|
|
|
* -EINVAL val out of range
|
|
|
|
**/
|
2008-01-11 14:53:09 +08:00
|
|
|
static int
|
|
|
|
lpfc_link_speed_set(struct lpfc_hba *phba, int val)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
uint32_t prev_val;
|
|
|
|
|
|
|
|
if (((val == LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
|
|
|
|
((val == LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
|
|
|
|
((val == LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
|
|
|
|
((val == LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
|
|
|
|
((val == LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if ((val >= 0 && val <= LPFC_MAX_LINK_SPEED)
|
|
|
|
&& (LPFC_LINK_SPEED_BITMAP & (1 << val))) {
|
|
|
|
prev_val = phba->cfg_link_speed;
|
|
|
|
phba->cfg_link_speed = val;
|
|
|
|
err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
|
|
|
|
if (err)
|
|
|
|
phba->cfg_link_speed = prev_val;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
|
|
|
"%d:0469 lpfc_link_speed attribute cannot be set to %d, "
|
|
|
|
"allowed range is [0, 8]\n",
|
|
|
|
phba->brd_no, val);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int lpfc_link_speed = 0;
|
|
|
|
module_param(lpfc_link_speed, int, 0);
|
|
|
|
MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
|
|
|
|
lpfc_param_show(link_speed)
|
2008-08-25 09:49:00 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* lpfc_link_speed_init: Set the adapters link speed.
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
* @val: link speed value.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If val is in a valid range then set the adapter's link speed field.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* If the value is not in range log a kernel error message, clear the link
|
|
|
|
* speed and return an error.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* zero if val saved.
|
|
|
|
* -EINVAL val out of range
|
|
|
|
**/
|
2008-01-11 14:53:09 +08:00
|
|
|
static int
|
|
|
|
lpfc_link_speed_init(struct lpfc_hba *phba, int val)
|
|
|
|
{
|
|
|
|
if ((val >= 0 && val <= LPFC_MAX_LINK_SPEED)
|
|
|
|
&& (LPFC_LINK_SPEED_BITMAP & (1 << val))) {
|
|
|
|
phba->cfg_link_speed = val;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
|
2008-08-25 09:50:00 +08:00
|
|
|
"0405 lpfc_link_speed attribute cannot "
|
2008-01-11 14:53:09 +08:00
|
|
|
"be set to %d, allowed values are "
|
|
|
|
"["LPFC_LINK_SPEED_STRING"]\n", val);
|
|
|
|
phba->cfg_link_speed = 0;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
lpfc_param_store(link_speed)
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
|
2008-01-11 14:53:09 +08:00
|
|
|
lpfc_link_speed_show, lpfc_link_speed_store);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
# lpfc_fcp_class: Determines FC class to use for the FCP protocol.
|
|
|
|
# Value range is [2,3]. Default value is 3.
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
|
|
|
|
"Select Fibre Channel class of service for FCP sequences");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
# lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
|
|
|
|
# is [0,1]. Default value is 0.
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1,
|
|
|
|
"Use ADISC on rediscovery to authenticate FCP devices");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2008-09-07 23:52:04 +08:00
|
|
|
/*
|
|
|
|
# lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
|
|
|
|
# depth. Default value is 0. When the value of this parameter is zero the
|
|
|
|
# SCSI command completion time is not used for controlling I/O queue depth. When
|
|
|
|
# the parameter is set to a non-zero value, the I/O queue depth is controlled
|
|
|
|
# to limit the I/O completion time to the parameter value.
|
|
|
|
# The value is set in milliseconds.
|
|
|
|
*/
|
|
|
|
static int lpfc_max_scsicmpl_time;
|
|
|
|
module_param(lpfc_max_scsicmpl_time, int, 0);
|
|
|
|
MODULE_PARM_DESC(lpfc_max_scsicmpl_time,
|
|
|
|
"Use command completion time to control queue depth");
|
|
|
|
lpfc_vport_param_show(max_scsicmpl_time);
|
|
|
|
lpfc_vport_param_init(max_scsicmpl_time, 0, 0, 60000);
|
|
|
|
static int
|
|
|
|
lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
|
|
|
|
struct lpfc_nodelist *ndlp, *next_ndlp;
|
|
|
|
|
|
|
|
if (val == vport->cfg_max_scsicmpl_time)
|
|
|
|
return 0;
|
|
|
|
if ((val < 0) || (val > 60000))
|
|
|
|
return -EINVAL;
|
|
|
|
vport->cfg_max_scsicmpl_time = val;
|
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
|
|
|
|
if (!NLP_CHK_NODE_ACT(ndlp))
|
|
|
|
continue;
|
|
|
|
if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
|
|
|
|
continue;
|
|
|
|
ndlp->cmd_qdepth = LPFC_MAX_TGT_QDEPTH;
|
|
|
|
}
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
lpfc_vport_param_store(max_scsicmpl_time);
|
|
|
|
static DEVICE_ATTR(lpfc_max_scsicmpl_time, S_IRUGO | S_IWUSR,
|
|
|
|
lpfc_max_scsicmpl_time_show,
|
|
|
|
lpfc_max_scsicmpl_time_store);
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
# lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
|
|
|
|
# range is [0,1]. Default value is 0.
|
|
|
|
*/
|
|
|
|
LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
|
|
|
|
|
|
|
|
/*
|
|
|
|
# lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
|
|
|
|
# cr_delay (msec) or cr_count outstanding commands. cr_delay can take
|
2007-04-25 21:52:34 +08:00
|
|
|
# value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
|
2005-04-18 05:05:31 +08:00
|
|
|
# is 0. Default value of cr_count is 1. The cr_count feature is disabled if
|
|
|
|
# cr_delay is set to 0.
|
|
|
|
*/
|
2006-03-01 08:25:35 +08:00
|
|
|
LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
|
2005-04-18 05:05:31 +08:00
|
|
|
"interrupt response is generated");
|
|
|
|
|
2006-03-01 08:25:35 +08:00
|
|
|
LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
|
2005-04-18 05:05:31 +08:00
|
|
|
"interrupt response is generated");
|
|
|
|
|
2006-03-01 11:33:08 +08:00
|
|
|
/*
|
|
|
|
# lpfc_multi_ring_support: Determines how many rings to spread available
|
|
|
|
# cmd/rsp IOCB entries across.
|
|
|
|
# Value range is [1,2]. Default value is 1.
|
|
|
|
*/
|
|
|
|
LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
|
|
|
|
"SLI rings to spread IOCB entries across");
|
|
|
|
|
2006-12-03 02:34:16 +08:00
|
|
|
/*
|
|
|
|
# lpfc_multi_ring_rctl: If lpfc_multi_ring_support is enabled, this
|
|
|
|
# identifies what rctl value to configure the additional ring for.
|
|
|
|
# Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
|
|
|
|
*/
|
|
|
|
LPFC_ATTR_R(multi_ring_rctl, FC_UNSOL_DATA, 1,
|
|
|
|
255, "Identifies RCTL for additional ring configuration");
|
|
|
|
|
|
|
|
/*
|
|
|
|
# lpfc_multi_ring_type: If lpfc_multi_ring_support is enabled, this
|
|
|
|
# identifies what type value to configure the additional ring for.
|
|
|
|
# Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
|
|
|
|
*/
|
|
|
|
LPFC_ATTR_R(multi_ring_type, FC_LLC_SNAP, 1,
|
|
|
|
255, "Identifies TYPE for additional ring configuration");
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
# lpfc_fdmi_on: controls FDMI support.
|
|
|
|
# 0 = no FDMI support
|
|
|
|
# 1 = support FDMI without attribute of hostname
|
|
|
|
# 2 = support FDMI with attribute of hostname
|
|
|
|
# Value range [0,2]. Default value is 0.
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_RW(fdmi_on, 0, 0, 2, "Enable FDMI support");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
# Specifies the maximum number of ELS cmds we can have outstanding (for
|
|
|
|
# discovery). Value range is [1,64]. Default value = 32.
|
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
|
2005-04-18 05:05:31 +08:00
|
|
|
"during discovery");
|
|
|
|
|
|
|
|
/*
|
2006-07-07 03:50:50 +08:00
|
|
|
# lpfc_max_luns: maximum allowed LUN.
|
|
|
|
# Value range is [0,65535]. Default value is 255.
|
|
|
|
# NOTE: The SCSI layer might probe all allowed LUN on some old targets.
|
2005-04-18 05:05:31 +08:00
|
|
|
*/
|
2007-08-02 23:09:59 +08:00
|
|
|
LPFC_VPORT_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN");
|
2005-04-18 05:05:31 +08:00
|
|
|
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
/*
|
|
|
|
# lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
|
|
|
|
# Value range is [1,255], default value is 10.
|
|
|
|
*/
|
|
|
|
LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
|
|
|
|
"Milliseconds driver will wait between polling FCP ring");
|
|
|
|
|
2006-12-03 02:34:56 +08:00
|
|
|
/*
|
|
|
|
# lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
|
|
|
|
# support this feature
|
2008-08-25 09:50:30 +08:00
|
|
|
# 0 = MSI disabled
|
2006-12-03 02:34:56 +08:00
|
|
|
# 1 = MSI enabled
|
2008-08-25 09:50:30 +08:00
|
|
|
# 2 = MSI-X enabled (default)
|
|
|
|
# Value range is [0,2]. Default value is 2.
|
2006-12-03 02:34:56 +08:00
|
|
|
*/
|
2008-08-25 09:50:30 +08:00
|
|
|
LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
|
2008-02-09 07:49:51 +08:00
|
|
|
"MSI-X (2), if possible");
|
2006-12-03 02:34:56 +08:00
|
|
|
|
2008-01-11 14:52:48 +08:00
|
|
|
/*
|
|
|
|
# lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
|
|
|
|
# 0 = HBA resets disabled
|
|
|
|
# 1 = HBA resets enabled (default)
|
|
|
|
# Value range is [0,1]. Default value is 1.
|
|
|
|
*/
|
|
|
|
LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver.");
|
2006-08-19 05:47:18 +08:00
|
|
|
|
2008-01-11 14:52:48 +08:00
|
|
|
/*
|
|
|
|
# lpfc_enable_hba_heartbeat: Enable HBA heartbeat timer..
|
|
|
|
# 0 = HBA Heartbeat disabled
|
|
|
|
# 1 = HBA Heartbeat enabled (default)
|
|
|
|
# Value range is [0,1]. Default value is 1.
|
|
|
|
*/
|
|
|
|
LPFC_ATTR_R(enable_hba_heartbeat, 1, 0, 1, "Enable HBA Heartbeat.");
|
2007-06-18 08:56:38 +08:00
|
|
|
|
2008-01-11 14:53:09 +08:00
|
|
|
/*
|
|
|
|
* lpfc_sg_seg_cnt: Initial Maximum DMA Segment Count
|
|
|
|
* This value can be set to values between 64 and 256. The default value is
|
|
|
|
* 64, but may be increased to allow for larger Max I/O sizes. The scsi layer
|
|
|
|
* will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).
|
|
|
|
*/
|
|
|
|
LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT,
|
|
|
|
LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device_attribute *lpfc_hba_attrs[] = {
|
|
|
|
&dev_attr_info,
|
|
|
|
&dev_attr_serialnum,
|
|
|
|
&dev_attr_modeldesc,
|
|
|
|
&dev_attr_modelname,
|
|
|
|
&dev_attr_programtype,
|
|
|
|
&dev_attr_portnum,
|
|
|
|
&dev_attr_fwrev,
|
|
|
|
&dev_attr_hdw,
|
|
|
|
&dev_attr_option_rom_version,
|
2008-03-18 21:32:28 +08:00
|
|
|
&dev_attr_link_state,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_num_discovered_ports,
|
2008-08-25 09:50:06 +08:00
|
|
|
&dev_attr_menlo_mgmt_mode,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_lpfc_drvr_version,
|
|
|
|
&dev_attr_lpfc_temp_sensor,
|
|
|
|
&dev_attr_lpfc_log_verbose,
|
|
|
|
&dev_attr_lpfc_lun_queue_depth,
|
|
|
|
&dev_attr_lpfc_hba_queue_depth,
|
|
|
|
&dev_attr_lpfc_peer_port_login,
|
|
|
|
&dev_attr_lpfc_nodev_tmo,
|
|
|
|
&dev_attr_lpfc_devloss_tmo,
|
|
|
|
&dev_attr_lpfc_fcp_class,
|
|
|
|
&dev_attr_lpfc_use_adisc,
|
|
|
|
&dev_attr_lpfc_ack0,
|
|
|
|
&dev_attr_lpfc_topology,
|
|
|
|
&dev_attr_lpfc_scan_down,
|
|
|
|
&dev_attr_lpfc_link_speed,
|
|
|
|
&dev_attr_lpfc_cr_delay,
|
|
|
|
&dev_attr_lpfc_cr_count,
|
|
|
|
&dev_attr_lpfc_multi_ring_support,
|
|
|
|
&dev_attr_lpfc_multi_ring_rctl,
|
|
|
|
&dev_attr_lpfc_multi_ring_type,
|
|
|
|
&dev_attr_lpfc_fdmi_on,
|
|
|
|
&dev_attr_lpfc_max_luns,
|
|
|
|
&dev_attr_lpfc_enable_npiv,
|
|
|
|
&dev_attr_nport_evt_cnt,
|
|
|
|
&dev_attr_board_mode,
|
|
|
|
&dev_attr_max_vpi,
|
|
|
|
&dev_attr_used_vpi,
|
|
|
|
&dev_attr_max_rpi,
|
|
|
|
&dev_attr_used_rpi,
|
|
|
|
&dev_attr_max_xri,
|
|
|
|
&dev_attr_used_xri,
|
|
|
|
&dev_attr_npiv_info,
|
|
|
|
&dev_attr_issue_reset,
|
|
|
|
&dev_attr_lpfc_poll,
|
|
|
|
&dev_attr_lpfc_poll_tmo,
|
|
|
|
&dev_attr_lpfc_use_msi,
|
|
|
|
&dev_attr_lpfc_soft_wwnn,
|
|
|
|
&dev_attr_lpfc_soft_wwpn,
|
|
|
|
&dev_attr_lpfc_soft_wwn_enable,
|
|
|
|
&dev_attr_lpfc_enable_hba_reset,
|
|
|
|
&dev_attr_lpfc_enable_hba_heartbeat,
|
|
|
|
&dev_attr_lpfc_sg_seg_cnt,
|
2008-09-07 23:52:04 +08:00
|
|
|
&dev_attr_lpfc_max_scsicmpl_time,
|
2008-09-07 23:52:10 +08:00
|
|
|
&dev_attr_lpfc_stat_data_ctrl,
|
2005-04-18 05:05:31 +08:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device_attribute *lpfc_vport_attrs[] = {
|
|
|
|
&dev_attr_info,
|
2008-03-18 21:32:28 +08:00
|
|
|
&dev_attr_link_state,
|
2008-02-22 07:13:36 +08:00
|
|
|
&dev_attr_num_discovered_ports,
|
|
|
|
&dev_attr_lpfc_drvr_version,
|
|
|
|
&dev_attr_lpfc_log_verbose,
|
|
|
|
&dev_attr_lpfc_lun_queue_depth,
|
|
|
|
&dev_attr_lpfc_nodev_tmo,
|
|
|
|
&dev_attr_lpfc_devloss_tmo,
|
|
|
|
&dev_attr_lpfc_hba_queue_depth,
|
|
|
|
&dev_attr_lpfc_peer_port_login,
|
|
|
|
&dev_attr_lpfc_restrict_login,
|
|
|
|
&dev_attr_lpfc_fcp_class,
|
|
|
|
&dev_attr_lpfc_use_adisc,
|
|
|
|
&dev_attr_lpfc_fdmi_on,
|
|
|
|
&dev_attr_lpfc_max_luns,
|
|
|
|
&dev_attr_nport_evt_cnt,
|
|
|
|
&dev_attr_npiv_info,
|
|
|
|
&dev_attr_lpfc_enable_da_id,
|
2008-09-07 23:52:10 +08:00
|
|
|
&dev_attr_lpfc_max_scsicmpl_time,
|
|
|
|
&dev_attr_lpfc_stat_data_ctrl,
|
2007-08-02 23:09:59 +08:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* sysfs_ctlreg_write: Write method for writing to ctlreg.
|
|
|
|
* @kobj: kernel kobject that contains the kernel class device.
|
|
|
|
* @bin_attr: kernel attributes passed to us.
|
|
|
|
* @buf: contains the data to be written to the adapter IOREG space.
|
|
|
|
* @off: offset into buffer to beginning of data.
|
|
|
|
* @count: bytes to transfer.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
|
|
|
|
* Uses the adapter io control registers to send buf contents to the adapter.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -ERANGE off and count combo out of range
|
|
|
|
* -EINVAL off, count or buff address invalid
|
|
|
|
* -EPERM adapter is offline
|
|
|
|
* value of count, buf contents written
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2007-06-09 13:57:22 +08:00
|
|
|
sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
|
|
|
size_t buf_off;
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
if ((off + count) > FF_REG_AREA_SIZE)
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
|
|
if (count == 0) return 0;
|
|
|
|
|
|
|
|
if (off % 4 || count % 4 || (unsigned long)buf % 4)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
|
2005-04-18 05:05:31 +08:00
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t))
|
|
|
|
writel(*((uint32_t *)(buf + buf_off)),
|
|
|
|
phba->ctrl_regs_memmap_p + off + buf_off);
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* sysfs_ctlreg_read: Read method for reading from ctlreg.
|
|
|
|
* @kobj: kernel kobject that contains the kernel class device.
|
|
|
|
* @bin_attr: kernel attributes passed to us.
|
|
|
|
* @buf: if succesful contains the data from the adapter IOREG space.
|
|
|
|
* @off: offset into buffer to beginning of data.
|
|
|
|
* @count: bytes to transfer.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
|
|
|
|
* Uses the adapter io control registers to read data into buf.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -ERANGE off and count combo out of range
|
|
|
|
* -EINVAL off, count or buff address invalid
|
|
|
|
* value of count, buf contents read
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2007-06-09 13:57:22 +08:00
|
|
|
sysfs_ctlreg_read(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
|
|
|
size_t buf_off;
|
|
|
|
uint32_t * tmp_ptr;
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
if (off > FF_REG_AREA_SIZE)
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
|
|
if ((off + count) > FF_REG_AREA_SIZE)
|
|
|
|
count = FF_REG_AREA_SIZE - off;
|
|
|
|
|
|
|
|
if (count == 0) return 0;
|
|
|
|
|
|
|
|
if (off % 4 || count % 4 || (unsigned long)buf % 4)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
|
|
|
|
tmp_ptr = (uint32_t *)(buf + buf_off);
|
|
|
|
*tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
|
|
|
|
}
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct bin_attribute sysfs_ctlreg_attr = {
|
|
|
|
.attr = {
|
|
|
|
.name = "ctlreg",
|
|
|
|
.mode = S_IRUSR | S_IWUSR,
|
|
|
|
},
|
|
|
|
.size = 256,
|
|
|
|
.read = sysfs_ctlreg_read,
|
|
|
|
.write = sysfs_ctlreg_write,
|
|
|
|
};
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* sysfs_mbox_idle: frees the sysfs mailbox.
|
|
|
|
* @phba: lpfc_hba pointer
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
2007-06-18 08:56:36 +08:00
|
|
|
sysfs_mbox_idle(struct lpfc_hba *phba)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
|
|
|
phba->sysfs_mbox.state = SMBOX_IDLE;
|
|
|
|
phba->sysfs_mbox.offset = 0;
|
|
|
|
|
|
|
|
if (phba->sysfs_mbox.mbox) {
|
|
|
|
mempool_free(phba->sysfs_mbox.mbox,
|
|
|
|
phba->mbox_mem_pool);
|
|
|
|
phba->sysfs_mbox.mbox = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* sysfs_mbox_write: Write method for writing information via mbox.
|
|
|
|
* @kobj: kernel kobject that contains the kernel class device.
|
|
|
|
* @bin_attr: kernel attributes passed to us.
|
|
|
|
* @buf: contains the data to be written to sysfs mbox.
|
|
|
|
* @off: offset into buffer to beginning of data.
|
|
|
|
* @count: bytes to transfer.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Accessed via /sys/class/scsi_host/hostxxx/mbox.
|
|
|
|
* Uses the sysfs mbox to send buf contents to the adapter.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -ERANGE off and count combo out of range
|
|
|
|
* -EINVAL off, count or buff address invalid
|
|
|
|
* zero if count is zero
|
|
|
|
* -EPERM adapter is offline
|
|
|
|
* -ENOMEM failed to allocate memory for the mail box
|
|
|
|
* -EAGAIN offset, state or mbox is NULL
|
|
|
|
* count number of bytes transferred
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2007-06-09 13:57:22 +08:00
|
|
|
sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
struct lpfcMboxq *mbox = NULL;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
if ((count + off) > MAILBOX_CMD_SIZE)
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
|
|
if (off % 4 || count % 4 || (unsigned long)buf % 4)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (count == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (off == 0) {
|
|
|
|
mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
|
|
if (!mbox)
|
|
|
|
return -ENOMEM;
|
2006-03-08 04:04:19 +08:00
|
|
|
memset(mbox, 0, sizeof (LPFC_MBOXQ_t));
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
if (off == 0) {
|
|
|
|
if (phba->sysfs_mbox.mbox)
|
|
|
|
mempool_free(mbox, phba->mbox_mem_pool);
|
|
|
|
else
|
|
|
|
phba->sysfs_mbox.mbox = mbox;
|
|
|
|
phba->sysfs_mbox.state = SMBOX_WRITING;
|
|
|
|
} else {
|
|
|
|
if (phba->sysfs_mbox.state != SMBOX_WRITING ||
|
|
|
|
phba->sysfs_mbox.offset != off ||
|
2007-06-18 08:56:38 +08:00
|
|
|
phba->sysfs_mbox.mbox == NULL) {
|
2005-04-18 05:05:31 +08:00
|
|
|
sysfs_mbox_idle(phba);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2006-08-01 19:34:00 +08:00
|
|
|
return -EAGAIN;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy((uint8_t *) & phba->sysfs_mbox.mbox->mb + off,
|
|
|
|
buf, count);
|
|
|
|
|
|
|
|
phba->sysfs_mbox.offset = off + count;
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* sysfs_mbox_read: Read method for reading information via mbox.
|
|
|
|
* @kobj: kernel kobject that contains the kernel class device.
|
|
|
|
* @bin_attr: kernel attributes passed to us.
|
|
|
|
* @buf: contains the data to be read from sysfs mbox.
|
|
|
|
* @off: offset into buffer to beginning of data.
|
|
|
|
* @count: bytes to transfer.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Accessed via /sys/class/scsi_host/hostxxx/mbox.
|
|
|
|
* Uses the sysfs mbox to receive data from to the adapter.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* -ERANGE off greater than mailbox command size
|
|
|
|
* -EINVAL off, count or buff address invalid
|
|
|
|
* zero if off and count are zero
|
|
|
|
* -EACCES adapter over temp
|
|
|
|
* -EPERM garbage can value to catch a multitude of errors
|
|
|
|
* -EAGAIN management IO not permitted, state or off error
|
|
|
|
* -ETIME mailbox timeout
|
|
|
|
* -ENODEV mailbox error
|
|
|
|
* count number of bytes transferred
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static ssize_t
|
2007-06-09 13:57:22 +08:00
|
|
|
sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
|
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
int rc;
|
|
|
|
|
2007-04-25 21:51:30 +08:00
|
|
|
if (off > MAILBOX_CMD_SIZE)
|
2005-04-18 05:05:31 +08:00
|
|
|
return -ERANGE;
|
|
|
|
|
2007-04-25 21:51:30 +08:00
|
|
|
if ((count + off) > MAILBOX_CMD_SIZE)
|
|
|
|
count = MAILBOX_CMD_SIZE - off;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
if (off % 4 || count % 4 || (unsigned long)buf % 4)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (off && count == 0)
|
|
|
|
return 0;
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-10-28 01:38:11 +08:00
|
|
|
if (phba->over_temp_state == HBA_OVER_TEMP) {
|
|
|
|
sysfs_mbox_idle(phba);
|
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2008-01-11 14:52:54 +08:00
|
|
|
return -EACCES;
|
2007-10-28 01:38:11 +08:00
|
|
|
}
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
if (off == 0 &&
|
|
|
|
phba->sysfs_mbox.state == SMBOX_WRITING &&
|
|
|
|
phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) {
|
|
|
|
|
|
|
|
switch (phba->sysfs_mbox.mbox->mb.mbxCommand) {
|
|
|
|
/* Offline only */
|
|
|
|
case MBX_INIT_LINK:
|
|
|
|
case MBX_DOWN_LINK:
|
|
|
|
case MBX_CONFIG_LINK:
|
|
|
|
case MBX_CONFIG_RING:
|
|
|
|
case MBX_RESET_RING:
|
|
|
|
case MBX_UNREG_LOGIN:
|
|
|
|
case MBX_CLEAR_LA:
|
|
|
|
case MBX_DUMP_CONTEXT:
|
|
|
|
case MBX_RUN_DIAGS:
|
|
|
|
case MBX_RESTART:
|
|
|
|
case MBX_SET_MASK:
|
|
|
|
case MBX_SET_DEBUG:
|
2007-06-18 08:56:36 +08:00
|
|
|
if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
|
2005-04-18 05:05:31 +08:00
|
|
|
printk(KERN_WARNING "mbox_read:Command 0x%x "
|
|
|
|
"is illegal in on-line state\n",
|
|
|
|
phba->sysfs_mbox.mbox->mb.mbxCommand);
|
|
|
|
sysfs_mbox_idle(phba);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
return -EPERM;
|
|
|
|
}
|
2007-10-28 01:37:53 +08:00
|
|
|
case MBX_WRITE_NV:
|
|
|
|
case MBX_WRITE_VPARMS:
|
2005-04-18 05:05:31 +08:00
|
|
|
case MBX_LOAD_SM:
|
|
|
|
case MBX_READ_NV:
|
|
|
|
case MBX_READ_CONFIG:
|
|
|
|
case MBX_READ_RCONFIG:
|
|
|
|
case MBX_READ_STATUS:
|
|
|
|
case MBX_READ_XRI:
|
|
|
|
case MBX_READ_REV:
|
|
|
|
case MBX_READ_LNK_STAT:
|
|
|
|
case MBX_DUMP_MEMORY:
|
|
|
|
case MBX_DOWN_LOAD:
|
|
|
|
case MBX_UPDATE_CFG:
|
2006-03-01 08:25:27 +08:00
|
|
|
case MBX_KILL_BOARD:
|
2005-04-18 05:05:31 +08:00
|
|
|
case MBX_LOAD_AREA:
|
|
|
|
case MBX_LOAD_EXP_ROM:
|
2006-03-01 08:25:27 +08:00
|
|
|
case MBX_BEACON:
|
|
|
|
case MBX_DEL_LD_ENTRY:
|
2008-01-11 14:52:54 +08:00
|
|
|
case MBX_SET_VARIABLE:
|
|
|
|
case MBX_WRITE_WWN:
|
2008-08-25 09:50:06 +08:00
|
|
|
case MBX_PORT_CAPABILITIES:
|
|
|
|
case MBX_PORT_IOV_CONTROL:
|
2005-04-18 05:05:31 +08:00
|
|
|
break;
|
|
|
|
case MBX_READ_SPARM64:
|
|
|
|
case MBX_READ_LA:
|
|
|
|
case MBX_READ_LA64:
|
|
|
|
case MBX_REG_LOGIN:
|
|
|
|
case MBX_REG_LOGIN64:
|
|
|
|
case MBX_CONFIG_PORT:
|
|
|
|
case MBX_RUN_BIU_DIAG:
|
|
|
|
printk(KERN_WARNING "mbox_read: Illegal Command 0x%x\n",
|
|
|
|
phba->sysfs_mbox.mbox->mb.mbxCommand);
|
|
|
|
sysfs_mbox_idle(phba);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
return -EPERM;
|
|
|
|
default:
|
|
|
|
printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n",
|
|
|
|
phba->sysfs_mbox.mbox->mb.mbxCommand);
|
|
|
|
sysfs_mbox_idle(phba);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
2008-01-11 14:52:54 +08:00
|
|
|
/* If HBA encountered an error attention, allow only DUMP
|
2008-02-09 07:49:39 +08:00
|
|
|
* or RESTART mailbox commands until the HBA is restarted.
|
2008-01-11 14:52:54 +08:00
|
|
|
*/
|
2008-08-25 09:50:00 +08:00
|
|
|
if (phba->pport->stopped &&
|
|
|
|
phba->sysfs_mbox.mbox->mb.mbxCommand != MBX_DUMP_MEMORY &&
|
|
|
|
phba->sysfs_mbox.mbox->mb.mbxCommand != MBX_RESTART &&
|
|
|
|
phba->sysfs_mbox.mbox->mb.mbxCommand != MBX_WRITE_VPARMS &&
|
|
|
|
phba->sysfs_mbox.mbox->mb.mbxCommand != MBX_WRITE_WWN)
|
|
|
|
lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
|
|
|
|
"1259 mbox: Issued mailbox cmd "
|
|
|
|
"0x%x while in stopped state.\n",
|
|
|
|
phba->sysfs_mbox.mbox->mb.mbxCommand);
|
2008-01-11 14:52:54 +08:00
|
|
|
|
2007-06-18 08:56:38 +08:00
|
|
|
phba->sysfs_mbox.mbox->vport = vport;
|
|
|
|
|
2008-04-07 22:15:56 +08:00
|
|
|
/* Don't allow mailbox commands to be sent when blocked
|
|
|
|
* or when in the middle of discovery
|
|
|
|
*/
|
2008-06-15 10:52:59 +08:00
|
|
|
if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
|
2007-04-25 21:51:45 +08:00
|
|
|
sysfs_mbox_idle(phba);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2007-04-25 21:51:45 +08:00
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if ((vport->fc_flag & FC_OFFLINE_MODE) ||
|
2005-04-18 05:05:31 +08:00
|
|
|
(!(phba->sli.sli_flag & LPFC_SLI2_ACTIVE))){
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
rc = lpfc_sli_issue_mbox (phba,
|
|
|
|
phba->sysfs_mbox.mbox,
|
|
|
|
MBX_POLL);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
} else {
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
rc = lpfc_sli_issue_mbox_wait (phba,
|
|
|
|
phba->sysfs_mbox.mbox,
|
2006-08-01 19:33:43 +08:00
|
|
|
lpfc_mbox_tmo_val(phba,
|
|
|
|
phba->sysfs_mbox.mbox->mb.mbxCommand) * HZ);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_lock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (rc != MBX_SUCCESS) {
|
2007-04-25 21:51:30 +08:00
|
|
|
if (rc == MBX_TIMEOUT) {
|
|
|
|
phba->sysfs_mbox.mbox = NULL;
|
|
|
|
}
|
2005-04-18 05:05:31 +08:00
|
|
|
sysfs_mbox_idle(phba);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2006-08-01 19:34:00 +08:00
|
|
|
return (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
phba->sysfs_mbox.state = SMBOX_READING;
|
|
|
|
}
|
|
|
|
else if (phba->sysfs_mbox.offset != off ||
|
|
|
|
phba->sysfs_mbox.state != SMBOX_READING) {
|
|
|
|
printk(KERN_WARNING "mbox_read: Bad State\n");
|
|
|
|
sysfs_mbox_idle(phba);
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2006-08-01 19:34:00 +08:00
|
|
|
return -EAGAIN;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(buf, (uint8_t *) & phba->sysfs_mbox.mbox->mb + off, count);
|
|
|
|
|
|
|
|
phba->sysfs_mbox.offset = off + count;
|
|
|
|
|
2007-04-25 21:51:30 +08:00
|
|
|
if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE)
|
2005-04-18 05:05:31 +08:00
|
|
|
sysfs_mbox_idle(phba);
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
spin_unlock_irq(&phba->hbalock);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct bin_attribute sysfs_mbox_attr = {
|
|
|
|
.attr = {
|
|
|
|
.name = "mbox",
|
|
|
|
.mode = S_IRUSR | S_IWUSR,
|
|
|
|
},
|
2007-04-25 21:51:30 +08:00
|
|
|
.size = MAILBOX_CMD_SIZE,
|
2005-04-18 05:05:31 +08:00
|
|
|
.read = sysfs_mbox_read,
|
|
|
|
.write = sysfs_mbox_write,
|
|
|
|
};
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2008-08-25 09:50:06 +08:00
|
|
|
* lpfc_alloc_sysfs_attr: Creates the ctlreg and mbox entries.
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: address of lpfc vport structure.
|
|
|
|
*
|
|
|
|
* Return codes:
|
|
|
|
* zero on success
|
|
|
|
* error return code from sysfs_create_bin_file()
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
int
|
2007-06-18 08:56:36 +08:00
|
|
|
lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
|
2005-04-18 05:05:31 +08:00
|
|
|
int error;
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
error = sysfs_create_bin_file(&shost->shost_dev.kobj,
|
2007-06-18 08:56:38 +08:00
|
|
|
&sysfs_ctlreg_attr);
|
2005-04-18 05:05:31 +08:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
error = sysfs_create_bin_file(&shost->shost_dev.kobj,
|
2007-06-18 08:56:38 +08:00
|
|
|
&sysfs_mbox_attr);
|
2005-04-18 05:05:31 +08:00
|
|
|
if (error)
|
|
|
|
goto out_remove_ctlreg_attr;
|
|
|
|
|
2008-09-07 23:52:10 +08:00
|
|
|
error = sysfs_create_bin_file(&shost->shost_dev.kobj,
|
|
|
|
&sysfs_drvr_stat_data_attr);
|
|
|
|
if (error)
|
|
|
|
goto out_remove_mbox_attr;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return 0;
|
2008-09-07 23:52:10 +08:00
|
|
|
out_remove_mbox_attr:
|
|
|
|
sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
|
2005-04-18 05:05:31 +08:00
|
|
|
out_remove_ctlreg_attr:
|
2008-02-22 07:13:36 +08:00
|
|
|
sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
|
2005-04-18 05:05:31 +08:00
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
2008-08-25 09:50:06 +08:00
|
|
|
* lpfc_free_sysfs_attr: Removes the ctlreg and mbox entries.
|
2008-08-25 09:49:00 +08:00
|
|
|
* @vport: address of lpfc vport structure.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
void
|
2007-06-18 08:56:36 +08:00
|
|
|
lpfc_free_sysfs_attr(struct lpfc_vport *vport)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
|
2008-09-07 23:52:10 +08:00
|
|
|
sysfs_remove_bin_file(&shost->shost_dev.kobj,
|
|
|
|
&sysfs_drvr_stat_data_attr);
|
2008-02-22 07:13:36 +08:00
|
|
|
sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
|
|
|
|
sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Dynamic FC Host Attributes Support
|
|
|
|
*/
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_host_port_id: Copy the vport DID into the scsi host port id.
|
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
lpfc_get_host_port_id(struct Scsi_Host *shost)
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
/* note: fc_myDID already in cpu endianness */
|
2007-06-18 08:56:36 +08:00
|
|
|
fc_host_port_id(shost) = vport->fc_myDID;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_host_port_type: Set the value of the scsi host port type.
|
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
lpfc_get_host_port_type(struct Scsi_Host *shost)
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
2007-06-18 08:56:38 +08:00
|
|
|
if (vport->port_type == LPFC_NPIV_PORT) {
|
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
|
|
|
|
} else if (lpfc_is_link_up(phba)) {
|
2005-04-18 05:05:31 +08:00
|
|
|
if (phba->fc_topology == TOPOLOGY_LOOP) {
|
2007-06-18 08:56:36 +08:00
|
|
|
if (vport->fc_flag & FC_PUBLIC_LOOP)
|
2005-04-18 05:05:31 +08:00
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
|
|
|
|
else
|
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
|
|
|
|
} else {
|
2007-06-18 08:56:36 +08:00
|
|
|
if (vport->fc_flag & FC_FABRIC)
|
2005-04-18 05:05:31 +08:00
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
|
|
|
|
else
|
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_PTP;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
|
|
|
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_host_port_state: Set the value of the scsi host port state.
|
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
lpfc_get_host_port_state(struct Scsi_Host *shost)
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if (vport->fc_flag & FC_OFFLINE_MODE)
|
2005-04-18 05:05:31 +08:00
|
|
|
fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
|
|
|
|
else {
|
2007-06-18 08:56:36 +08:00
|
|
|
switch (phba->link_state) {
|
|
|
|
case LPFC_LINK_UNKNOWN:
|
2005-04-18 05:05:31 +08:00
|
|
|
case LPFC_LINK_DOWN:
|
|
|
|
fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
|
|
|
|
break;
|
|
|
|
case LPFC_LINK_UP:
|
|
|
|
case LPFC_CLEAR_LA:
|
|
|
|
case LPFC_HBA_READY:
|
|
|
|
/* Links up, beyond this port_type reports state */
|
|
|
|
fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
|
|
|
|
break;
|
|
|
|
case LPFC_HBA_ERROR:
|
|
|
|
fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_host_speed: Set the value of the scsi host speed.
|
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
lpfc_get_host_speed(struct Scsi_Host *shost)
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if (lpfc_is_link_up(phba)) {
|
2005-04-18 05:05:31 +08:00
|
|
|
switch(phba->fc_linkspeed) {
|
|
|
|
case LA_1GHZ_LINK:
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
|
|
|
|
break;
|
|
|
|
case LA_2GHZ_LINK:
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
|
|
|
|
break;
|
|
|
|
case LA_4GHZ_LINK:
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
|
|
|
|
break;
|
2007-04-25 21:53:28 +08:00
|
|
|
case LA_8GHZ_LINK:
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
|
|
|
|
break;
|
2005-04-18 05:05:31 +08:00
|
|
|
default:
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
|
|
|
|
break;
|
|
|
|
}
|
2008-01-11 14:52:54 +08:00
|
|
|
} else
|
|
|
|
fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_host_fabric_name: Set the value of the scsi host fabric name.
|
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
lpfc_get_host_fabric_name (struct Scsi_Host *shost)
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
2005-09-01 06:23:12 +08:00
|
|
|
u64 node_name;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if ((vport->fc_flag & FC_FABRIC) ||
|
2005-04-18 05:05:31 +08:00
|
|
|
((phba->fc_topology == TOPOLOGY_LOOP) &&
|
2007-06-18 08:56:36 +08:00
|
|
|
(vport->fc_flag & FC_PUBLIC_LOOP)))
|
2005-09-22 00:46:54 +08:00
|
|
|
node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
|
2005-04-18 05:05:31 +08:00
|
|
|
else
|
|
|
|
/* fabric is local port if there is no F/FL_Port */
|
2008-01-11 14:52:54 +08:00
|
|
|
node_name = 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
|
2005-09-01 06:23:12 +08:00
|
|
|
fc_host_fabric_name(shost) = node_name;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_stats: Return statistical information about the adapter.
|
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* NULL on error for link down, no mbox pool, sli2 active,
|
|
|
|
* management not allowed, memory allocation error, or mbox error.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* NULL for error
|
|
|
|
* address of the adapter host statistics
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static struct fc_host_statistics *
|
|
|
|
lpfc_get_stats(struct Scsi_Host *shost)
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
struct lpfc_sli *psli = &phba->sli;
|
2005-08-11 03:03:01 +08:00
|
|
|
struct fc_host_statistics *hs = &phba->link_stats;
|
2006-08-03 03:24:34 +08:00
|
|
|
struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
|
2005-04-18 05:05:31 +08:00
|
|
|
LPFC_MBOXQ_t *pmboxq;
|
|
|
|
MAILBOX_t *pmb;
|
2006-08-03 03:24:34 +08:00
|
|
|
unsigned long seconds;
|
2005-10-29 08:28:56 +08:00
|
|
|
int rc = 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-06-18 08:56:38 +08:00
|
|
|
/*
|
|
|
|
* prevent udev from issuing mailbox commands until the port is
|
|
|
|
* configured.
|
|
|
|
*/
|
2007-06-18 08:56:36 +08:00
|
|
|
if (phba->link_state < LPFC_LINK_DOWN ||
|
|
|
|
!phba->mbox_mem_pool ||
|
|
|
|
(phba->sli.sli_flag & LPFC_SLI2_ACTIVE) == 0)
|
2007-06-18 08:56:38 +08:00
|
|
|
return NULL;
|
2007-06-18 08:56:36 +08:00
|
|
|
|
|
|
|
if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
|
2007-04-25 21:51:45 +08:00
|
|
|
return NULL;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
|
|
if (!pmboxq)
|
|
|
|
return NULL;
|
|
|
|
memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
|
|
|
|
|
|
|
|
pmb = &pmboxq->mb;
|
|
|
|
pmb->mbxCommand = MBX_READ_STATUS;
|
|
|
|
pmb->mbxOwner = OWN_HOST;
|
|
|
|
pmboxq->context1 = NULL;
|
2007-06-18 08:56:38 +08:00
|
|
|
pmboxq->vport = vport;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if ((vport->fc_flag & FC_OFFLINE_MODE) ||
|
2005-10-29 08:28:56 +08:00
|
|
|
(!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
|
2005-04-18 05:05:31 +08:00
|
|
|
rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
|
2005-10-29 08:28:56 +08:00
|
|
|
else
|
2005-04-18 05:05:31 +08:00
|
|
|
rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
|
|
|
|
|
|
|
|
if (rc != MBX_SUCCESS) {
|
2007-06-18 08:56:39 +08:00
|
|
|
if (rc != MBX_TIMEOUT)
|
2005-10-29 08:28:56 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
2005-04-18 05:05:31 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-08-11 03:03:01 +08:00
|
|
|
memset(hs, 0, sizeof (struct fc_host_statistics));
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
|
|
|
|
hs->tx_words = (pmb->un.varRdStatus.xmitByteCnt * 256);
|
|
|
|
hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
|
|
|
|
hs->rx_words = (pmb->un.varRdStatus.rcvByteCnt * 256);
|
|
|
|
|
2005-10-29 08:28:56 +08:00
|
|
|
memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
|
2005-04-18 05:05:31 +08:00
|
|
|
pmb->mbxCommand = MBX_READ_LNK_STAT;
|
|
|
|
pmb->mbxOwner = OWN_HOST;
|
|
|
|
pmboxq->context1 = NULL;
|
2007-06-18 08:56:38 +08:00
|
|
|
pmboxq->vport = vport;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if ((vport->fc_flag & FC_OFFLINE_MODE) ||
|
2005-10-29 08:28:56 +08:00
|
|
|
(!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
|
2005-04-18 05:05:31 +08:00
|
|
|
rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
|
2005-10-29 08:28:56 +08:00
|
|
|
else
|
2005-04-18 05:05:31 +08:00
|
|
|
rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
|
|
|
|
|
|
|
|
if (rc != MBX_SUCCESS) {
|
2007-06-18 08:56:39 +08:00
|
|
|
if (rc != MBX_TIMEOUT)
|
2007-06-18 08:56:38 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
2005-04-18 05:05:31 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
|
|
|
|
hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
|
|
|
|
hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
|
|
|
|
hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
|
|
|
|
hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
|
|
|
|
hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
|
|
|
|
hs->error_frames = pmb->un.varRdLnk.crcCnt;
|
|
|
|
|
2006-08-03 03:24:34 +08:00
|
|
|
hs->link_failure_count -= lso->link_failure_count;
|
|
|
|
hs->loss_of_sync_count -= lso->loss_of_sync_count;
|
|
|
|
hs->loss_of_signal_count -= lso->loss_of_signal_count;
|
|
|
|
hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
|
|
|
|
hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
|
|
|
|
hs->invalid_crc_count -= lso->invalid_crc_count;
|
|
|
|
hs->error_frames -= lso->error_frames;
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
if (phba->fc_topology == TOPOLOGY_LOOP) {
|
|
|
|
hs->lip_count = (phba->fc_eventTag >> 1);
|
2006-08-03 03:24:34 +08:00
|
|
|
hs->lip_count -= lso->link_events;
|
2005-04-18 05:05:31 +08:00
|
|
|
hs->nos_count = -1;
|
|
|
|
} else {
|
|
|
|
hs->lip_count = -1;
|
|
|
|
hs->nos_count = (phba->fc_eventTag >> 1);
|
2006-08-03 03:24:34 +08:00
|
|
|
hs->nos_count -= lso->link_events;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
hs->dumped_frames = -1;
|
|
|
|
|
2006-08-03 03:24:34 +08:00
|
|
|
seconds = get_seconds();
|
|
|
|
if (seconds < psli->stats_start)
|
|
|
|
hs->seconds_since_last_reset = seconds +
|
|
|
|
((unsigned long)-1 - psli->stats_start);
|
|
|
|
else
|
|
|
|
hs->seconds_since_last_reset = seconds - psli->stats_start;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-04-25 21:51:30 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
2005-04-18 05:05:31 +08:00
|
|
|
return hs;
|
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_reset_stats: Copy the adapter link stats information.
|
|
|
|
* @shost: kernel scsi host pointer.
|
|
|
|
**/
|
2006-08-03 03:24:34 +08:00
|
|
|
static void
|
|
|
|
lpfc_reset_stats(struct Scsi_Host *shost)
|
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
|
|
|
struct lpfc_hba *phba = vport->phba;
|
|
|
|
struct lpfc_sli *psli = &phba->sli;
|
|
|
|
struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
|
2006-08-03 03:24:34 +08:00
|
|
|
LPFC_MBOXQ_t *pmboxq;
|
|
|
|
MAILBOX_t *pmb;
|
|
|
|
int rc = 0;
|
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
|
2007-04-25 21:51:45 +08:00
|
|
|
return;
|
|
|
|
|
2006-08-03 03:24:34 +08:00
|
|
|
pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
|
|
if (!pmboxq)
|
|
|
|
return;
|
|
|
|
memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
|
|
|
|
|
|
|
|
pmb = &pmboxq->mb;
|
|
|
|
pmb->mbxCommand = MBX_READ_STATUS;
|
|
|
|
pmb->mbxOwner = OWN_HOST;
|
|
|
|
pmb->un.varWords[0] = 0x1; /* reset request */
|
|
|
|
pmboxq->context1 = NULL;
|
2007-06-18 08:56:38 +08:00
|
|
|
pmboxq->vport = vport;
|
2006-08-03 03:24:34 +08:00
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if ((vport->fc_flag & FC_OFFLINE_MODE) ||
|
2006-08-03 03:24:34 +08:00
|
|
|
(!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
|
|
|
|
rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
|
|
|
|
else
|
|
|
|
rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
|
|
|
|
|
|
|
|
if (rc != MBX_SUCCESS) {
|
2007-06-18 08:56:39 +08:00
|
|
|
if (rc != MBX_TIMEOUT)
|
2006-08-03 03:24:34 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
|
|
|
|
pmb->mbxCommand = MBX_READ_LNK_STAT;
|
|
|
|
pmb->mbxOwner = OWN_HOST;
|
|
|
|
pmboxq->context1 = NULL;
|
2007-06-18 08:56:38 +08:00
|
|
|
pmboxq->vport = vport;
|
2006-08-03 03:24:34 +08:00
|
|
|
|
2007-06-18 08:56:36 +08:00
|
|
|
if ((vport->fc_flag & FC_OFFLINE_MODE) ||
|
2006-08-03 03:24:34 +08:00
|
|
|
(!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
|
|
|
|
rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
|
|
|
|
else
|
|
|
|
rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
|
|
|
|
|
|
|
|
if (rc != MBX_SUCCESS) {
|
2007-06-18 08:56:39 +08:00
|
|
|
if (rc != MBX_TIMEOUT)
|
2006-08-03 03:24:34 +08:00
|
|
|
mempool_free( pmboxq, phba->mbox_mem_pool);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
|
|
|
|
lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
|
|
|
|
lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
|
|
|
|
lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
|
|
|
|
lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
|
|
|
|
lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
|
|
|
|
lso->error_frames = pmb->un.varRdLnk.crcCnt;
|
|
|
|
lso->link_events = (phba->fc_eventTag >> 1);
|
|
|
|
|
|
|
|
psli->stats_start = get_seconds();
|
|
|
|
|
2007-04-25 21:51:30 +08:00
|
|
|
mempool_free(pmboxq, phba->mbox_mem_pool);
|
|
|
|
|
2006-08-03 03:24:34 +08:00
|
|
|
return;
|
|
|
|
}
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The LPFC driver treats linkdown handling as target loss events so there
|
|
|
|
* are no sysfs handlers for link_down_tmo.
|
|
|
|
*/
|
2007-04-25 21:53:08 +08:00
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_node_by_target: Return the nodelist for a target.
|
|
|
|
* @starget: kernel scsi target pointer.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* address of the node list if found
|
|
|
|
* NULL target not found
|
|
|
|
**/
|
2007-04-25 21:53:08 +08:00
|
|
|
static struct lpfc_nodelist *
|
|
|
|
lpfc_get_node_by_target(struct scsi_target *starget)
|
2005-04-18 05:05:31 +08:00
|
|
|
{
|
2007-06-18 08:56:36 +08:00
|
|
|
struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
|
|
|
|
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
|
2007-04-25 21:53:08 +08:00
|
|
|
struct lpfc_nodelist *ndlp;
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
spin_lock_irq(shost->host_lock);
|
2007-04-25 21:53:08 +08:00
|
|
|
/* Search for this, mapped, target ID */
|
2007-06-18 08:56:36 +08:00
|
|
|
list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
|
2008-02-09 07:49:26 +08:00
|
|
|
if (NLP_CHK_NODE_ACT(ndlp) &&
|
|
|
|
ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
|
2007-04-25 21:53:08 +08:00
|
|
|
starget->id == ndlp->nlp_sid) {
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
|
|
|
return ndlp;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irq(shost->host_lock);
|
2007-04-25 21:53:08 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_starget_port_id: Set the target port id to the ndlp DID or -1.
|
|
|
|
* @starget: kernel scsi target pointer.
|
|
|
|
**/
|
2007-04-25 21:53:08 +08:00
|
|
|
static void
|
|
|
|
lpfc_get_starget_port_id(struct scsi_target *starget)
|
|
|
|
{
|
|
|
|
struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
|
|
|
|
|
|
|
|
fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_starget_node_name: Set the target node name.
|
|
|
|
* @starget: kernel scsi target pointer.
|
|
|
|
*
|
|
|
|
* Description: Set the target node name to the ndlp node name wwn or zero.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
lpfc_get_starget_node_name(struct scsi_target *starget)
|
|
|
|
{
|
2007-04-25 21:53:08 +08:00
|
|
|
struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-04-25 21:53:08 +08:00
|
|
|
fc_starget_node_name(starget) =
|
|
|
|
ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_starget_port_name: Set the target port name.
|
|
|
|
* @starget: kernel scsi target pointer.
|
|
|
|
*
|
|
|
|
* Description: set the target port name to the ndlp port name wwn or zero.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
lpfc_get_starget_port_name(struct scsi_target *starget)
|
|
|
|
{
|
2007-04-25 21:53:08 +08:00
|
|
|
struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
|
2005-04-18 05:05:31 +08:00
|
|
|
|
2007-04-25 21:53:08 +08:00
|
|
|
fc_starget_port_name(starget) =
|
|
|
|
ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_set_rport_loss_tmo: Set the rport dev loss tmo.
|
|
|
|
* @rport: fc rport address.
|
|
|
|
* @timeout: new value for dev loss tmo.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If timeout is non zero set the dev_loss_tmo to timeout, else set
|
|
|
|
* dev_loss_tmo to one.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
static void
|
|
|
|
lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
|
|
|
|
{
|
|
|
|
if (timeout)
|
2006-08-19 05:47:08 +08:00
|
|
|
rport->dev_loss_tmo = timeout;
|
2005-04-18 05:05:31 +08:00
|
|
|
else
|
2006-08-19 05:47:08 +08:00
|
|
|
rport->dev_loss_tmo = 1;
|
2005-04-18 05:05:31 +08:00
|
|
|
}
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_rport_show_function: Return rport target information.
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Macro that uses field to generate a function with the name lpfc_show_rport_
|
|
|
|
*
|
|
|
|
* lpfc_show_rport_##field: returns the bytes formatted in buf
|
|
|
|
* @cdev: class converted to an fc_rport.
|
|
|
|
* @buf: on return contains the target_field or zero.
|
|
|
|
*
|
|
|
|
* Returns: size of formatted string.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
#define lpfc_rport_show_function(field, format_string, sz, cast) \
|
|
|
|
static ssize_t \
|
2008-02-22 07:13:36 +08:00
|
|
|
lpfc_show_rport_##field (struct device *dev, \
|
|
|
|
struct device_attribute *attr, \
|
|
|
|
char *buf) \
|
2005-04-18 05:05:31 +08:00
|
|
|
{ \
|
2008-02-22 07:13:36 +08:00
|
|
|
struct fc_rport *rport = transport_class_to_rport(dev); \
|
2005-04-18 05:05:31 +08:00
|
|
|
struct lpfc_rport_data *rdata = rport->hostdata; \
|
|
|
|
return snprintf(buf, sz, format_string, \
|
|
|
|
(rdata->target) ? cast rdata->target->field : 0); \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define lpfc_rport_rd_attr(field, format_string, sz) \
|
|
|
|
lpfc_rport_show_function(field, format_string, sz, ) \
|
|
|
|
static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
|
|
|
|
|
|
|
|
|
|
|
|
struct fc_function_template lpfc_transport_functions = {
|
|
|
|
/* fixed attributes the driver supports */
|
|
|
|
.show_host_node_name = 1,
|
|
|
|
.show_host_port_name = 1,
|
|
|
|
.show_host_supported_classes = 1,
|
|
|
|
.show_host_supported_fc4s = 1,
|
|
|
|
.show_host_supported_speeds = 1,
|
|
|
|
.show_host_maxframe_size = 1,
|
|
|
|
|
|
|
|
/* dynamic attributes the driver supports */
|
|
|
|
.get_host_port_id = lpfc_get_host_port_id,
|
|
|
|
.show_host_port_id = 1,
|
|
|
|
|
|
|
|
.get_host_port_type = lpfc_get_host_port_type,
|
|
|
|
.show_host_port_type = 1,
|
|
|
|
|
|
|
|
.get_host_port_state = lpfc_get_host_port_state,
|
|
|
|
.show_host_port_state = 1,
|
|
|
|
|
|
|
|
/* active_fc4s is shown but doesn't change (thus no get function) */
|
|
|
|
.show_host_active_fc4s = 1,
|
|
|
|
|
|
|
|
.get_host_speed = lpfc_get_host_speed,
|
|
|
|
.show_host_speed = 1,
|
|
|
|
|
|
|
|
.get_host_fabric_name = lpfc_get_host_fabric_name,
|
|
|
|
.show_host_fabric_name = 1,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The LPFC driver treats linkdown handling as target loss events
|
|
|
|
* so there are no sysfs handlers for link_down_tmo.
|
|
|
|
*/
|
|
|
|
|
|
|
|
.get_fc_host_stats = lpfc_get_stats,
|
2006-08-03 03:24:34 +08:00
|
|
|
.reset_fc_host_stats = lpfc_reset_stats,
|
2005-04-18 05:05:31 +08:00
|
|
|
|
|
|
|
.dd_fcrport_size = sizeof(struct lpfc_rport_data),
|
|
|
|
.show_rport_maxframe_size = 1,
|
|
|
|
.show_rport_supported_classes = 1,
|
|
|
|
|
|
|
|
.set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
|
|
|
|
.show_rport_dev_loss_tmo = 1,
|
|
|
|
|
|
|
|
.get_starget_port_id = lpfc_get_starget_port_id,
|
|
|
|
.show_starget_port_id = 1,
|
|
|
|
|
|
|
|
.get_starget_node_name = lpfc_get_starget_node_name,
|
|
|
|
.show_starget_node_name = 1,
|
|
|
|
|
|
|
|
.get_starget_port_name = lpfc_get_starget_port_name,
|
|
|
|
.show_starget_port_name = 1,
|
2005-10-28 07:03:37 +08:00
|
|
|
|
|
|
|
.issue_fc_host_lip = lpfc_issue_lip,
|
2006-08-19 05:47:08 +08:00
|
|
|
.dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
|
|
|
|
.terminate_rport_io = lpfc_terminate_rport_io,
|
2007-06-18 08:56:38 +08:00
|
|
|
|
|
|
|
.dd_fcvport_size = sizeof(struct lpfc_vport *),
|
|
|
|
};
|
|
|
|
|
2007-10-28 01:37:33 +08:00
|
|
|
struct fc_function_template lpfc_vport_transport_functions = {
|
|
|
|
/* fixed attributes the driver supports */
|
|
|
|
.show_host_node_name = 1,
|
|
|
|
.show_host_port_name = 1,
|
|
|
|
.show_host_supported_classes = 1,
|
|
|
|
.show_host_supported_fc4s = 1,
|
|
|
|
.show_host_supported_speeds = 1,
|
|
|
|
.show_host_maxframe_size = 1,
|
|
|
|
|
|
|
|
/* dynamic attributes the driver supports */
|
|
|
|
.get_host_port_id = lpfc_get_host_port_id,
|
|
|
|
.show_host_port_id = 1,
|
|
|
|
|
|
|
|
.get_host_port_type = lpfc_get_host_port_type,
|
|
|
|
.show_host_port_type = 1,
|
|
|
|
|
|
|
|
.get_host_port_state = lpfc_get_host_port_state,
|
|
|
|
.show_host_port_state = 1,
|
|
|
|
|
|
|
|
/* active_fc4s is shown but doesn't change (thus no get function) */
|
|
|
|
.show_host_active_fc4s = 1,
|
|
|
|
|
|
|
|
.get_host_speed = lpfc_get_host_speed,
|
|
|
|
.show_host_speed = 1,
|
|
|
|
|
|
|
|
.get_host_fabric_name = lpfc_get_host_fabric_name,
|
|
|
|
.show_host_fabric_name = 1,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The LPFC driver treats linkdown handling as target loss events
|
|
|
|
* so there are no sysfs handlers for link_down_tmo.
|
|
|
|
*/
|
|
|
|
|
|
|
|
.get_fc_host_stats = lpfc_get_stats,
|
|
|
|
.reset_fc_host_stats = lpfc_reset_stats,
|
|
|
|
|
|
|
|
.dd_fcrport_size = sizeof(struct lpfc_rport_data),
|
|
|
|
.show_rport_maxframe_size = 1,
|
|
|
|
.show_rport_supported_classes = 1,
|
|
|
|
|
|
|
|
.set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
|
|
|
|
.show_rport_dev_loss_tmo = 1,
|
|
|
|
|
|
|
|
.get_starget_port_id = lpfc_get_starget_port_id,
|
|
|
|
.show_starget_port_id = 1,
|
|
|
|
|
|
|
|
.get_starget_node_name = lpfc_get_starget_node_name,
|
|
|
|
.show_starget_node_name = 1,
|
|
|
|
|
|
|
|
.get_starget_port_name = lpfc_get_starget_port_name,
|
|
|
|
.show_starget_port_name = 1,
|
|
|
|
|
|
|
|
.dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
|
|
|
|
.terminate_rport_io = lpfc_terminate_rport_io,
|
|
|
|
|
|
|
|
.vport_disable = lpfc_vport_disable,
|
|
|
|
};
|
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_cfgparam: Used during probe_one to init the adapter structure.
|
|
|
|
* @phba: lpfc_hba pointer.
|
|
|
|
**/
|
2005-04-18 05:05:31 +08:00
|
|
|
void
|
|
|
|
lpfc_get_cfgparam(struct lpfc_hba *phba)
|
|
|
|
{
|
2005-10-29 08:29:13 +08:00
|
|
|
lpfc_cr_delay_init(phba, lpfc_cr_delay);
|
|
|
|
lpfc_cr_count_init(phba, lpfc_cr_count);
|
2006-03-01 11:33:08 +08:00
|
|
|
lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
|
2006-12-03 02:34:16 +08:00
|
|
|
lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
|
|
|
|
lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
|
2005-10-29 08:29:13 +08:00
|
|
|
lpfc_ack0_init(phba, lpfc_ack0);
|
|
|
|
lpfc_topology_init(phba, lpfc_topology);
|
|
|
|
lpfc_link_speed_init(phba, lpfc_link_speed);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
|
2007-08-02 23:10:21 +08:00
|
|
|
lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
|
2006-12-03 02:34:56 +08:00
|
|
|
lpfc_use_msi_init(phba, lpfc_use_msi);
|
2008-01-11 14:52:48 +08:00
|
|
|
lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
|
|
|
|
lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
|
[SCSI] lpfc 8.1.1 : Add polled-mode support
- Add functionality to run in polled mode only. Includes run time
attribute to enable mode.
- Enable runtime writable hba settings for coallescing and delay parameters
Customers have requested a mode in the driver to run strictly polled.
This is generally to support an environment where the server is extremely
loaded and is looking to reclaim some cpu cycles from adapter interrupt
handling.
This patch adds a new "poll" attribute, and the following behavior:
if value is 0 (default):
The driver uses the normal method for i/o completion. It uses the
firmware feature of interrupt coalesing. The firmware allows a
minimum number of i/o completions before an interrupt, or a maximum
time delay between interrupts. By default, the driver sets these
to no delay (disabled) or 1 i/o - meaning coalescing is disabled.
Attributes were provided to change the coalescing values, but it was
a module-load time only and global across all adapters.
This patch allows them to be writable on a per-adapter basis.
if value is 1 :
Interrupts are left enabled, expecting that the user has tuned the
interrupt coalescing values. When this setting is enabled, the driver
will attempt to service completed i/o whenever new i/o is submitted
to the adapter. If the coalescing values are large, and the i/o
generation rate steady, an interrupt will be avoided by servicing
completed i/o prior to the coalescing thresholds kicking in. However,
if the i/o completion load is high enough or i/o generation slow, the
coalescion values will ensure that completed i/o is serviced in a timely
fashion.
if value is 3 :
Turns off FCP i/o interrupts altogether. The coalescing values now have
no effect. A new attribute "poll_tmo" (default 10ms) exists to set
the polling interval for i/o completion. When this setting is enabled,
the driver will attempt to service completed i/o and restart the
interval timer whenever new i/o is submitted. This behavior allows for
servicing of completed i/o sooner than the interval timer, but ensures
that if no i/o is being issued, then the interval timer will kick in
to service the outstanding i/o.
Signed-off-by: James Smart <James.Smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-11-30 05:32:13 +08:00
|
|
|
phba->cfg_poll = lpfc_poll;
|
2006-12-03 02:35:30 +08:00
|
|
|
phba->cfg_soft_wwnn = 0L;
|
2006-08-19 05:47:18 +08:00
|
|
|
phba->cfg_soft_wwpn = 0L;
|
2008-01-11 14:53:09 +08:00
|
|
|
lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
|
|
|
|
/* Also reinitialize the host templates with new values. */
|
|
|
|
lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
|
|
|
|
lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
|
2005-04-18 05:05:31 +08:00
|
|
|
/*
|
|
|
|
* Since the sg_tablesize is module parameter, the sg_dma_buf_size
|
2008-01-11 14:53:09 +08:00
|
|
|
* used to create the sg_dma_buf_pool must be dynamically calculated.
|
|
|
|
* 2 segments are added since the IOCB needs a command and response bde.
|
2005-04-18 05:05:31 +08:00
|
|
|
*/
|
|
|
|
phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
|
|
|
|
sizeof(struct fcp_rsp) +
|
2008-01-11 14:53:09 +08:00
|
|
|
((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
|
2007-04-25 21:52:34 +08:00
|
|
|
lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
|
2007-08-02 23:09:59 +08:00
|
|
|
return;
|
|
|
|
}
|
2006-03-01 08:25:21 +08:00
|
|
|
|
2008-08-25 09:49:00 +08:00
|
|
|
/**
|
|
|
|
* lpfc_get_vport_cfgparam: Used during port create, init the vport structure.
|
|
|
|
* @vport: lpfc_vport pointer.
|
|
|
|
**/
|
2007-08-02 23:09:59 +08:00
|
|
|
void
|
|
|
|
lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
|
|
|
|
{
|
2007-08-02 23:10:09 +08:00
|
|
|
lpfc_log_verbose_init(vport, lpfc_log_verbose);
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
|
|
|
|
lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
|
|
|
|
lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
|
|
|
|
lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
|
|
|
|
lpfc_restrict_login_init(vport, lpfc_restrict_login);
|
|
|
|
lpfc_fcp_class_init(vport, lpfc_fcp_class);
|
|
|
|
lpfc_use_adisc_init(vport, lpfc_use_adisc);
|
2008-09-07 23:52:04 +08:00
|
|
|
lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
|
2007-08-02 23:09:59 +08:00
|
|
|
lpfc_fdmi_on_init(vport, lpfc_fdmi_on);
|
|
|
|
lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
|
|
|
|
lpfc_max_luns_init(vport, lpfc_max_luns);
|
|
|
|
lpfc_scan_down_init(vport, lpfc_scan_down);
|
2007-10-28 01:37:17 +08:00
|
|
|
lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
|
2005-04-18 05:05:31 +08:00
|
|
|
return;
|
|
|
|
}
|