lpfc_attr.c 150.5 KB
Newer Older
已提交
1 2
/*******************************************************************
 * This file is part of the Emulex Linux Device Driver for         *
3
 * Fibre Channel Host Bus Adapters.                                *
4
 * Copyright (C) 2004-2011 Emulex.  All rights reserved.           *
5
 * EMULEX and SLI are trademarks of Emulex.                        *
已提交
6
 * www.emulex.com                                                  *
7
 * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
已提交
8 9
 *                                                                 *
 * This program is free software; you can redistribute it and/or   *
10 11 12 13 14 15 16 17 18 19
 * 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.                                     *
已提交
20 21 22
 *******************************************************************/

#include <linux/ctype.h>
23
#include <linux/delay.h>
已提交
24 25
#include <linux/pci.h>
#include <linux/interrupt.h>
J
James Smart 已提交
26
#include <linux/aer.h>
27
#include <linux/gfp.h>
28
#include <linux/kernel.h>
已提交
29

30
#include <scsi/scsi.h>
已提交
31 32 33 34
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_tcq.h>
#include <scsi/scsi_transport_fc.h>
35
#include <scsi/fc/fc_fs.h>
已提交
36

37
#include "lpfc_hw4.h"
已提交
38 39
#include "lpfc_hw.h"
#include "lpfc_sli.h"
40
#include "lpfc_sli4.h"
41
#include "lpfc_nl.h"
已提交
42 43 44 45 46 47 48
#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"
49
#include "lpfc_vport.h"
已提交
50

51 52 53
#define LPFC_DEF_DEVLOSS_TMO 30
#define LPFC_MIN_DEVLOSS_TMO 1
#define LPFC_MAX_DEVLOSS_TMO 255
已提交
54

55 56 57 58 59 60 61
/*
 * Write key size should be multiple of 4. If write key is changed
 * make sure that library write key is also changed.
 */
#define LPFC_REG_WRITE_KEY_SIZE	4
#define LPFC_REG_WRITE_KEY	"EMLX"

62
/**
63
 * lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules
64 65 66 67 68 69 70 71 72 73 74 75 76
 * @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.
 **/
已提交
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
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;
}

93
/**
94
 * lpfc_drvr_version_show - Return the Emulex driver string with version number
95 96 97 98 99 100
 * @dev: class unused variable.
 * @attr: device attribute, not used.
 * @buf: on return contains the module description text.
 *
 * Returns: size of formatted string.
 **/
已提交
101
static ssize_t
102 103
lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
		       char *buf)
已提交
104 105 106 107
{
	return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
}

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
/**
 * lpfc_enable_fip_show - Return the fip mode of the HBA
 * @dev: class unused variable.
 * @attr: device attribute, not used.
 * @buf: on return contains the module description text.
 *
 * Returns: size of formatted string.
 **/
static ssize_t
lpfc_enable_fip_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;

	if (phba->hba_flag & HBA_FIP_SUPPORT)
		return snprintf(buf, PAGE_SIZE, "1\n");
	else
		return snprintf(buf, PAGE_SIZE, "0\n");
}

130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
static ssize_t
lpfc_bg_info_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;

	if (phba->cfg_enable_bg)
		if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
			return snprintf(buf, PAGE_SIZE, "BlockGuard Enabled\n");
		else
			return snprintf(buf, PAGE_SIZE,
					"BlockGuard Not Supported\n");
	else
			return snprintf(buf, PAGE_SIZE,
					"BlockGuard Disabled\n");
}

static ssize_t
lpfc_bg_guard_err_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;

157 158
	return snprintf(buf, PAGE_SIZE, "%llu\n",
			(unsigned long long)phba->bg_guard_err_cnt);
159 160 161 162 163 164 165 166 167 168
}

static ssize_t
lpfc_bg_apptag_err_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;

169 170
	return snprintf(buf, PAGE_SIZE, "%llu\n",
			(unsigned long long)phba->bg_apptag_err_cnt);
171 172 173 174 175 176 177 178 179 180
}

static ssize_t
lpfc_bg_reftag_err_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;

181 182
	return snprintf(buf, PAGE_SIZE, "%llu\n",
			(unsigned long long)phba->bg_reftag_err_cnt);
183 184
}

185
/**
186
 * lpfc_info_show - Return some pci info about the host in ascii
187 188 189 190 191 192
 * @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.
 **/
已提交
193
static ssize_t
194 195
lpfc_info_show(struct device *dev, struct device_attribute *attr,
	       char *buf)
已提交
196
{
197
	struct Scsi_Host *host = class_to_shost(dev);
J
James Smart 已提交
198

已提交
199 200 201
	return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
}

202
/**
203
 * lpfc_serialnum_show - Return the hba serial number in ascii
204 205 206 207 208 209
 * @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.
 **/
已提交
210
static ssize_t
211 212
lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
已提交
213
{
214
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
215 216 217
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;

已提交
218 219 220
	return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber);
}

221
/**
222
 * lpfc_temp_sensor_show - Return the temperature sensor level
223 224 225 226 227 228 229 230 231 232
 * @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.
 **/
233
static ssize_t
234 235
lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
		      char *buf)
236
{
237
	struct Scsi_Host *shost = class_to_shost(dev);
238 239 240 241 242
	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);
}

243
/**
244
 * lpfc_modeldesc_show - Return the model description of the hba
245 246 247 248 249 250
 * @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.
 **/
已提交
251
static ssize_t
252 253
lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
已提交
254
{
255
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
256 257 258
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;

已提交
259 260 261
	return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc);
}

262
/**
263
 * lpfc_modelname_show - Return the model name of the hba
264 265 266 267 268 269
 * @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.
 **/
已提交
270
static ssize_t
271 272
lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
已提交
273
{
274
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
275 276 277
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;

已提交
278 279 280
	return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName);
}

281
/**
282
 * lpfc_programtype_show - Return the program type of the hba
283 284 285 286 287 288
 * @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.
 **/
已提交
289
static ssize_t
290 291
lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
		      char *buf)
已提交
292
{
293
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
294 295 296
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;

已提交
297 298 299
	return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType);
}

300
/**
301
 * lpfc_mlomgmt_show - Return the Menlo Maintenance sli flag
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
 * @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));
}

319
/**
320
 * lpfc_vportnum_show - Return the port number in ascii of the hba
321 322 323 324 325 326
 * @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.
 **/
已提交
327
static ssize_t
328 329
lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
		   char *buf)
已提交
330
{
331
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
332 333 334
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;

已提交
335 336 337
	return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port);
}

338
/**
339
 * lpfc_fwrev_show - Return the firmware rev running in the hba
340 341 342 343 344 345
 * @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.
 **/
已提交
346
static ssize_t
347 348
lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
		char *buf)
已提交
349
{
350
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
351 352
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
353
	char fwrev[32];
J
James Smart 已提交
354

已提交
355
	lpfc_decode_firmware_rev(phba, fwrev, 1);
356
	return snprintf(buf, PAGE_SIZE, "%s, sli-%d\n", fwrev, phba->sli_rev);
已提交
357 358
}

359
/**
360
 * lpfc_hdw_show - Return the jedec information about the hba
361 362 363 364 365 366
 * @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.
 **/
已提交
367
static ssize_t
368
lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
已提交
369 370
{
	char hdw[9];
371
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
372 373
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
374
	lpfc_vpd_t *vp = &phba->vpd;
J
James Smart 已提交
375

已提交
376 377 378
	lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
	return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
}
379 380

/**
381
 * lpfc_option_rom_version_show - Return the adapter ROM FCode version
382 383 384 385 386 387
 * @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.
 **/
已提交
388
static ssize_t
389 390
lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
已提交
391
{
392
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
393 394 395
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;

已提交
396 397
	return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
}
398 399

/**
400
 * lpfc_state_show - Return the link state of the port
401 402 403 404 405 406 407 408 409
 * @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.
 **/
已提交
410
static ssize_t
411 412
lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
		     char *buf)
已提交
413
{
414
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
415 416 417 418 419 420
	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:
421
	case LPFC_WARM_START:
已提交
422 423 424
	case LPFC_INIT_START:
	case LPFC_INIT_MBX_CMDS:
	case LPFC_LINK_DOWN:
J
James Smart 已提交
425
	case LPFC_HBA_ERROR:
426 427 428 429 430 431
		if (phba->hba_flag & LINK_DISABLED)
			len += snprintf(buf + len, PAGE_SIZE-len,
				"Link Down - User disabled\n");
		else
			len += snprintf(buf + len, PAGE_SIZE-len,
				"Link Down\n");
已提交
432 433 434 435
		break;
	case LPFC_LINK_UP:
	case LPFC_CLEAR_LA:
	case LPFC_HBA_READY:
436
		len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
J
James Smart 已提交
437 438 439 440

		switch (vport->port_state) {
		case LPFC_LOCAL_CFG_LINK:
			len += snprintf(buf + len, PAGE_SIZE-len,
441
					"Configuring Link\n");
J
James Smart 已提交
442
			break;
443
		case LPFC_FDISC:
J
James Smart 已提交
444 445 446 447 448 449 450 451 452 453 454 455 456
		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;

457 458 459 460 461
		case LPFC_VPORT_FAILED:
			len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n");
			break;

		case LPFC_VPORT_UNKNOWN:
J
James Smart 已提交
462 463 464 465
			len += snprintf(buf + len, PAGE_SIZE - len,
					"Unknown\n");
			break;
		}
466 467 468
		if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
			len += snprintf(buf + len, PAGE_SIZE-len,
					"   Menlo Maint Mode\n");
469
		else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
J
James Smart 已提交
470
			if (vport->fc_flag & FC_PUBLIC_LOOP)
已提交
471 472 473 474 475 476
				len += snprintf(buf + len, PAGE_SIZE-len,
						"   Public Loop\n");
			else
				len += snprintf(buf + len, PAGE_SIZE-len,
						"   Private Loop\n");
		} else {
J
James Smart 已提交
477
			if (vport->fc_flag & FC_FABRIC)
已提交
478 479 480 481 482 483 484
				len += snprintf(buf + len, PAGE_SIZE-len,
						"   Fabric\n");
			else
				len += snprintf(buf + len, PAGE_SIZE-len,
						"   Point-2-Point\n");
		}
	}
J
James Smart 已提交
485

已提交
486 487 488
	return len;
}

489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
/**
 * lpfc_link_state_store - Transition the link_state on an HBA port
 * @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.
 *
 * Returns:
 * -EINVAL if the buffer is not "up" or "down"
 * return from link state change function if non-zero
 * length of the buf on success
 **/
static ssize_t
lpfc_link_state_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;

	int status = -EINVAL;

	if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
			(phba->link_state == LPFC_LINK_DOWN))
513
		status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
514 515
	else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
			(phba->link_state >= LPFC_LINK_UP))
516
		status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT);
517 518 519 520 521 522 523

	if (status == 0)
		return strlen(buf);
	else
		return status;
}

524
/**
525
 * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
526 527 528 529 530 531 532 533 534 535
 * @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.
 **/
已提交
536
static ssize_t
537 538
lpfc_num_discovered_ports_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
已提交
539
{
540
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
541 542 543 544
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;

	return snprintf(buf, PAGE_SIZE, "%d\n",
			vport->fc_map_cnt + vport->fc_unmap_cnt);
已提交
545 546
}

547
/**
548
 * lpfc_issue_lip - Misnomer, name carried over from long ago
549 550 551 552 553 554 555 556 557 558 559 560
 * @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
 **/
561
static int
J
James Smart 已提交
562
lpfc_issue_lip(struct Scsi_Host *shost)
已提交
563
{
J
James Smart 已提交
564 565
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
566 567 568
	LPFC_MBOXQ_t *pmboxq;
	int mbxstatus = MBXERR_ERROR;

J
James Smart 已提交
569
	if ((vport->fc_flag & FC_OFFLINE_MODE) ||
570
	    (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
已提交
571 572 573 574 575 576 577 578
		return -EPERM;

	pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);

	if (!pmboxq)
		return -ENOMEM;

	memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
579 580
	pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
	pmboxq->u.mb.mbxOwner = OWN_HOST;
581

J
James Smart 已提交
582
	mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
已提交
583

584 585 586
	if ((mbxstatus == MBX_SUCCESS) &&
	    (pmboxq->u.mb.mbxStatus == 0 ||
	     pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) {
587 588 589 590 591
		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);
592 593 594 595 596
		if ((mbxstatus == MBX_SUCCESS) &&
		    (pmboxq->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
					"2859 SLI authentication is required "
					"for INIT_LINK but has not done yet\n");
597 598
	}

599
	lpfc_set_loopback_flag(phba);
J
James Smart 已提交
600
	if (mbxstatus != MBX_TIMEOUT)
601
		mempool_free(pmboxq, phba->mbox_mem_pool);
已提交
602 603 604 605

	if (mbxstatus == MBXERR_ERROR)
		return -EIO;

606
	return 0;
已提交
607 608
}

609
/**
610
 * lpfc_do_offline - Issues a mailbox command to bring the link down
611 612 613 614 615 616 617
 * @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.
618
 * lpfc_workq_post_event() returns a non-zero return code if call fails.
619 620 621 622 623
 *
 * Returns:
 * -EIO error posting the event
 * zero for success
 **/
624
static int
625
lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
626 627
{
	struct completion online_compl;
628 629
	struct lpfc_sli_ring *pring;
	struct lpfc_sli *psli;
630
	int status = 0;
631 632
	int cnt = 0;
	int i;
633
	int rc;
634 635

	init_completion(&online_compl);
636
	rc = lpfc_workq_post_event(phba, &status, &online_compl,
637
			      LPFC_EVT_OFFLINE_PREP);
638 639 640
	if (rc == 0)
		return -ENOMEM;

641 642 643 644 645 646 647
	wait_for_completion(&online_compl);

	if (status != 0)
		return -EIO;

	psli = &phba->sli;

648 649 650
	/* Wait a little for things to settle down, but not
	 * long enough for dev loss timeout to expire.
	 */
651 652 653 654
	for (i = 0; i < psli->num_rings; i++) {
		pring = &psli->ring[i];
		while (pring->txcmplq_cnt) {
			msleep(10);
655
			if (cnt++ > 500) {  /* 5 secs */
656 657
				lpfc_printf_log(phba,
					KERN_WARNING, LOG_INIT,
658 659
					"0466 Outstanding IO when "
					"bringing Adapter offline\n");
660 661 662 663 664 665
				break;
			}
		}
	}

	init_completion(&online_compl);
666 667 668 669
	rc = lpfc_workq_post_event(phba, &status, &online_compl, type);
	if (rc == 0)
		return -ENOMEM;

670 671 672 673 674
	wait_for_completion(&online_compl);

	if (status != 0)
		return -EIO;

675 676 677
	return 0;
}

678
/**
679
 * lpfc_selective_reset - Offline then onlines the port
680 681 682 683 684 685 686 687
 * @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.
688
 * Do not make this function static.
689 690 691 692 693 694
 *
 * Returns:
 * lpfc_do_offline() return code if not zero
 * -EIO reset not configured or error posting the event
 * zero for success
 **/
695
int
696 697 698 699
lpfc_selective_reset(struct lpfc_hba *phba)
{
	struct completion online_compl;
	int status = 0;
700
	int rc;
701

702
	if (!phba->cfg_enable_hba_reset)
703
		return -EACCES;
704

705 706 707 708 709
	status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);

	if (status != 0)
		return status;

710
	init_completion(&online_compl);
711
	rc = lpfc_workq_post_event(phba, &status, &online_compl,
712
			      LPFC_EVT_ONLINE);
713 714 715
	if (rc == 0)
		return -ENOMEM;

716 717 718 719 720 721 722 723
	wait_for_completion(&online_compl);

	if (status != 0)
		return -EIO;

	return 0;
}

724
/**
725
 * lpfc_issue_reset - Selectively resets an adapter
726 727 728 729 730 731 732 733 734 735 736 737
 * @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
738
 * is returned which indicates success
739 740 741 742 743 744
 *
 * 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
**/
745
static ssize_t
746 747
lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
		 const char *buf, size_t count)
748
{
749
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
750 751
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
752 753
	int status = -EINVAL;

754 755 756
	if (!phba->cfg_enable_hba_reset)
		return -EACCES;

757
	if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
758
		status = phba->lpfc_selective_reset(phba);
759 760 761 762 763 764 765

	if (status == 0)
		return strlen(buf);
	else
		return status;
}

766 767 768 769 770 771 772 773 774 775 776
/**
 * lpfc_sli4_pdev_status_reg_wait - Wait for pdev status register for readyness
 * @phba: lpfc_hba pointer.
 *
 * Description:
 * SLI4 interface type-2 device to wait on the sliport status register for
 * the readyness after performing a firmware reset.
 *
 * Returns:
 * zero for success
 **/
777
int
778 779
lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba)
{
780
	struct lpfc_register portstat_reg = {0};
781 782
	int i;

783
	msleep(100);
784 785 786
	lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
		   &portstat_reg.word0);

787 788 789 790 791
	/* verify if privilaged for the request operation */
	if (!bf_get(lpfc_sliport_status_rn, &portstat_reg) &&
	    !bf_get(lpfc_sliport_status_err, &portstat_reg))
		return -EPERM;

792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
	/* wait for the SLI port firmware ready after firmware reset */
	for (i = 0; i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT; i++) {
		msleep(10);
		lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
			   &portstat_reg.word0);
		if (!bf_get(lpfc_sliport_status_err, &portstat_reg))
			continue;
		if (!bf_get(lpfc_sliport_status_rn, &portstat_reg))
			continue;
		if (!bf_get(lpfc_sliport_status_rdy, &portstat_reg))
			continue;
		break;
	}

	if (i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT)
		return 0;
	else
		return -EIO;
}

812
/**
813
 * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
814 815 816
 * @phba: lpfc_hba pointer.
 *
 * Description:
817 818
 * Request SLI4 interface type-2 device to perform a physical register set
 * access.
819 820 821 822 823
 *
 * Returns:
 * zero for success
 **/
static ssize_t
824
lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
825 826
{
	struct completion online_compl;
827
	struct pci_dev *pdev = phba->pcidev;
828 829 830 831 832
	uint32_t reg_val;
	int status = 0;
	int rc;

	if (!phba->cfg_enable_hba_reset)
833
		return -EACCES;
834

835 836 837 838 839
	if ((phba->sli_rev < LPFC_SLI_REV4) ||
	    (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
	     LPFC_SLI_INTF_IF_TYPE_2))
		return -EPERM;

840 841 842 843 844
	/* Disable SR-IOV virtual functions if enabled */
	if (phba->cfg_sriov_nr_virtfn) {
		pci_disable_sriov(pdev);
		phba->cfg_sriov_nr_virtfn = 0;
	}
845 846 847 848 849 850 851 852 853 854
	status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);

	if (status != 0)
		return status;

	/* wait for the device to be quiesced before firmware reset */
	msleep(100);

	reg_val = readl(phba->sli4_hba.conf_regs_memmap_p +
			LPFC_CTL_PDEV_CTL_OFFSET);
855 856 857 858 859 860 861 862

	if (opcode == LPFC_FW_DUMP)
		reg_val |= LPFC_FW_DUMP_REQUEST;
	else if (opcode == LPFC_FW_RESET)
		reg_val |= LPFC_CTL_PDEV_CTL_FRST;
	else if (opcode == LPFC_DV_RESET)
		reg_val |= LPFC_CTL_PDEV_CTL_DRST;

863 864 865 866 867 868
	writel(reg_val, phba->sli4_hba.conf_regs_memmap_p +
	       LPFC_CTL_PDEV_CTL_OFFSET);
	/* flush */
	readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);

	/* delay driver action following IF_TYPE_2 reset */
869 870 871
	rc = lpfc_sli4_pdev_status_reg_wait(phba);

	if (rc)
872
		return rc;
873 874 875 876 877 878 879 880 881 882 883 884 885 886 887

	init_completion(&online_compl);
	rc = lpfc_workq_post_event(phba, &status, &online_compl,
				   LPFC_EVT_ONLINE);
	if (rc == 0)
		return -ENOMEM;

	wait_for_completion(&online_compl);

	if (status != 0)
		return -EIO;

	return 0;
}

888
/**
889
 * lpfc_nport_evt_cnt_show - Return the number of nport events
890 891 892 893 894 895
 * @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.
 **/
已提交
896
static ssize_t
897 898
lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
			char *buf)
已提交
899
{
900
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
901 902 903
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;

已提交
904 905 906
	return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
}

907
/**
908
 * lpfc_board_mode_show - Return the state of the board
909 910 911 912 913 914
 * @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.
 **/
915
static ssize_t
916 917
lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
		     char *buf)
918
{
919
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
920 921
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
922 923
	char  * state;

J
James Smart 已提交
924
	if (phba->link_state == LPFC_HBA_ERROR)
925
		state = "error";
J
James Smart 已提交
926
	else if (phba->link_state == LPFC_WARM_START)
927
		state = "warm start";
J
James Smart 已提交
928
	else if (phba->link_state == LPFC_INIT_START)
929 930 931 932 933 934 935
		state = "offline";
	else
		state = "online";

	return snprintf(buf, PAGE_SIZE, "%s\n", state);
}

936
/**
937
 * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
938 939 940 941 942 943 944 945 946 947 948
 * @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
 **/
949
static ssize_t
950 951
lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
		      const char *buf, size_t count)
952
{
953
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
954 955
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
956 957
	struct completion online_compl;
	int status=0;
958
	int rc;
959

960 961
	if (!phba->cfg_enable_hba_reset)
		return -EACCES;
962 963 964 965

	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
		"3050 lpfc_board_mode set to %s\n", buf);

966 967
	init_completion(&online_compl);

968
	if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
969
		rc = lpfc_workq_post_event(phba, &status, &online_compl,
970
				      LPFC_EVT_ONLINE);
971 972
		if (rc == 0)
			return -ENOMEM;
973 974 975
		wait_for_completion(&online_compl);
	} else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
		status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
976
	else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
977 978 979 980
		if (phba->sli_rev == LPFC_SLI_REV4)
			return -EINVAL;
		else
			status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
981
	else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
982 983 984 985
		if (phba->sli_rev == LPFC_SLI_REV4)
			return -EINVAL;
		else
			status = lpfc_do_offline(phba, LPFC_EVT_KILL);
986
	else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
987 988 989 990 991
		status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP);
	else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0)
		status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET);
	else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
		status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
992 993 994 995 996 997
	else
		return -EINVAL;

	if (!status)
		return strlen(buf);
	else
998
		return status;
999 1000
}

1001
/**
1002
 * lpfc_get_hba_info - Return various bits of informaton about the adapter
1003
 * @phba: pointer to the adapter structure.
1004 1005 1006 1007 1008 1009
 * @mxri: max xri count.
 * @axri: available xri count.
 * @mrpi: max rpi count.
 * @arpi: available rpi count.
 * @mvpi: max vpi count.
 * @avpi: available vpi count.
1010 1011 1012 1013 1014 1015 1016 1017 1018
 *
 * 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
 **/
J
James Smart 已提交
1019
static int
J
James Smart 已提交
1020 1021 1022 1023
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)
1024
{
1025
	struct lpfc_mbx_read_config *rd_config;
1026 1027 1028
	LPFC_MBOXQ_t *pmboxq;
	MAILBOX_t *pmb;
	int rc = 0;
1029
	uint32_t max_vpi;
1030 1031 1032 1033 1034 1035 1036

	/*
	 * prevent udev from issuing mailbox commands until the port is
	 * configured.
	 */
	if (phba->link_state < LPFC_LINK_DOWN ||
	    !phba->mbox_mem_pool ||
1037
	    (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
		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));

1048
	pmb = &pmboxq->u.mb;
1049 1050 1051 1052
	pmb->mbxCommand = MBX_READ_CONFIG;
	pmb->mbxOwner = OWN_HOST;
	pmboxq->context1 = NULL;

1053
	if (phba->pport->fc_flag & FC_OFFLINE_MODE)
1054 1055 1056 1057 1058
		rc = MBX_NOT_FINISHED;
	else
		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);

	if (rc != MBX_SUCCESS) {
J
James Smart 已提交
1059
		if (rc != MBX_TIMEOUT)
1060 1061 1062 1063
			mempool_free(pmboxq, phba->mbox_mem_pool);
		return 0;
	}

1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
	if (phba->sli_rev == LPFC_SLI_REV4) {
		rd_config = &pmboxq->u.mqe.un.rd_config;
		if (mrpi)
			*mrpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
		if (arpi)
			*arpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config) -
					phba->sli4_hba.max_cfg_param.rpi_used;
		if (mxri)
			*mxri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
		if (axri)
			*axri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config) -
					phba->sli4_hba.max_cfg_param.xri_used;
1076 1077 1078 1079 1080 1081 1082

		/* Account for differences with SLI-3.  Get vpi count from
		 * mailbox data and subtract one for max vpi value.
		 */
		max_vpi = (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) > 0) ?
			(bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) - 1) : 0;

1083
		if (mvpi)
1084
			*mvpi = max_vpi;
1085
		if (avpi)
1086
			*avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used;
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
	} else {
		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;
		if (mvpi)
			*mvpi = pmb->un.varRdConfig.max_vpi;
		if (avpi)
			*avpi = pmb->un.varRdConfig.avail_vpi;
	}
1101 1102 1103 1104 1105

	mempool_free(pmboxq, phba->mbox_mem_pool);
	return 1;
}

1106
/**
1107
 * lpfc_max_rpi_show - Return maximum rpi
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
 * @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.
 **/
1120
static ssize_t
1121 1122
lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
		  char *buf)
1123
{
1124
	struct Scsi_Host  *shost = class_to_shost(dev);
1125 1126 1127 1128
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	uint32_t cnt;

J
James Smart 已提交
1129
	if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
1130 1131 1132 1133
		return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
	return snprintf(buf, PAGE_SIZE, "Unknown\n");
}

1134
/**
1135
 * lpfc_used_rpi_show - Return maximum rpi minus available rpi
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
 * @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.
 **/
1148
static ssize_t
1149 1150
lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
		   char *buf)
1151
{
1152
	struct Scsi_Host  *shost = class_to_shost(dev);
1153 1154 1155 1156
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	uint32_t cnt, acnt;

J
James Smart 已提交
1157
	if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
1158 1159 1160 1161
		return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
	return snprintf(buf, PAGE_SIZE, "Unknown\n");
}

1162
/**
1163
 * lpfc_max_xri_show - Return maximum xri
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
 * @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.
 **/
1176
static ssize_t
1177 1178
lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
		  char *buf)
1179
{
1180
	struct Scsi_Host  *shost = class_to_shost(dev);
1181 1182 1183 1184
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	uint32_t cnt;

J
James Smart 已提交
1185
	if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
1186 1187 1188 1189
		return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
	return snprintf(buf, PAGE_SIZE, "Unknown\n");
}

1190
/**
1191
 * lpfc_used_xri_show - Return maximum xpi minus the available xpi
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
 * @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.
 **/
1204
static ssize_t
1205 1206
lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
		   char *buf)
1207
{
1208
	struct Scsi_Host  *shost = class_to_shost(dev);
1209 1210 1211 1212
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	uint32_t cnt, acnt;

J
James Smart 已提交
1213 1214 1215 1216 1217
	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");
}

1218
/**
1219
 * lpfc_max_vpi_show - Return maximum vpi
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
 * @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.
 **/
J
James Smart 已提交
1232
static ssize_t
1233 1234
lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
		  char *buf)
J
James Smart 已提交
1235
{
1236
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1237 1238 1239 1240 1241 1242 1243 1244 1245
	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");
}

1246
/**
1247
 * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
 * @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.
 **/
J
James Smart 已提交
1260
static ssize_t
1261 1262
lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
		   char *buf)
J
James Smart 已提交
1263
{
1264
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1265 1266 1267 1268 1269
	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))
1270 1271 1272 1273
		return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
	return snprintf(buf, PAGE_SIZE, "Unknown\n");
}

1274
/**
1275
 * lpfc_npiv_info_show - Return text about NPIV support for the adapter
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
 * @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.
 **/
1287
static ssize_t
1288 1289
lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
1290
{
1291
	struct Scsi_Host  *shost = class_to_shost(dev);
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
	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);
}

1302
/**
1303
 * lpfc_poll_show - Return text about poll support for the adapter
1304 1305 1306 1307 1308 1309 1310 1311 1312
 * @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.
 **/
1313
static ssize_t
1314 1315
lpfc_poll_show(struct device *dev, struct device_attribute *attr,
	       char *buf)
1316
{
1317
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1318 1319
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
1320 1321 1322 1323

	return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
}

1324
/**
1325
 * lpfc_poll_store - Set the value of cfg_poll for the adapter
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
 * @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
 **/
1338
static ssize_t
1339 1340
lpfc_poll_store(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
1341
{
1342
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1343 1344
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357
	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;

1358 1359 1360
	if (phba->sli_rev == LPFC_SLI_REV4)
		val = 0;

1361 1362 1363 1364
	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
		"3051 lpfc_poll changed from %d to %d\n",
		phba->cfg_poll, val);

J
James Smart 已提交
1365
	spin_lock_irq(&phba->hbalock);
1366 1367 1368 1369 1370 1371

	old_val = phba->cfg_poll;

	if (val & ENABLE_FCP_RING_POLLING) {
		if ((val & DISABLE_FCP_RING_INT) &&
		    !(old_val & DISABLE_FCP_RING_INT)) {
1372 1373 1374 1375
			if (lpfc_readl(phba->HCregaddr, &creg_val)) {
				spin_unlock_irq(&phba->hbalock);
				return -EINVAL;
			}
1376 1377 1378 1379 1380 1381 1382
			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) {
J
James Smart 已提交
1383
		spin_unlock_irq(&phba->hbalock);
1384 1385 1386 1387 1388 1389
		return -EINVAL;
	}

	if (!(val & DISABLE_FCP_RING_INT) &&
	    (old_val & DISABLE_FCP_RING_INT))
	{
J
James Smart 已提交
1390
		spin_unlock_irq(&phba->hbalock);
1391
		del_timer(&phba->fcp_poll_timer);
J
James Smart 已提交
1392
		spin_lock_irq(&phba->hbalock);
1393 1394 1395 1396
		if (lpfc_readl(phba->HCregaddr, &creg_val)) {
			spin_unlock_irq(&phba->hbalock);
			return -EINVAL;
		}
1397 1398 1399 1400 1401 1402 1403
		creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
		writel(creg_val, phba->HCregaddr);
		readl(phba->HCregaddr); /* flush */
	}

	phba->cfg_poll = val;

J
James Smart 已提交
1404
	spin_unlock_irq(&phba->hbalock);
1405 1406 1407

	return strlen(buf);
}
已提交
1408

1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446
/**
 * lpfc_fips_level_show - Return the current FIPS level for the HBA
 * @dev: class unused variable.
 * @attr: device attribute, not used.
 * @buf: on return contains the module description text.
 *
 * Returns: size of formatted string.
 **/
static ssize_t
lpfc_fips_level_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->fips_level);
}

/**
 * lpfc_fips_rev_show - Return the FIPS Spec revision for the HBA
 * @dev: class unused variable.
 * @attr: device attribute, not used.
 * @buf: on return contains the module description text.
 *
 * Returns: size of formatted string.
 **/
static ssize_t
lpfc_fips_rev_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->fips_spec_rev);
}

1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
/**
 * lpfc_dss_show - Return the current state of dss and the configured state
 * @dev: class converted to a Scsi_host structure.
 * @attr: device attribute, not used.
 * @buf: on return contains the formatted text.
 *
 * Returns: size of formatted string.
 **/
static ssize_t
lpfc_dss_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, "%s - %sOperational\n",
			(phba->cfg_enable_dss) ? "Enabled" : "Disabled",
			(phba->sli3_options & LPFC_SLI3_DSS_ENABLED) ?
				"" : "Not ");
}

1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
/**
 * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
 * @dev: class converted to a Scsi_host structure.
 * @attr: device attribute, not used.
 * @buf: on return contains the formatted support level.
 *
 * Description:
 * Returns the maximum number of virtual functions a physical function can
 * support, 0 will be returned if called on virtual function.
 *
 * Returns: size of formatted string.
 **/
static ssize_t
lpfc_sriov_hw_max_virtfn_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;
1489
	uint16_t max_nr_virtfn;
1490

1491 1492
	max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
	return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
1493 1494
}

1495
/**
1496
 * lpfc_param_show - Return a cfg attribute value in decimal
1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508
 *
 * 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.
 **/
已提交
1509 1510
#define lpfc_param_show(attr)	\
static ssize_t \
1511 1512
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
		   char *buf) \
已提交
1513
{ \
1514
	struct Scsi_Host  *shost = class_to_shost(dev);\
J
James Smart 已提交
1515 1516
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
	struct lpfc_hba   *phba = vport->phba;\
1517
	uint val = 0;\
1518 1519 1520 1521 1522
	val = phba->cfg_##attr;\
	return snprintf(buf, PAGE_SIZE, "%d\n",\
			phba->cfg_##attr);\
}

1523
/**
1524
 * lpfc_param_hex_show - Return a cfg attribute value in hex
1525 1526 1527 1528 1529 1530 1531 1532
 *
 * 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.
1533
 * @buf: on return contains the attribute value in hexadecimal.
1534 1535 1536
 *
 * Returns: size of formatted string.
 **/
1537 1538
#define lpfc_param_hex_show(attr)	\
static ssize_t \
1539 1540
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
		   char *buf) \
1541
{ \
1542
	struct Scsi_Host  *shost = class_to_shost(dev);\
J
James Smart 已提交
1543 1544
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
	struct lpfc_hba   *phba = vport->phba;\
1545
	uint val = 0;\
1546 1547 1548 1549 1550
	val = phba->cfg_##attr;\
	return snprintf(buf, PAGE_SIZE, "%#x\n",\
			phba->cfg_##attr);\
}

1551
/**
1552
 * lpfc_param_init - Initializes a cfg attribute
1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
 *
 * 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
 **/
1570 1571
#define lpfc_param_init(attr, default, minval, maxval)	\
static int \
1572
lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
1573 1574 1575 1576
{ \
	if (val >= minval && val <= maxval) {\
		phba->cfg_##attr = val;\
		return 0;\
已提交
1577
	}\
1578
	lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1579 1580
			"0449 lpfc_"#attr" attribute cannot be set to %d, "\
			"allowed range is ["#minval", "#maxval"]\n", val); \
1581 1582
	phba->cfg_##attr = default;\
	return -EINVAL;\
已提交
1583 1584
}

1585
/**
1586
 * lpfc_param_set - Set a cfg attribute value
1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
 *
 * 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
 **/
1605 1606
#define lpfc_param_set(attr, default, minval, maxval)	\
static int \
1607
lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
1608 1609
{ \
	if (val >= minval && val <= maxval) {\
1610 1611 1612
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
			"3052 lpfc_" #attr " changed from %d to %d\n", \
			phba->cfg_##attr, val); \
1613 1614 1615 1616
		phba->cfg_##attr = val;\
		return 0;\
	}\
	lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1617 1618
			"0450 lpfc_"#attr" attribute cannot be set to %d, "\
			"allowed range is ["#minval", "#maxval"]\n", val); \
1619 1620 1621
	return -EINVAL;\
}

1622
/**
1623
 * lpfc_param_store - Set a vport attribute value
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
 *
 * 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.
 **/
1643
#define lpfc_param_store(attr)	\
已提交
1644
static ssize_t \
1645 1646
lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
		    const char *buf, size_t count) \
已提交
1647
{ \
1648
	struct Scsi_Host  *shost = class_to_shost(dev);\
J
James Smart 已提交
1649 1650
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
	struct lpfc_hba   *phba = vport->phba;\
1651
	uint val = 0;\
1652 1653 1654 1655
	if (!isdigit(buf[0]))\
		return -EINVAL;\
	if (sscanf(buf, "%i", &val) != 1)\
		return -EINVAL;\
1656
	if (lpfc_##attr##_set(phba, val) == 0) \
1657
		return strlen(buf);\
1658 1659
	else \
		return -EINVAL;\
已提交
1660 1661
}

1662
/**
1663
 * lpfc_vport_param_show - Return decimal formatted cfg attribute value
1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675
 *
 * 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.
 **/
1676 1677
#define lpfc_vport_param_show(attr)	\
static ssize_t \
1678 1679
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
		   char *buf) \
1680
{ \
1681
	struct Scsi_Host  *shost = class_to_shost(dev);\
1682
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1683
	uint val = 0;\
1684 1685 1686 1687
	val = vport->cfg_##attr;\
	return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
}

1688
/**
1689
 * lpfc_vport_param_hex_show - Return hex formatted attribute value
1690 1691 1692 1693 1694 1695
 *
 * Description:
 * Macro that given an attr e.g.
 * hba_queue_depth expands into a function with the name
 * lpfc_hba_queue_depth_show
 *
1696
 * lpfc_##attr##_show: prints the attribute value in hexadecimal.
1697 1698
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
1699
 * @buf: on return contains the attribute value in hexadecimal.
1700 1701 1702
 *
 * Returns: length of formatted string.
 **/
1703 1704
#define lpfc_vport_param_hex_show(attr)	\
static ssize_t \
1705 1706
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
		   char *buf) \
1707
{ \
1708
	struct Scsi_Host  *shost = class_to_shost(dev);\
1709
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1710
	uint val = 0;\
1711 1712 1713 1714
	val = vport->cfg_##attr;\
	return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
}

1715
/**
1716
 * lpfc_vport_param_init - Initialize a vport cfg attribute
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732
 *
 * 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
 **/
1733 1734
#define lpfc_vport_param_init(attr, default, minval, maxval)	\
static int \
1735
lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
1736 1737 1738 1739 1740
{ \
	if (val >= minval && val <= maxval) {\
		vport->cfg_##attr = val;\
		return 0;\
	}\
1741
	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1742
			 "0423 lpfc_"#attr" attribute cannot be set to %d, "\
1743
			 "allowed range is ["#minval", "#maxval"]\n", val); \
1744 1745 1746 1747
	vport->cfg_##attr = default;\
	return -EINVAL;\
}

1748
/**
1749
 * lpfc_vport_param_set - Set a vport cfg attribute
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764
 *
 * 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
 **/
1765 1766
#define lpfc_vport_param_set(attr, default, minval, maxval)	\
static int \
1767
lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
1768 1769
{ \
	if (val >= minval && val <= maxval) {\
1770 1771 1772
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
			"3053 lpfc_" #attr " changed from %d to %d\n", \
			vport->cfg_##attr, val); \
1773 1774 1775
		vport->cfg_##attr = val;\
		return 0;\
	}\
1776
	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1777
			 "0424 lpfc_"#attr" attribute cannot be set to %d, "\
1778
			 "allowed range is ["#minval", "#maxval"]\n", val); \
1779 1780 1781
	return -EINVAL;\
}

1782
/**
1783
 * lpfc_vport_param_store - Set a vport attribute
1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798
 *
 * 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.
 **/
1799 1800
#define lpfc_vport_param_store(attr)	\
static ssize_t \
1801 1802
lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
		    const char *buf, size_t count) \
1803
{ \
1804
	struct Scsi_Host  *shost = class_to_shost(dev);\
1805
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1806
	uint val = 0;\
1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817
	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;\
}


1818
#define LPFC_ATTR(name, defval, minval, maxval, desc) \
1819
static uint lpfc_##name = defval;\
1820
module_param(lpfc_##name, uint, S_IRUGO);\
已提交
1821
MODULE_PARM_DESC(lpfc_##name, desc);\
1822
lpfc_param_init(name, defval, minval, maxval)
已提交
1823 1824

#define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
1825
static uint lpfc_##name = defval;\
1826
module_param(lpfc_##name, uint, S_IRUGO);\
已提交
1827 1828
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_param_show(name)\
1829
lpfc_param_init(name, defval, minval, maxval)\
1830
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
已提交
1831 1832

#define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
1833
static uint lpfc_##name = defval;\
1834
module_param(lpfc_##name, uint, S_IRUGO);\
已提交
1835 1836
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_param_show(name)\
1837 1838 1839
lpfc_param_init(name, defval, minval, maxval)\
lpfc_param_set(name, defval, minval, maxval)\
lpfc_param_store(name)\
1840 1841
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
		   lpfc_##name##_show, lpfc_##name##_store)
已提交
1842

1843
#define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1844
static uint lpfc_##name = defval;\
1845
module_param(lpfc_##name, uint, S_IRUGO);\
1846 1847 1848
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_param_hex_show(name)\
lpfc_param_init(name, defval, minval, maxval)\
1849
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1850 1851

#define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1852
static uint lpfc_##name = defval;\
1853
module_param(lpfc_##name, uint, S_IRUGO);\
1854 1855 1856 1857 1858
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)\
1859 1860
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
		   lpfc_##name##_show, lpfc_##name##_store)
1861

1862
#define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
1863
static uint lpfc_##name = defval;\
1864
module_param(lpfc_##name, uint, S_IRUGO);\
1865 1866 1867 1868
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_vport_param_init(name, defval, minval, maxval)

#define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
1869
static uint lpfc_##name = defval;\
1870
module_param(lpfc_##name, uint, S_IRUGO);\
1871 1872 1873
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_vport_param_show(name)\
lpfc_vport_param_init(name, defval, minval, maxval)\
1874
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1875 1876

#define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
1877
static uint lpfc_##name = defval;\
1878
module_param(lpfc_##name, uint, S_IRUGO);\
1879 1880 1881 1882 1883
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)\
1884 1885
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
		   lpfc_##name##_show, lpfc_##name##_store)
1886 1887

#define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1888
static uint lpfc_##name = defval;\
1889
module_param(lpfc_##name, uint, S_IRUGO);\
1890 1891 1892
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_vport_param_hex_show(name)\
lpfc_vport_param_init(name, defval, minval, maxval)\
1893
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1894 1895

#define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1896
static uint lpfc_##name = defval;\
1897
module_param(lpfc_##name, uint, S_IRUGO);\
1898 1899 1900 1901 1902
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)\
1903 1904 1905
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
		   lpfc_##name##_show, lpfc_##name##_store)

1906 1907 1908 1909
static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL);
static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL);
static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL);
static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL);
1910 1911 1912 1913 1914 1915 1916 1917
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);
1918 1919
static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
		lpfc_link_state_store);
1920 1921 1922 1923
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);
1924
static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
1925 1926
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);
1927
static DEVICE_ATTR(lpfc_enable_fip, S_IRUGO, lpfc_enable_fip_show, NULL);
1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938
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);
1939 1940
static DEVICE_ATTR(lpfc_fips_level, S_IRUGO, lpfc_fips_level_show, NULL);
static DEVICE_ATTR(lpfc_fips_rev, S_IRUGO, lpfc_fips_rev_show, NULL);
1941
static DEVICE_ATTR(lpfc_dss, S_IRUGO, lpfc_dss_show, NULL);
1942 1943
static DEVICE_ATTR(lpfc_sriov_hw_max_virtfn, S_IRUGO,
		   lpfc_sriov_hw_max_virtfn_show, NULL);
1944

1945
static char *lpfc_soft_wwn_key = "C99G71SL8032A";
1946

1947
/**
1948
 * lpfc_soft_wwn_enable_store - Allows setting of the wwn if the key is valid
1949 1950 1951 1952 1953 1954 1955 1956 1957
 * @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
 **/
1958
static ssize_t
1959 1960
lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
1961
{
1962
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1963 1964
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983
	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--;

1984 1985
	if ((cnt != strlen(lpfc_soft_wwn_key)) ||
	    (strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0))
1986 1987
		return -EINVAL;

1988
	phba->soft_wwn_enable = 1;
1989 1990
	return count;
}
1991 1992
static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
		   lpfc_soft_wwn_enable_store);
1993

1994
/**
1995
 * lpfc_soft_wwpn_show - Return the cfg soft ww port name of the adapter
1996 1997
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
1998
 * @buf: on return contains the wwpn in hexadecimal.
1999 2000 2001
 *
 * Returns: size of formatted string.
 **/
2002
static ssize_t
2003 2004
lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
2005
{
2006
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
2007 2008 2009
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;

2010 2011
	return snprintf(buf, PAGE_SIZE, "0x%llx\n",
			(unsigned long long)phba->cfg_soft_wwpn);
2012 2013
}

2014
/**
2015
 * lpfc_soft_wwpn_store - Set the ww port name of the adapter
2016 2017
 * @dev class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
2018
 * @buf: contains the wwpn in hexadecimal.
2019 2020 2021 2022 2023 2024 2025 2026
 * @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
 **/
2027
static ssize_t
2028 2029
lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr,
		     const char *buf, size_t count)
2030
{
2031
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
2032 2033
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
2034 2035 2036 2037
	struct completion online_compl;
	int stat1=0, stat2=0;
	unsigned int i, j, cnt=count;
	u8 wwpn[8];
2038
	int rc;
2039

2040 2041
	if (!phba->cfg_enable_hba_reset)
		return -EACCES;
2042 2043 2044
	spin_lock_irq(&phba->hbalock);
	if (phba->over_temp_state == HBA_OVER_TEMP) {
		spin_unlock_irq(&phba->hbalock);
2045
		return -EACCES;
2046 2047
	}
	spin_unlock_irq(&phba->hbalock);
2048 2049 2050 2051
	/* count may include a LF at end of string */
	if (buf[cnt-1] == '\n')
		cnt--;

2052
	if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
2053 2054 2055 2056
	    ((cnt == 17) && (*buf++ != 'x')) ||
	    ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
		return -EINVAL;

2057
	phba->soft_wwn_enable = 0;
2058 2059 2060 2061 2062

	memset(wwpn, 0, sizeof(wwpn));

	/* Validate and store the new name */
	for (i=0, j=0; i < 16; i++) {
2063 2064 2065 2066 2067
		int value;

		value = hex_to_bin(*buf++);
		if (value >= 0)
			j = (j << 4) | value;
2068 2069 2070 2071 2072 2073 2074 2075
		else
			return -EINVAL;
		if (i % 2) {
			wwpn[i/2] = j & 0xff;
			j = 0;
		}
	}
	phba->cfg_soft_wwpn = wwn_to_u64(wwpn);
J
James Smart 已提交
2076
	fc_host_port_name(shost) = phba->cfg_soft_wwpn;
2077
	if (phba->cfg_soft_wwnn)
J
James Smart 已提交
2078
		fc_host_node_name(shost) = phba->cfg_soft_wwnn;
2079 2080 2081 2082

	dev_printk(KERN_NOTICE, &phba->pcidev->dev,
		   "lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no);

2083
	stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
2084 2085
	if (stat1)
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2086 2087
				"0463 lpfc_soft_wwpn attribute set failed to "
				"reinit adapter - %d\n", stat1);
2088
	init_completion(&online_compl);
2089 2090 2091 2092 2093
	rc = lpfc_workq_post_event(phba, &stat2, &online_compl,
				   LPFC_EVT_ONLINE);
	if (rc == 0)
		return -ENOMEM;

2094 2095 2096
	wait_for_completion(&online_compl);
	if (stat2)
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2097 2098
				"0464 lpfc_soft_wwpn attribute set failed to "
				"reinit adapter - %d\n", stat2);
2099 2100
	return (stat1 || stat2) ? -EIO : count;
}
2101 2102
static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\
		   lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
2103

2104
/**
2105
 * lpfc_soft_wwnn_show - Return the cfg soft ww node name for the adapter
2106 2107
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
2108
 * @buf: on return contains the wwnn in hexadecimal.
2109 2110 2111
 *
 * Returns: size of formatted string.
 **/
2112
static ssize_t
2113 2114
lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
2115
{
2116
	struct Scsi_Host *shost = class_to_shost(dev);
2117
	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2118 2119 2120 2121
	return snprintf(buf, PAGE_SIZE, "0x%llx\n",
			(unsigned long long)phba->cfg_soft_wwnn);
}

2122
/**
2123
 * lpfc_soft_wwnn_store - sets the ww node name of the adapter
2124
 * @cdev: class device that is converted into a Scsi_host.
2125
 * @buf: contains the ww node name in hexadecimal.
2126 2127 2128 2129 2130 2131
 * @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
 **/
2132
static ssize_t
2133 2134
lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr,
		     const char *buf, size_t count)
2135
{
2136
	struct Scsi_Host *shost = class_to_shost(dev);
2137
	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158
	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++) {
2159 2160 2161 2162 2163
		int value;

		value = hex_to_bin(*buf++);
		if (value >= 0)
			j = (j << 4) | value;
2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178
		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;
}
2179 2180
static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\
		   lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
2181

2182

2183
static int lpfc_poll = 0;
2184
module_param(lpfc_poll, int, S_IRUGO);
2185 2186 2187 2188 2189
MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
		 " 0 - none,"
		 " 1 - poll with interrupts enabled"
		 " 3 - poll and disable FCP ring interrupts");

2190 2191
static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
		   lpfc_poll_show, lpfc_poll_store);
已提交
2192

2193
int  lpfc_sli_mode = 0;
2194
module_param(lpfc_sli_mode, int, S_IRUGO);
2195 2196 2197 2198 2199
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");

2200
int lpfc_enable_npiv = 1;
2201
module_param(lpfc_enable_npiv, int, S_IRUGO);
J
James Smart 已提交
2202 2203
MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality");
lpfc_param_show(enable_npiv);
J
James Smart 已提交
2204
lpfc_param_init(enable_npiv, 1, 0, 1);
2205
static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, lpfc_enable_npiv_show, NULL);
2206

2207 2208 2209
LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,
	"FCF Fast failover=1 Priority failover=2");

2210
int lpfc_enable_rrq;
2211
module_param(lpfc_enable_rrq, int, S_IRUGO);
2212 2213 2214 2215 2216
MODULE_PARM_DESC(lpfc_enable_rrq, "Enable RRQ functionality");
lpfc_param_show(enable_rrq);
lpfc_param_init(enable_rrq, 0, 0, 1);
static DEVICE_ATTR(lpfc_enable_rrq, S_IRUGO, lpfc_enable_rrq_show, NULL);

2217 2218 2219 2220 2221 2222 2223
/*
# lpfc_suppress_link_up:  Bring link up at initialization
#            0x0  = bring link up (issue MBX_INIT_LINK)
#            0x1  = do NOT bring link up at initialization(MBX_INIT_LINK)
#            0x2  = never bring up link
# Default value is 0.
*/
2224 2225 2226
LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
		LPFC_DELAY_INIT_LINK_INDEFINITELY,
		"Suppress Link Up at initialization");
2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272
/*
# lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
#       1 - (1024)
#       2 - (2048)
#       3 - (3072)
#       4 - (4096)
#       5 - (5120)
*/
static ssize_t
lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct Scsi_Host  *shost = class_to_shost(dev);
	struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;

	return snprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
}

static DEVICE_ATTR(iocb_hw, S_IRUGO,
			 lpfc_iocb_hw_show, NULL);
static ssize_t
lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct Scsi_Host  *shost = class_to_shost(dev);
	struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;

	return snprintf(buf, PAGE_SIZE, "%d\n",
		phba->sli.ring[LPFC_ELS_RING].txq_max);
}

static DEVICE_ATTR(txq_hw, S_IRUGO,
			 lpfc_txq_hw_show, NULL);
static ssize_t
lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
 char *buf)
{
	struct Scsi_Host  *shost = class_to_shost(dev);
	struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;

	return snprintf(buf, PAGE_SIZE, "%d\n",
		phba->sli.ring[LPFC_ELS_RING].txcmplq_max);
}

static DEVICE_ATTR(txcmplq_hw, S_IRUGO,
			 lpfc_txcmplq_hw_show, NULL);

int lpfc_iocb_cnt = 2;
2273
module_param(lpfc_iocb_cnt, int, S_IRUGO);
2274 2275 2276 2277 2278 2279
MODULE_PARM_DESC(lpfc_iocb_cnt,
	"Number of IOCBs alloc for ELS, CT, and ABTS: 1k to 5k IOCBs");
lpfc_param_show(iocb_cnt);
lpfc_param_init(iocb_cnt, 2, 1, 5);
static DEVICE_ATTR(lpfc_iocb_cnt, S_IRUGO,
			 lpfc_iocb_cnt_show, NULL);
2280

2281 2282 2283 2284 2285 2286 2287 2288 2289 2290
/*
# 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");
2291 2292

/**
2293
 * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
2294 2295 2296 2297 2298 2299
 * @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.
 **/
2300
static ssize_t
2301 2302
lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
2303
{
2304
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
2305
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2306

2307
	return snprintf(buf, PAGE_SIZE, "%d\n",	vport->cfg_devloss_tmo);
2308 2309
}

2310
/**
2311
 * lpfc_nodev_tmo_init - Set the hba nodev timeout value
2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324
 * @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
 **/
2325
static int
2326 2327 2328 2329 2330
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)
2331
			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2332
					 "0407 Ignoring nodev_tmo module "
2333 2334
					 "parameter because devloss_tmo is "
					 "set.\n");
2335 2336 2337 2338
		return 0;
	}

	if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2339 2340
		vport->cfg_nodev_tmo = val;
		vport->cfg_devloss_tmo = val;
2341 2342
		return 0;
	}
2343 2344 2345 2346
	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);
2347
	vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
2348 2349 2350
	return -EINVAL;
}

2351
/**
2352
 * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
2353 2354 2355 2356 2357
 * @vport: lpfc vport structure pointer.
 *
 * Description:
 * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
 **/
2358
static void
2359
lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
2360
{
J
James Smart 已提交
2361
	struct Scsi_Host  *shost;
2362 2363
	struct lpfc_nodelist  *ndlp;

2364 2365 2366
	shost = lpfc_shost_from_vport(vport);
	spin_lock_irq(shost->host_lock);
	list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
2367
		if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport)
2368 2369
			ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
	spin_unlock_irq(shost->host_lock);
2370 2371
}

2372
/**
2373
 * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386
 * @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
 **/
2387
static int
2388
lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
2389
{
2390 2391
	if (vport->dev_loss_tmo_changed ||
	    (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
2392 2393 2394
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
				 "0401 Ignoring change to nodev_tmo "
				 "because devloss_tmo is set.\n");
2395 2396 2397
		return 0;
	}
	if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2398 2399
		vport->cfg_nodev_tmo = val;
		vport->cfg_devloss_tmo = val;
2400 2401 2402 2403 2404
		/*
		 * For compat: set the fc_host dev loss so new rports
		 * will get the value.
		 */
		fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
2405
		lpfc_update_rport_devloss_tmo(vport);
2406 2407
		return 0;
	}
2408 2409 2410 2411
	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);
2412 2413 2414
	return -EINVAL;
}

2415
lpfc_vport_param_store(nodev_tmo)
2416

2417 2418
static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
		   lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
2419 2420 2421 2422 2423 2424

/*
# 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.
*/
2425
module_param(lpfc_devloss_tmo, int, S_IRUGO);
2426 2427 2428
MODULE_PARM_DESC(lpfc_devloss_tmo,
		 "Seconds driver will hold I/O waiting "
		 "for a device to come back");
2429 2430 2431
lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
		      LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
lpfc_vport_param_show(devloss_tmo)
2432 2433

/**
2434
 * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446
 * @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
 **/
2447
static int
2448
lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
2449 2450
{
	if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2451 2452 2453
		vport->cfg_nodev_tmo = val;
		vport->cfg_devloss_tmo = val;
		vport->dev_loss_tmo_changed = 1;
2454
		fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
2455
		lpfc_update_rport_devloss_tmo(vport);
2456 2457 2458
		return 0;
	}

2459 2460 2461 2462
	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);
2463 2464 2465
	return -EINVAL;
}

2466
lpfc_vport_param_store(devloss_tmo)
2467 2468
static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
		   lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
2469

已提交
2470 2471 2472 2473
/*
# 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:
2474
# See lpfc_logmsh.h for definitions.
已提交
2475
*/
2476
LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
2477
		       "Verbose logging bit-mask");
已提交
2478

J
James Smart 已提交
2479 2480 2481 2482 2483 2484 2485
/*
# 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");

已提交
2486 2487 2488 2489
/*
# 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.
*/
2490 2491
LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 128,
		  "Max number of FCP commands we can queue to a specific LUN");
已提交
2492

2493 2494 2495 2496 2497 2498 2499
/*
# tgt_queue_depth:  This parameter is used to limit the number of outstanding
# commands per target port. Value range is [10,65535]. Default value is 65535.
*/
LPFC_VPORT_ATTR_R(tgt_queue_depth, 65535, 10, 65535,
	"Max number of FCP commands we can queue to a specific target port");

2500 2501 2502 2503 2504 2505 2506 2507 2508 2509
/*
# 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");

2510 2511 2512 2513 2514 2515 2516 2517 2518
/*
# 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.
*/
2519 2520 2521
LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
		  "Allow peer ports on the same physical port to login to each "
		  "other.");
2522 2523

/*
2524
# restrict_login:  This parameter allows/prevents logins
2525 2526 2527 2528 2529 2530 2531 2532 2533
# 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.
*/
2534
static int lpfc_restrict_login = 1;
2535
module_param(lpfc_restrict_login, int, S_IRUGO);
2536 2537 2538 2539
MODULE_PARM_DESC(lpfc_restrict_login,
		 "Restrict virtual ports login to remote initiators.");
lpfc_vport_param_show(restrict_login);

2540
/**
2541
 * lpfc_restrict_login_init - Set the vport restrict login flag
2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554
 * @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
 **/
2555 2556 2557 2558
static int
lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
{
	if (val < 0 || val > 1) {
2559
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2560
				 "0422 lpfc_restrict_login attribute cannot "
2561 2562
				 "be set to %d, allowed range is [0, 1]\n",
				 val);
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573
		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;
}

2574
/**
2575
 * lpfc_restrict_login_set - Set the vport restrict login flag
2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589
 * @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
 **/
2590 2591 2592 2593
static int
lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
{
	if (val < 0 || val > 1) {
2594
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2595
				 "0425 lpfc_restrict_login attribute cannot "
2596 2597
				 "be set to %d, allowed range is [0, 1]\n",
				 val);
2598 2599 2600 2601
		vport->cfg_restrict_login = 1;
		return -EINVAL;
	}
	if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
2602 2603 2604
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
				 "0468 lpfc_restrict_login must be 0 for "
				 "Physical ports.\n");
2605 2606 2607 2608 2609 2610 2611
		vport->cfg_restrict_login = 0;
		return 0;
	}
	vport->cfg_restrict_login = val;
	return 0;
}
lpfc_vport_param_store(restrict_login);
2612 2613
static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
		   lpfc_restrict_login_show, lpfc_restrict_login_store);
2614

已提交
2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631
/*
# 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.)
*/
2632 2633
LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
		  "Start scanning for devices from highest ALPA to lowest");
已提交
2634 2635 2636 2637

/*
# lpfc_topology:  link topology for init link
#            0x0  = attempt loop mode then point-to-point
2638
#            0x01 = internal loopback mode
已提交
2639 2640 2641 2642 2643 2644 2645
#            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.
*/
2646 2647

/**
2648
 * lpfc_topology_set - Set the adapters topology field
2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662
 * @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
 **/
2663 2664 2665
static ssize_t
lpfc_topology_store(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
2666
{
2667 2668 2669 2670 2671 2672
	struct Scsi_Host  *shost = class_to_shost(dev);
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	int val = 0;
	int nolip = 0;
	const char *val_buf = buf;
2673 2674
	int err;
	uint32_t prev_val;
2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685

	if (!strncmp(buf, "nolip ", strlen("nolip "))) {
		nolip = 1;
		val_buf = &buf[strlen("nolip ")];
	}

	if (!isdigit(val_buf[0]))
		return -EINVAL;
	if (sscanf(val_buf, "%i", &val) != 1)
		return -EINVAL;

2686 2687 2688
	if (val >= 0 && val <= 6) {
		prev_val = phba->cfg_topology;
		phba->cfg_topology = val;
2689 2690 2691
		if (nolip)
			return strlen(buf);

2692 2693 2694
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
			"3054 lpfc_topology changed from %d to %d\n",
			prev_val, val);
2695
		err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
2696
		if (err) {
2697
			phba->cfg_topology = prev_val;
2698 2699 2700
			return -EINVAL;
		} else
			return strlen(buf);
2701 2702 2703 2704 2705 2706 2707 2708
	}
	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;
2709
module_param(lpfc_topology, int, S_IRUGO);
2710 2711 2712
MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology");
lpfc_param_show(topology)
lpfc_param_init(topology, 0, 0, 6)
2713
static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR,
2714
		lpfc_topology_show, lpfc_topology_store);
已提交
2715

2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745
/**
 * lpfc_static_vport_show: Read callback function for
 *   lpfc_static_vport sysfs file.
 * @dev: Pointer to class device object.
 * @attr: device attribute structure.
 * @buf: Data buffer.
 *
 * This function is the read call back function for
 * lpfc_static_vport sysfs file. The lpfc_static_vport
 * sysfs file report the mageability of the vport.
 **/
static ssize_t
lpfc_static_vport_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;
	if (vport->vport_flag & STATIC_VPORT)
		sprintf(buf, "1\n");
	else
		sprintf(buf, "0\n");

	return strlen(buf);
}

/*
 * Sysfs attribute to control the statistical data collection.
 */
static DEVICE_ATTR(lpfc_static_vport, S_IRUGO,
		   lpfc_static_vport_show, NULL);
2746 2747

/**
2748
 * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file
2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782
 * @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"))) {
2783
		if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1))
2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820
			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;

2821
		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835
			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;

2836
		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852
			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;

2853
		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911
			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;
}


/**
2912
 * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file
2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988
 * @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)


/**
2989
 * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
2990
 * @filp: sysfs file
2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001
 * @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
3002 3003
sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj,
		struct bin_attribute *bin_attr,
3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072
		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,
	},
	.size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET,
	.read = sysfs_drvr_stat_data_read,
	.write = NULL,
};

已提交
3073 3074 3075
/*
# lpfc_link_speed: Link speed selection for initializing the Fibre Channel
# connection.
3076
# Value range is [0,16]. Default value is 0.
已提交
3077
*/
3078
/**
3079
 * lpfc_link_speed_set - Set the adapters link speed
3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094
 * @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
 **/
3095 3096 3097
static ssize_t
lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
3098
{
3099 3100 3101
	struct Scsi_Host  *shost = class_to_shost(dev);
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
3102
	int val = LPFC_USER_LINK_SPEED_AUTO;
3103 3104
	int nolip = 0;
	const char *val_buf = buf;
3105 3106 3107
	int err;
	uint32_t prev_val;

3108 3109 3110 3111 3112 3113 3114 3115 3116 3117
	if (!strncmp(buf, "nolip ", strlen("nolip "))) {
		nolip = 1;
		val_buf = &buf[strlen("nolip ")];
	}

	if (!isdigit(val_buf[0]))
		return -EINVAL;
	if (sscanf(val_buf, "%i", &val) != 1)
		return -EINVAL;

3118 3119 3120 3121
	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
		"3055 lpfc_link_speed changed from %d to %d %s\n",
		phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)");

3122 3123 3124 3125 3126 3127 3128 3129 3130 3131
	if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
	    ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
	    ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
	    ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
	    ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) ||
	    ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb))) {
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
				"2879 lpfc_link_speed attribute cannot be set "
				"to %d. Speed is not supported by this port.\n",
				val);
3132
		return -EINVAL;
3133 3134 3135
	}
	if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
	    (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
3136 3137
		prev_val = phba->cfg_link_speed;
		phba->cfg_link_speed = val;
3138 3139 3140
		if (nolip)
			return strlen(buf);

3141
		err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
3142
		if (err) {
3143
			phba->cfg_link_speed = prev_val;
3144 3145 3146
			return -EINVAL;
		} else
			return strlen(buf);
3147 3148
	}
	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3149 3150
		"0469 lpfc_link_speed attribute cannot be set to %d, "
		"allowed values are ["LPFC_LINK_SPEED_STRING"]\n", val);
3151 3152 3153 3154
	return -EINVAL;
}

static int lpfc_link_speed = 0;
3155
module_param(lpfc_link_speed, int, S_IRUGO);
3156 3157
MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
lpfc_param_show(link_speed)
3158 3159

/**
3160
 * lpfc_link_speed_init - Set the adapters link speed
3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174
 * @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
 **/
3175 3176 3177
static int
lpfc_link_speed_init(struct lpfc_hba *phba, int val)
{
3178 3179
	if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
	    (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
3180 3181 3182 3183
		phba->cfg_link_speed = val;
		return 0;
	}
	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3184
			"0405 lpfc_link_speed attribute cannot "
3185 3186
			"be set to %d, allowed values are "
			"["LPFC_LINK_SPEED_STRING"]\n", val);
3187
	phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
3188 3189 3190
	return -EINVAL;
}

3191
static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
3192
		   lpfc_link_speed_show, lpfc_link_speed_store);
已提交
3193

J
James Smart 已提交
3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205
/*
# lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
#       0  = aer disabled or not supported
#       1  = aer supported and enabled (default)
# Value range is [0,1]. Default value is 1.
*/

/**
 * lpfc_aer_support_store - Set the adapter for aer support
 *
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
3206
 * @buf: containing enable or disable aer flag.
J
James Smart 已提交
3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252
 * @count: unused variable.
 *
 * Description:
 * If the val is 1 and currently the device's AER capability was not
 * enabled, invoke the kernel's enable AER helper routine, trying to
 * enable the device's AER capability. If the helper routine enabling
 * AER returns success, update the device's cfg_aer_support flag to
 * indicate AER is supported by the device; otherwise, if the device
 * AER capability is already enabled to support AER, then do nothing.
 *
 * If the val is 0 and currently the device's AER support was enabled,
 * invoke the kernel's disable AER helper routine. After that, update
 * the device's cfg_aer_support flag to indicate AER is not supported
 * by the device; otherwise, if the device AER capability is already
 * disabled from supporting AER, then do nothing.
 *
 * Returns:
 * length of the buf on success if val is in range the intended mode
 * is supported.
 * -EINVAL if val out of range or intended mode is not supported.
 **/
static ssize_t
lpfc_aer_support_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;
	int val = 0, rc = -EINVAL;

	if (!isdigit(buf[0]))
		return -EINVAL;
	if (sscanf(buf, "%i", &val) != 1)
		return -EINVAL;

	switch (val) {
	case 0:
		if (phba->hba_flag & HBA_AER_ENABLED) {
			rc = pci_disable_pcie_error_reporting(phba->pcidev);
			if (!rc) {
				spin_lock_irq(&phba->hbalock);
				phba->hba_flag &= ~HBA_AER_ENABLED;
				spin_unlock_irq(&phba->hbalock);
				phba->cfg_aer_support = 0;
				rc = strlen(buf);
			} else
J
James Smart 已提交
3253 3254
				rc = -EPERM;
		} else {
J
James Smart 已提交
3255
			phba->cfg_aer_support = 0;
J
James Smart 已提交
3256 3257
			rc = strlen(buf);
		}
J
James Smart 已提交
3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268
		break;
	case 1:
		if (!(phba->hba_flag & HBA_AER_ENABLED)) {
			rc = pci_enable_pcie_error_reporting(phba->pcidev);
			if (!rc) {
				spin_lock_irq(&phba->hbalock);
				phba->hba_flag |= HBA_AER_ENABLED;
				spin_unlock_irq(&phba->hbalock);
				phba->cfg_aer_support = 1;
				rc = strlen(buf);
			} else
J
James Smart 已提交
3269 3270
				 rc = -EPERM;
		} else {
J
James Smart 已提交
3271
			phba->cfg_aer_support = 1;
J
James Smart 已提交
3272 3273
			rc = strlen(buf);
		}
J
James Smart 已提交
3274 3275 3276 3277 3278 3279 3280 3281 3282
		break;
	default:
		rc = -EINVAL;
		break;
	}
	return rc;
}

static int lpfc_aer_support = 1;
3283
module_param(lpfc_aer_support, int, S_IRUGO);
J
James Smart 已提交
3284 3285 3286 3287 3288 3289
MODULE_PARM_DESC(lpfc_aer_support, "Enable PCIe device AER support");
lpfc_param_show(aer_support)

/**
 * lpfc_aer_support_init - Set the initial adapters aer support flag
 * @phba: lpfc_hba pointer.
3290
 * @val: enable aer or disable aer flag.
J
James Smart 已提交
3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316
 *
 * Description:
 * If val is in a valid range [0,1], then set the adapter's initial
 * cfg_aer_support field. It will be up to the driver's probe_one
 * routine to determine whether the device's AER support can be set
 * or not.
 *
 * Notes:
 * If the value is not in range log a kernel error message, and
 * choose the default value of setting AER support and return.
 *
 * Returns:
 * zero if val saved.
 * -EINVAL val out of range
 **/
static int
lpfc_aer_support_init(struct lpfc_hba *phba, int val)
{
	if (val == 0 || val == 1) {
		phba->cfg_aer_support = val;
		return 0;
	}
	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
			"2712 lpfc_aer_support attribute value %d out "
			"of range, allowed values are 0|1, setting it "
			"to default value of 1\n", val);
J
James Smart 已提交
3317
	/* By default, try to enable AER on a device */
J
James Smart 已提交
3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328
	phba->cfg_aer_support = 1;
	return -EINVAL;
}

static DEVICE_ATTR(lpfc_aer_support, S_IRUGO | S_IWUSR,
		   lpfc_aer_support_show, lpfc_aer_support_store);

/**
 * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
3329
 * @buf: containing flag 1 for aer cleanup state.
J
James Smart 已提交
3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356
 * @count: unused variable.
 *
 * Description:
 * If the @buf contains 1 and the device currently has the AER support
 * enabled, then invokes the kernel AER helper routine
 * pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable
 * error status register.
 *
 * Notes:
 *
 * Returns:
 * -EINVAL if the buf does not contain the 1 or the device is not currently
 * enabled with the AER support.
 **/
static ssize_t
lpfc_aer_cleanup_state(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;
	int val, rc = -1;

	if (!isdigit(buf[0]))
		return -EINVAL;
	if (sscanf(buf, "%i", &val) != 1)
		return -EINVAL;
J
James Smart 已提交
3357 3358
	if (val != 1)
		return -EINVAL;
J
James Smart 已提交
3359

J
James Smart 已提交
3360
	if (phba->hba_flag & HBA_AER_ENABLED)
J
James Smart 已提交
3361 3362 3363 3364 3365
		rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev);

	if (rc == 0)
		return strlen(buf);
	else
J
James Smart 已提交
3366
		return -EPERM;
J
James Smart 已提交
3367 3368 3369 3370 3371
}

static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
		   lpfc_aer_cleanup_state);

3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501
/**
 * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
 *
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: containing the string the number of vfs to be enabled.
 * @count: unused variable.
 *
 * Description:
 * When this api is called either through user sysfs, the driver shall
 * try to enable or disable SR-IOV virtual functions according to the
 * following:
 *
 * If zero virtual function has been enabled to the physical function,
 * the driver shall invoke the pci enable virtual function api trying
 * to enable the virtual functions. If the nr_vfn provided is greater
 * than the maximum supported, the maximum virtual function number will
 * be used for invoking the api; otherwise, the nr_vfn provided shall
 * be used for invoking the api. If the api call returned success, the
 * actual number of virtual functions enabled will be set to the driver
 * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
 * cfg_sriov_nr_virtfn remains zero.
 *
 * If none-zero virtual functions have already been enabled to the
 * physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
 * -EINVAL will be returned and the driver does nothing;
 *
 * If the nr_vfn provided is zero and none-zero virtual functions have
 * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
 * disabling virtual function api shall be invoded to disable all the
 * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
 * zero. Otherwise, if zero virtual function has been enabled, do
 * nothing.
 *
 * Returns:
 * length of the buf on success if val is in range the intended mode
 * is supported.
 * -EINVAL if val out of range or intended mode is not supported.
 **/
static ssize_t
lpfc_sriov_nr_virtfn_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;
	struct pci_dev *pdev = phba->pcidev;
	int val = 0, rc = -EINVAL;

	/* Sanity check on user data */
	if (!isdigit(buf[0]))
		return -EINVAL;
	if (sscanf(buf, "%i", &val) != 1)
		return -EINVAL;
	if (val < 0)
		return -EINVAL;

	/* Request disabling virtual functions */
	if (val == 0) {
		if (phba->cfg_sriov_nr_virtfn > 0) {
			pci_disable_sriov(pdev);
			phba->cfg_sriov_nr_virtfn = 0;
		}
		return strlen(buf);
	}

	/* Request enabling virtual functions */
	if (phba->cfg_sriov_nr_virtfn > 0) {
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
				"3018 There are %d virtual functions "
				"enabled on physical function.\n",
				phba->cfg_sriov_nr_virtfn);
		return -EEXIST;
	}

	if (val <= LPFC_MAX_VFN_PER_PFN)
		phba->cfg_sriov_nr_virtfn = val;
	else {
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
				"3019 Enabling %d virtual functions is not "
				"allowed.\n", val);
		return -EINVAL;
	}

	rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn);
	if (rc) {
		phba->cfg_sriov_nr_virtfn = 0;
		rc = -EPERM;
	} else
		rc = strlen(buf);

	return rc;
}

static int lpfc_sriov_nr_virtfn = LPFC_DEF_VFN_PER_PFN;
module_param(lpfc_sriov_nr_virtfn, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(lpfc_sriov_nr_virtfn, "Enable PCIe device SR-IOV virtual fn");
lpfc_param_show(sriov_nr_virtfn)

/**
 * lpfc_sriov_nr_virtfn_init - Set the initial sr-iov virtual function enable
 * @phba: lpfc_hba pointer.
 * @val: link speed value.
 *
 * Description:
 * If val is in a valid range [0,255], then set the adapter's initial
 * cfg_sriov_nr_virtfn field. If it's greater than the maximum, the maximum
 * number shall be used instead. It will be up to the driver's probe_one
 * routine to determine whether the device's SR-IOV is supported or not.
 *
 * Returns:
 * zero if val saved.
 * -EINVAL val out of range
 **/
static int
lpfc_sriov_nr_virtfn_init(struct lpfc_hba *phba, int val)
{
	if (val >= 0 && val <= LPFC_MAX_VFN_PER_PFN) {
		phba->cfg_sriov_nr_virtfn = val;
		return 0;
	}

	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
			"3017 Enabling %d virtual functions is not "
			"allowed.\n", val);
	return -EINVAL;
}
static DEVICE_ATTR(lpfc_sriov_nr_virtfn, S_IRUGO | S_IWUSR,
		   lpfc_sriov_nr_virtfn_show, lpfc_sriov_nr_virtfn_store);

已提交
3502 3503 3504 3505
/*
# lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
# Value range is [2,3]. Default value is 3.
*/
3506 3507
LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
		  "Select Fibre Channel class of service for FCP sequences");
已提交
3508 3509 3510 3511 3512

/*
# lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
# is [0,1]. Default value is 0.
*/
3513 3514
LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1,
		   "Use ADISC on rediscovery to authenticate FCP devices");
已提交
3515

3516 3517 3518 3519 3520 3521 3522 3523 3524
/*
# 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;
3525
module_param(lpfc_max_scsicmpl_time, int, S_IRUGO);
3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547
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;
3548
		ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
3549 3550 3551 3552 3553 3554 3555 3556 3557
	}
	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);

已提交
3558 3559 3560 3561 3562 3563 3564 3565 3566
/*
# 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
3567
# value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
已提交
3568 3569 3570
# is 0. Default value of cr_count is 1. The cr_count feature is disabled if
# cr_delay is set to 0.
*/
3571
LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
已提交
3572 3573
		"interrupt response is generated");

3574
LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
已提交
3575 3576
		"interrupt response is generated");

3577 3578 3579 3580 3581 3582 3583 3584
/*
# 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");

3585 3586 3587 3588 3589
/*
# 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).
*/
3590
LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
3591 3592 3593 3594 3595 3596 3597
	     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).
*/
3598
LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
3599 3600
	     255, "Identifies TYPE for additional ring configuration");

已提交
3601 3602 3603 3604 3605 3606 3607
/*
# 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.
*/
3608
LPFC_VPORT_ATTR_RW(fdmi_on, 0, 0, 2, "Enable FDMI support");
已提交
3609 3610 3611 3612 3613

/*
# Specifies the maximum number of ELS cmds we can have outstanding (for
# discovery). Value range is [1,64]. Default value = 32.
*/
3614
LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
已提交
3615 3616 3617
		 "during discovery");

/*
J
James Smart 已提交
3618 3619 3620
# 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.
已提交
3621
*/
3622
LPFC_VPORT_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN");
已提交
3623

3624 3625 3626 3627 3628 3629 3630
/*
# 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");

3631 3632 3633
/*
# lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
#		support this feature
3634
#       0  = MSI disabled
3635
#       1  = MSI enabled
3636 3637
#       2  = MSI-X enabled (default)
# Value range is [0,2]. Default value is 2.
3638
*/
3639
LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
3640
	    "MSI-X (2), if possible");
3641

3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665
/*
# lpfc_fcp_imax: Set the maximum number of fast-path FCP interrupts per second
#
# Value range is [636,651042]. Default value is 10000.
*/
LPFC_ATTR_R(fcp_imax, LPFC_FP_DEF_IMAX, LPFC_MIM_IMAX, LPFC_DMULT_CONST,
	    "Set the maximum number of fast-path FCP interrupts per second");

/*
# lpfc_fcp_wq_count: Set the number of fast-path FCP work queues
#
# Value range is [1,31]. Default value is 4.
*/
LPFC_ATTR_R(fcp_wq_count, LPFC_FP_WQN_DEF, LPFC_FP_WQN_MIN, LPFC_FP_WQN_MAX,
	    "Set the number of fast-path FCP work queues, if possible");

/*
# lpfc_fcp_eq_count: Set the number of fast-path FCP event queues
#
# Value range is [1,7]. Default value is 1.
*/
LPFC_ATTR_R(fcp_eq_count, LPFC_FP_EQN_DEF, LPFC_FP_EQN_MIN, LPFC_FP_EQN_MAX,
	    "Set the number of fast-path FCP event queues, if possible");

3666 3667 3668 3669 3670 3671 3672
/*
# 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.");
3673

3674
/*
3675
# lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
3676 3677 3678 3679
#       0  = HBA Heartbeat disabled
#       1  = HBA Heartbeat enabled (default)
# Value range is [0,1]. Default value is 1.
*/
3680
LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
3681

3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698
/*
# lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
#       0  = BlockGuard disabled (default)
#       1  = BlockGuard enabled
# Value range is [0,1]. Default value is 0.
*/
LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");

/*
# lpfc_prot_mask: i
#	- Bit mask of host protection capabilities used to register with the
#	  SCSI mid-layer
# 	- Only meaningful if BG is turned on (lpfc_enable_bg=1).
#	- Allows you to ultimately specify which profiles to use
#	- Default will result in registering capabilities for all profiles.
#
*/
J
James Smart 已提交
3699 3700 3701
unsigned int lpfc_prot_mask = SHOST_DIF_TYPE1_PROTECTION |
			      SHOST_DIX_TYPE0_PROTECTION |
			      SHOST_DIX_TYPE1_PROTECTION;
3702

3703
module_param(lpfc_prot_mask, uint, S_IRUGO);
3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714
MODULE_PARM_DESC(lpfc_prot_mask, "host protection mask");

/*
# lpfc_prot_guard: i
#	- Bit mask of protection guard types to register with the SCSI mid-layer
# 	- Guard types are currently either 1) IP checksum 2) T10-DIF CRC
#	- Allows you to ultimately specify which profiles to use
#	- Default will result in registering capabilities for all guard types
#
*/
unsigned char lpfc_prot_guard = SHOST_DIX_GUARD_IP;
3715
module_param(lpfc_prot_guard, byte, S_IRUGO);
3716 3717
MODULE_PARM_DESC(lpfc_prot_guard, "host protection guard type");

3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732
/*
 * Delay initial NPort discovery when Clean Address bit is cleared in
 * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed.
 * This parameter can have value 0 or 1.
 * When this parameter is set to 0, no delay is added to the initial
 * discovery.
 * When this parameter is set to non-zero value, initial Nport discovery is
 * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC
 * accept and FCID/Fabric name/Fabric portname is changed.
 * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion
 * when Clean Address bit is cleared in FLOGI/FDISC
 * accept and FCID/Fabric name/Fabric portname is changed.
 * Default value is 0.
 */
int lpfc_delay_discovery;
3733
module_param(lpfc_delay_discovery, int, S_IRUGO);
3734 3735 3736
MODULE_PARM_DESC(lpfc_delay_discovery,
	"Delay NPort discovery when Clean Address bit is cleared. "
	"Allowed values: 0,1.");
3737

3738
/*
3739
 * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
3740 3741 3742 3743 3744 3745 3746
 * 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");

3747 3748 3749 3750
LPFC_ATTR_R(prot_sg_seg_cnt, LPFC_DEFAULT_PROT_SG_SEG_CNT,
		LPFC_DEFAULT_PROT_SG_SEG_CNT, LPFC_MAX_PROT_SG_SEG_CNT,
		"Max Protection Scatter Gather Segment Count");

3751
struct device_attribute *lpfc_hba_attrs[] = {
3752 3753 3754 3755
	&dev_attr_bg_info,
	&dev_attr_bg_guard_err,
	&dev_attr_bg_apptag_err,
	&dev_attr_bg_reftag_err,
3756 3757 3758 3759 3760 3761 3762 3763 3764
	&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,
3765
	&dev_attr_link_state,
3766
	&dev_attr_num_discovered_ports,
3767
	&dev_attr_menlo_mgmt_mode,
3768
	&dev_attr_lpfc_drvr_version,
3769
	&dev_attr_lpfc_enable_fip,
3770 3771 3772
	&dev_attr_lpfc_temp_sensor,
	&dev_attr_lpfc_log_verbose,
	&dev_attr_lpfc_lun_queue_depth,
3773
	&dev_attr_lpfc_tgt_queue_depth,
3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791
	&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,
3792
	&dev_attr_lpfc_fcf_failover_policy,
3793
	&dev_attr_lpfc_enable_rrq,
3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806
	&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,
3807 3808 3809
	&dev_attr_lpfc_fcp_imax,
	&dev_attr_lpfc_fcp_wq_count,
	&dev_attr_lpfc_fcp_eq_count,
3810
	&dev_attr_lpfc_enable_bg,
3811 3812 3813 3814 3815 3816
	&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,
3817
	&dev_attr_lpfc_max_scsicmpl_time,
3818
	&dev_attr_lpfc_stat_data_ctrl,
3819
	&dev_attr_lpfc_prot_sg_seg_cnt,
J
James Smart 已提交
3820 3821
	&dev_attr_lpfc_aer_support,
	&dev_attr_lpfc_aer_state_cleanup,
3822
	&dev_attr_lpfc_sriov_nr_virtfn,
3823
	&dev_attr_lpfc_suppress_link_up,
3824 3825 3826 3827
	&dev_attr_lpfc_iocb_cnt,
	&dev_attr_iocb_hw,
	&dev_attr_txq_hw,
	&dev_attr_txcmplq_hw,
3828 3829
	&dev_attr_lpfc_fips_level,
	&dev_attr_lpfc_fips_rev,
3830
	&dev_attr_lpfc_dss,
3831
	&dev_attr_lpfc_sriov_hw_max_virtfn,
已提交
3832 3833 3834
	NULL,
};

3835 3836
struct device_attribute *lpfc_vport_attrs[] = {
	&dev_attr_info,
3837
	&dev_attr_link_state,
3838 3839 3840 3841
	&dev_attr_num_discovered_ports,
	&dev_attr_lpfc_drvr_version,
	&dev_attr_lpfc_log_verbose,
	&dev_attr_lpfc_lun_queue_depth,
3842
	&dev_attr_lpfc_tgt_queue_depth,
3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854
	&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,
3855 3856
	&dev_attr_lpfc_max_scsicmpl_time,
	&dev_attr_lpfc_stat_data_ctrl,
3857
	&dev_attr_lpfc_static_vport,
3858 3859
	&dev_attr_lpfc_fips_level,
	&dev_attr_lpfc_fips_rev,
3860 3861 3862
	NULL,
};

3863
/**
3864
 * sysfs_ctlreg_write - Write method for writing to ctlreg
3865
 * @filp: open sysfs file
3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881
 * @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
 **/
已提交
3882
static ssize_t
3883 3884
sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
		   struct bin_attribute *bin_attr,
3885
		   char *buf, loff_t off, size_t count)
已提交
3886 3887
{
	size_t buf_off;
3888 3889
	struct device *dev = container_of(kobj, struct device, kobj);
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
3890 3891
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
3892

3893 3894 3895
	if (phba->sli_rev >= LPFC_SLI_REV4)
		return -EPERM;

已提交
3896 3897 3898
	if ((off + count) > FF_REG_AREA_SIZE)
		return -ERANGE;

3899 3900
	if (count <= LPFC_REG_WRITE_KEY_SIZE)
		return 0;
已提交
3901 3902 3903 3904

	if (off % 4 || count % 4 || (unsigned long)buf % 4)
		return -EINVAL;

3905 3906 3907 3908 3909
	/* This is to protect HBA registers from accidental writes. */
	if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE))
		return -EINVAL;

	if (!(vport->fc_flag & FC_OFFLINE_MODE))
已提交
3910 3911
		return -EPERM;

J
James Smart 已提交
3912
	spin_lock_irq(&phba->hbalock);
3913 3914 3915
	for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE;
			buf_off += sizeof(uint32_t))
		writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)),
已提交
3916 3917
		       phba->ctrl_regs_memmap_p + off + buf_off);

J
James Smart 已提交
3918
	spin_unlock_irq(&phba->hbalock);
已提交
3919 3920 3921 3922

	return count;
}

3923
/**
3924
 * sysfs_ctlreg_read - Read method for reading from ctlreg
3925
 * @filp: open sysfs file
3926 3927
 * @kobj: kernel kobject that contains the kernel class device.
 * @bin_attr: kernel attributes passed to us.
3928
 * @buf: if successful contains the data from the adapter IOREG space.
3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940
 * @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
 **/
已提交
3941
static ssize_t
3942 3943
sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
		  struct bin_attribute *bin_attr,
3944
		  char *buf, loff_t off, size_t count)
已提交
3945 3946 3947
{
	size_t buf_off;
	uint32_t * tmp_ptr;
3948 3949
	struct device *dev = container_of(kobj, struct device, kobj);
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
3950 3951
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
3952

3953 3954 3955
	if (phba->sli_rev >= LPFC_SLI_REV4)
		return -EPERM;

已提交
3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966
	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;

J
James Smart 已提交
3967
	spin_lock_irq(&phba->hbalock);
已提交
3968 3969 3970 3971 3972 3973

	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);
	}

J
James Smart 已提交
3974
	spin_unlock_irq(&phba->hbalock);
已提交
3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988

	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,
};

3989
/**
3990
 * sysfs_mbox_idle - frees the sysfs mailbox
3991 3992
 * @phba: lpfc_hba pointer
 **/
已提交
3993
static void
J
James Smart 已提交
3994
sysfs_mbox_idle(struct lpfc_hba *phba)
已提交
3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005
{
	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;
	}
}

4006
/**
4007
 * sysfs_mbox_write - Write method for writing information via mbox
4008
 * @filp: open sysfs file
4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027
 * @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
 **/
已提交
4028
static ssize_t
4029 4030
sysfs_mbox_write(struct file *filp, struct kobject *kobj,
		 struct bin_attribute *bin_attr,
4031
		 char *buf, loff_t off, size_t count)
已提交
4032
{
4033 4034
	struct device *dev = container_of(kobj, struct device, kobj);
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
4035 4036 4037
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	struct lpfcMboxq  *mbox = NULL;
已提交
4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051

	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;
J
James Smart 已提交
4052
		memset(mbox, 0, sizeof (LPFC_MBOXQ_t));
已提交
4053 4054
	}

J
James Smart 已提交
4055
	spin_lock_irq(&phba->hbalock);
已提交
4056 4057 4058 4059 4060 4061 4062 4063 4064 4065

	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           ||
4066
		    phba->sysfs_mbox.mbox   == NULL) {
已提交
4067
			sysfs_mbox_idle(phba);
J
James Smart 已提交
4068
			spin_unlock_irq(&phba->hbalock);
4069
			return -EAGAIN;
已提交
4070 4071 4072
		}
	}

4073
	memcpy((uint8_t *) &phba->sysfs_mbox.mbox->u.mb + off,
已提交
4074 4075 4076 4077
	       buf, count);

	phba->sysfs_mbox.offset = off + count;

J
James Smart 已提交
4078
	spin_unlock_irq(&phba->hbalock);
已提交
4079 4080 4081 4082

	return count;
}

4083
/**
4084
 * sysfs_mbox_read - Read method for reading information via mbox
4085
 * @filp: open sysfs file
4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106
 * @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
 **/
已提交
4107
static ssize_t
4108 4109
sysfs_mbox_read(struct file *filp, struct kobject *kobj,
		struct bin_attribute *bin_attr,
4110
		char *buf, loff_t off, size_t count)
已提交
4111
{
4112 4113
	struct device *dev = container_of(kobj, struct device, kobj);
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
4114 4115
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
4116
	LPFC_MBOXQ_t *mboxq;
4117
	MAILBOX_t *pmb;
4118 4119
	uint32_t mbox_tmo;
	int rc;
已提交
4120

4121
	if (off > MAILBOX_CMD_SIZE)
已提交
4122 4123
		return -ERANGE;

4124 4125
	if ((count + off) > MAILBOX_CMD_SIZE)
		count = MAILBOX_CMD_SIZE - off;
已提交
4126 4127 4128 4129 4130 4131 4132

	if (off % 4 ||  count % 4 || (unsigned long)buf % 4)
		return -EINVAL;

	if (off && count == 0)
		return 0;

J
James Smart 已提交
4133
	spin_lock_irq(&phba->hbalock);
已提交
4134

4135 4136 4137
	if (phba->over_temp_state == HBA_OVER_TEMP) {
		sysfs_mbox_idle(phba);
		spin_unlock_irq(&phba->hbalock);
4138
		return  -EACCES;
4139 4140
	}

已提交
4141 4142 4143
	if (off == 0 &&
	    phba->sysfs_mbox.state  == SMBOX_WRITING &&
	    phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) {
4144 4145
		mboxq = (LPFC_MBOXQ_t *)&phba->sysfs_mbox.mbox;
		pmb = &mboxq->u.mb;
4146
		switch (pmb->mbxCommand) {
已提交
4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159
			/* 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:
J
James Smart 已提交
4160
			if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
已提交
4161 4162
				printk(KERN_WARNING "mbox_read:Command 0x%x "
				       "is illegal in on-line state\n",
4163
				       pmb->mbxCommand);
已提交
4164
				sysfs_mbox_idle(phba);
J
James Smart 已提交
4165
				spin_unlock_irq(&phba->hbalock);
已提交
4166 4167
				return -EPERM;
			}
4168 4169
		case MBX_WRITE_NV:
		case MBX_WRITE_VPARMS:
已提交
4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180
		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:
4181
		case MBX_KILL_BOARD:
已提交
4182 4183
		case MBX_LOAD_AREA:
		case MBX_LOAD_EXP_ROM:
4184 4185
		case MBX_BEACON:
		case MBX_DEL_LD_ENTRY:
4186 4187
		case MBX_SET_VARIABLE:
		case MBX_WRITE_WWN:
4188 4189
		case MBX_PORT_CAPABILITIES:
		case MBX_PORT_IOV_CONTROL:
已提交
4190
			break;
4191 4192
		case MBX_SECURITY_MGMT:
		case MBX_AUTH_PORT:
4193 4194 4195 4196 4197
			if (phba->pci_dev_grp == LPFC_PCI_DEV_OC) {
				printk(KERN_WARNING "mbox_read:Command 0x%x "
				       "is not permitted\n", pmb->mbxCommand);
				sysfs_mbox_idle(phba);
				spin_unlock_irq(&phba->hbalock);
4198
				return -EPERM;
4199
			}
4200
			break;
已提交
4201
		case MBX_READ_SPARM64:
4202
		case MBX_READ_TOPOLOGY:
已提交
4203 4204 4205 4206 4207
		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",
4208
			       pmb->mbxCommand);
已提交
4209
			sysfs_mbox_idle(phba);
J
James Smart 已提交
4210
			spin_unlock_irq(&phba->hbalock);
已提交
4211 4212 4213
			return -EPERM;
		default:
			printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n",
4214
			       pmb->mbxCommand);
已提交
4215
			sysfs_mbox_idle(phba);
J
James Smart 已提交
4216
			spin_unlock_irq(&phba->hbalock);
已提交
4217 4218 4219
			return -EPERM;
		}

4220
		/* If HBA encountered an error attention, allow only DUMP
4221
		 * or RESTART mailbox commands until the HBA is restarted.
4222
		 */
4223
		if (phba->pport->stopped &&
4224 4225 4226 4227
		    pmb->mbxCommand != MBX_DUMP_MEMORY &&
		    pmb->mbxCommand != MBX_RESTART &&
		    pmb->mbxCommand != MBX_WRITE_VPARMS &&
		    pmb->mbxCommand != MBX_WRITE_WWN)
4228 4229 4230
			lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
					"1259 mbox: Issued mailbox cmd "
					"0x%x while in stopped state.\n",
4231
					pmb->mbxCommand);
4232

4233 4234
		phba->sysfs_mbox.mbox->vport = vport;

4235 4236 4237
		/* Don't allow mailbox commands to be sent when blocked
		 * or when in the middle of discovery
		 */
4238
		if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
4239
			sysfs_mbox_idle(phba);
J
James Smart 已提交
4240
			spin_unlock_irq(&phba->hbalock);
4241 4242 4243
			return  -EAGAIN;
		}

J
James Smart 已提交
4244
		if ((vport->fc_flag & FC_OFFLINE_MODE) ||
4245
		    (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE))) {
已提交
4246

J
James Smart 已提交
4247
			spin_unlock_irq(&phba->hbalock);
已提交
4248 4249 4250
			rc = lpfc_sli_issue_mbox (phba,
						  phba->sysfs_mbox.mbox,
						  MBX_POLL);
J
James Smart 已提交
4251
			spin_lock_irq(&phba->hbalock);
已提交
4252 4253

		} else {
J
James Smart 已提交
4254
			spin_unlock_irq(&phba->hbalock);
4255 4256
			mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq);
			rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
J
James Smart 已提交
4257
			spin_lock_irq(&phba->hbalock);
已提交
4258 4259 4260
		}

		if (rc != MBX_SUCCESS) {
4261 4262 4263
			if (rc == MBX_TIMEOUT) {
				phba->sysfs_mbox.mbox = NULL;
			}
已提交
4264
			sysfs_mbox_idle(phba);
J
James Smart 已提交
4265
			spin_unlock_irq(&phba->hbalock);
4266
			return  (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
已提交
4267 4268 4269 4270 4271 4272 4273
		}
		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);
J
James Smart 已提交
4274
		spin_unlock_irq(&phba->hbalock);
4275
		return -EAGAIN;
已提交
4276 4277
	}

4278
	memcpy(buf, (uint8_t *) &pmb + off, count);
已提交
4279 4280 4281

	phba->sysfs_mbox.offset = off + count;

4282
	if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE)
已提交
4283 4284
		sysfs_mbox_idle(phba);

J
James Smart 已提交
4285
	spin_unlock_irq(&phba->hbalock);
已提交
4286 4287 4288 4289 4290 4291 4292 4293 4294

	return count;
}

static struct bin_attribute sysfs_mbox_attr = {
	.attr = {
		.name = "mbox",
		.mode = S_IRUSR | S_IWUSR,
	},
4295
	.size = MAILBOX_SYSFS_MAX,
已提交
4296 4297 4298 4299
	.read = sysfs_mbox_read,
	.write = sysfs_mbox_write,
};

4300
/**
4301
 * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
4302 4303 4304 4305 4306 4307
 * @vport: address of lpfc vport structure.
 *
 * Return codes:
 * zero on success
 * error return code from sysfs_create_bin_file()
 **/
已提交
4308
int
J
James Smart 已提交
4309
lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
已提交
4310
{
J
James Smart 已提交
4311
	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
已提交
4312 4313
	int error;

4314
	error = sysfs_create_bin_file(&shost->shost_dev.kobj,
4315 4316 4317 4318
				      &sysfs_drvr_stat_data_attr);

	/* Virtual ports do not need ctrl_reg and mbox */
	if (error || vport->port_type == LPFC_NPIV_PORT)
已提交
4319 4320
		goto out;

4321
	error = sysfs_create_bin_file(&shost->shost_dev.kobj,
4322
				      &sysfs_ctlreg_attr);
已提交
4323
	if (error)
4324
		goto out_remove_stat_attr;
已提交
4325

4326
	error = sysfs_create_bin_file(&shost->shost_dev.kobj,
4327
				      &sysfs_mbox_attr);
4328
	if (error)
4329
		goto out_remove_ctlreg_attr;
4330

已提交
4331 4332
	return 0;
out_remove_ctlreg_attr:
4333
	sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
4334 4335 4336
out_remove_stat_attr:
	sysfs_remove_bin_file(&shost->shost_dev.kobj,
			&sysfs_drvr_stat_data_attr);
已提交
4337 4338 4339 4340
out:
	return error;
}

4341
/**
4342
 * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
4343 4344
 * @vport: address of lpfc vport structure.
 **/
已提交
4345
void
J
James Smart 已提交
4346
lpfc_free_sysfs_attr(struct lpfc_vport *vport)
已提交
4347
{
J
James Smart 已提交
4348
	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4349 4350
	sysfs_remove_bin_file(&shost->shost_dev.kobj,
		&sysfs_drvr_stat_data_attr);
4351 4352 4353
	/* Virtual ports do not need ctrl_reg and mbox */
	if (vport->port_type == LPFC_NPIV_PORT)
		return;
4354 4355
	sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
	sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
已提交
4356 4357 4358 4359 4360 4361 4362
}


/*
 * Dynamic FC Host Attributes Support
 */

4363
/**
4364
 * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
4365 4366
 * @shost: kernel scsi host pointer.
 **/
已提交
4367 4368 4369
static void
lpfc_get_host_port_id(struct Scsi_Host *shost)
{
J
James Smart 已提交
4370 4371
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;

已提交
4372
	/* note: fc_myDID already in cpu endianness */
J
James Smart 已提交
4373
	fc_host_port_id(shost) = vport->fc_myDID;
已提交
4374 4375
}

4376
/**
4377
 * lpfc_get_host_port_type - Set the value of the scsi host port type
4378 4379
 * @shost: kernel scsi host pointer.
 **/
已提交
4380 4381 4382
static void
lpfc_get_host_port_type(struct Scsi_Host *shost)
{
J
James Smart 已提交
4383 4384
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
4385 4386 4387

	spin_lock_irq(shost->host_lock);

4388 4389 4390
	if (vport->port_type == LPFC_NPIV_PORT) {
		fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
	} else if (lpfc_is_link_up(phba)) {
4391
		if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
J
James Smart 已提交
4392
			if (vport->fc_flag & FC_PUBLIC_LOOP)
已提交
4393 4394 4395 4396
				fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
			else
				fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
		} else {
J
James Smart 已提交
4397
			if (vport->fc_flag & FC_FABRIC)
已提交
4398 4399 4400 4401 4402 4403 4404 4405 4406 4407
				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);
}

4408
/**
4409
 * lpfc_get_host_port_state - Set the value of the scsi host port state
4410 4411
 * @shost: kernel scsi host pointer.
 **/
已提交
4412 4413 4414
static void
lpfc_get_host_port_state(struct Scsi_Host *shost)
{
J
James Smart 已提交
4415 4416
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
4417 4418 4419

	spin_lock_irq(shost->host_lock);

J
James Smart 已提交
4420
	if (vport->fc_flag & FC_OFFLINE_MODE)
已提交
4421 4422
		fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
	else {
J
James Smart 已提交
4423 4424
		switch (phba->link_state) {
		case LPFC_LINK_UNKNOWN:
已提交
4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445
		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);
}

4446
/**
4447
 * lpfc_get_host_speed - Set the value of the scsi host speed
4448 4449
 * @shost: kernel scsi host pointer.
 **/
已提交
4450 4451 4452
static void
lpfc_get_host_speed(struct Scsi_Host *shost)
{
J
James Smart 已提交
4453 4454
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
4455 4456 4457

	spin_lock_irq(shost->host_lock);

J
James Smart 已提交
4458
	if (lpfc_is_link_up(phba)) {
已提交
4459
		switch(phba->fc_linkspeed) {
4460 4461
		case LPFC_LINK_SPEED_1GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
已提交
4462
			break;
4463 4464
		case LPFC_LINK_SPEED_2GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
已提交
4465
			break;
4466 4467
		case LPFC_LINK_SPEED_4GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
已提交
4468
			break;
4469 4470
		case LPFC_LINK_SPEED_8GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
4471
			break;
4472 4473
		case LPFC_LINK_SPEED_10GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
4474
			break;
4475 4476 4477 4478 4479
		case LPFC_LINK_SPEED_16GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
			break;
		default:
			fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
已提交
4480 4481
			break;
		}
4482 4483
	} else
		fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
已提交
4484 4485 4486 4487

	spin_unlock_irq(shost->host_lock);
}

4488
/**
4489
 * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
4490 4491
 * @shost: kernel scsi host pointer.
 **/
已提交
4492 4493 4494
static void
lpfc_get_host_fabric_name (struct Scsi_Host *shost)
{
J
James Smart 已提交
4495 4496
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
4497
	u64 node_name;
已提交
4498 4499 4500

	spin_lock_irq(shost->host_lock);

4501 4502 4503 4504
	if ((vport->port_state > LPFC_FLOGI) &&
	    ((vport->fc_flag & FC_FABRIC) ||
	     ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
	      (vport->fc_flag & FC_PUBLIC_LOOP))))
A
Andrew Morton 已提交
4505
		node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
已提交
4506 4507
	else
		/* fabric is local port if there is no F/FL_Port */
4508
		node_name = 0;
已提交
4509 4510 4511

	spin_unlock_irq(shost->host_lock);

4512
	fc_host_fabric_name(shost) = node_name;
已提交
4513 4514
}

4515
/**
4516
 * lpfc_get_stats - Return statistical information about the adapter
4517 4518 4519 4520 4521 4522 4523 4524 4525 4526
 * @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
 **/
已提交
4527 4528 4529
static struct fc_host_statistics *
lpfc_get_stats(struct Scsi_Host *shost)
{
J
James Smart 已提交
4530 4531 4532
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	struct lpfc_sli   *psli = &phba->sli;
4533
	struct fc_host_statistics *hs = &phba->link_stats;
4534
	struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
已提交
4535 4536
	LPFC_MBOXQ_t *pmboxq;
	MAILBOX_t *pmb;
4537
	unsigned long seconds;
4538
	int rc = 0;
已提交
4539

4540 4541 4542 4543
	/*
	 * prevent udev from issuing mailbox commands until the port is
	 * configured.
	 */
J
James Smart 已提交
4544 4545
	if (phba->link_state < LPFC_LINK_DOWN ||
	    !phba->mbox_mem_pool ||
4546
	    (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
4547
		return NULL;
J
James Smart 已提交
4548 4549

	if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
4550 4551
		return NULL;

已提交
4552 4553 4554 4555 4556
	pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
	if (!pmboxq)
		return NULL;
	memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));

4557
	pmb = &pmboxq->u.mb;
已提交
4558 4559 4560
	pmb->mbxCommand = MBX_READ_STATUS;
	pmb->mbxOwner = OWN_HOST;
	pmboxq->context1 = NULL;
4561
	pmboxq->vport = vport;
已提交
4562

4563
	if (vport->fc_flag & FC_OFFLINE_MODE)
已提交
4564
		rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4565
	else
已提交
4566 4567 4568
		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);

	if (rc != MBX_SUCCESS) {
J
James Smart 已提交
4569
		if (rc != MBX_TIMEOUT)
4570
			mempool_free(pmboxq, phba->mbox_mem_pool);
已提交
4571 4572 4573
		return NULL;
	}

4574 4575
	memset(hs, 0, sizeof (struct fc_host_statistics));

已提交
4576
	hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
4577 4578 4579 4580 4581 4582 4583
	/*
	 * The MBX_READ_STATUS returns tx_k_bytes which has to
	 * converted to words
	 */
	hs->tx_words = (uint64_t)
			((uint64_t)pmb->un.varRdStatus.xmitByteCnt
			* (uint64_t)256);
已提交
4584
	hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
4585 4586 4587
	hs->rx_words = (uint64_t)
			((uint64_t)pmb->un.varRdStatus.rcvByteCnt
			 * (uint64_t)256);
已提交
4588

4589
	memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
已提交
4590 4591 4592
	pmb->mbxCommand = MBX_READ_LNK_STAT;
	pmb->mbxOwner = OWN_HOST;
	pmboxq->context1 = NULL;
4593
	pmboxq->vport = vport;
已提交
4594

4595
	if (vport->fc_flag & FC_OFFLINE_MODE)
已提交
4596
		rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4597
	else
已提交
4598 4599 4600
		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);

	if (rc != MBX_SUCCESS) {
J
James Smart 已提交
4601
		if (rc != MBX_TIMEOUT)
4602
			mempool_free(pmboxq, phba->mbox_mem_pool);
已提交
4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613
		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;

4614 4615 4616 4617 4618 4619 4620 4621
	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;

4622
	if (phba->hba_flag & HBA_FCOE_MODE) {
4623 4624 4625
		hs->lip_count = -1;
		hs->nos_count = (phba->link_events >> 1);
		hs->nos_count -= lso->link_events;
4626
	} else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
已提交
4627
		hs->lip_count = (phba->fc_eventTag >> 1);
4628
		hs->lip_count -= lso->link_events;
已提交
4629 4630 4631 4632
		hs->nos_count = -1;
	} else {
		hs->lip_count = -1;
		hs->nos_count = (phba->fc_eventTag >> 1);
4633
		hs->nos_count -= lso->link_events;
已提交
4634 4635 4636 4637
	}

	hs->dumped_frames = -1;

4638 4639 4640 4641 4642 4643
	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;
已提交
4644

4645 4646
	mempool_free(pmboxq, phba->mbox_mem_pool);

已提交
4647 4648 4649
	return hs;
}

4650
/**
4651
 * lpfc_reset_stats - Copy the adapter link stats information
4652 4653
 * @shost: kernel scsi host pointer.
 **/
4654 4655 4656
static void
lpfc_reset_stats(struct Scsi_Host *shost)
{
J
James Smart 已提交
4657 4658 4659 4660
	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;
4661 4662 4663 4664
	LPFC_MBOXQ_t *pmboxq;
	MAILBOX_t *pmb;
	int rc = 0;

J
James Smart 已提交
4665
	if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
4666 4667
		return;

4668 4669 4670 4671 4672
	pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
	if (!pmboxq)
		return;
	memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));

4673
	pmb = &pmboxq->u.mb;
4674 4675 4676 4677
	pmb->mbxCommand = MBX_READ_STATUS;
	pmb->mbxOwner = OWN_HOST;
	pmb->un.varWords[0] = 0x1; /* reset request */
	pmboxq->context1 = NULL;
4678
	pmboxq->vport = vport;
4679

J
James Smart 已提交
4680
	if ((vport->fc_flag & FC_OFFLINE_MODE) ||
4681
		(!(psli->sli_flag & LPFC_SLI_ACTIVE)))
4682 4683 4684 4685 4686
		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) {
J
James Smart 已提交
4687
		if (rc != MBX_TIMEOUT)
4688 4689 4690 4691 4692 4693 4694 4695
			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;
4696
	pmboxq->vport = vport;
4697

J
James Smart 已提交
4698
	if ((vport->fc_flag & FC_OFFLINE_MODE) ||
4699
	    (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
4700 4701 4702 4703 4704
		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) {
J
James Smart 已提交
4705
		if (rc != MBX_TIMEOUT)
4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716
			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;
4717
	if (phba->hba_flag & HBA_FCOE_MODE)
4718 4719 4720
		lso->link_events = (phba->link_events >> 1);
	else
		lso->link_events = (phba->fc_eventTag >> 1);
4721 4722 4723

	psli->stats_start = get_seconds();

4724 4725
	mempool_free(pmboxq, phba->mbox_mem_pool);

4726 4727
	return;
}
已提交
4728 4729 4730 4731 4732

/*
 * The LPFC driver treats linkdown handling as target loss events so there
 * are no sysfs handlers for link_down_tmo.
 */
4733

4734
/**
4735
 * lpfc_get_node_by_target - Return the nodelist for a target
4736 4737 4738 4739 4740 4741
 * @starget: kernel scsi target pointer.
 *
 * Returns:
 * address of the node list if found
 * NULL target not found
 **/
4742 4743
static struct lpfc_nodelist *
lpfc_get_node_by_target(struct scsi_target *starget)
已提交
4744
{
J
James Smart 已提交
4745 4746
	struct Scsi_Host  *shost = dev_to_shost(starget->dev.parent);
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4747
	struct lpfc_nodelist *ndlp;
已提交
4748 4749

	spin_lock_irq(shost->host_lock);
4750
	/* Search for this, mapped, target ID */
J
James Smart 已提交
4751
	list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
4752 4753
		if (NLP_CHK_NODE_ACT(ndlp) &&
		    ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
4754 4755 4756
		    starget->id == ndlp->nlp_sid) {
			spin_unlock_irq(shost->host_lock);
			return ndlp;
已提交
4757 4758 4759
		}
	}
	spin_unlock_irq(shost->host_lock);
4760 4761
	return NULL;
}
已提交
4762

4763
/**
4764
 * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
4765 4766
 * @starget: kernel scsi target pointer.
 **/
4767 4768 4769 4770 4771 4772
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;
已提交
4773 4774
}

4775
/**
4776
 * lpfc_get_starget_node_name - Set the target node name
4777 4778 4779 4780
 * @starget: kernel scsi target pointer.
 *
 * Description: Set the target node name to the ndlp node name wwn or zero.
 **/
已提交
4781 4782 4783
static void
lpfc_get_starget_node_name(struct scsi_target *starget)
{
4784
	struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
已提交
4785

4786 4787
	fc_starget_node_name(starget) =
		ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
已提交
4788 4789
}

4790
/**
4791
 * lpfc_get_starget_port_name - Set the target port name
4792 4793 4794 4795
 * @starget: kernel scsi target pointer.
 *
 * Description:  set the target port name to the ndlp port name wwn or zero.
 **/
已提交
4796 4797 4798
static void
lpfc_get_starget_port_name(struct scsi_target *starget)
{
4799
	struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
已提交
4800

4801 4802
	fc_starget_port_name(starget) =
		ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
已提交
4803 4804
}

4805
/**
4806
 * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
4807 4808 4809 4810 4811 4812 4813
 * @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.
 **/
已提交
4814 4815 4816 4817
static void
lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
{
	if (timeout)
4818
		rport->dev_loss_tmo = timeout;
已提交
4819
	else
4820
		rport->dev_loss_tmo = 1;
已提交
4821 4822
}

4823
/**
4824
 * lpfc_rport_show_function - Return rport target information
4825 4826 4827 4828 4829 4830 4831 4832 4833 4834
 *
 * 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.
 **/
已提交
4835 4836
#define lpfc_rport_show_function(field, format_string, sz, cast)	\
static ssize_t								\
4837 4838 4839
lpfc_show_rport_##field (struct device *dev,				\
			 struct device_attribute *attr,			\
			 char *buf)					\
已提交
4840
{									\
4841
	struct fc_rport *rport = transport_class_to_rport(dev);		\
已提交
4842 4843 4844 4845 4846 4847 4848 4849 4850
	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)

4851
/**
4852
 * lpfc_set_vport_symbolic_name - Set the vport's symbolic name
4853 4854 4855 4856 4857
 * @fc_vport: The fc_vport who's symbolic name has been changed.
 *
 * Description:
 * This function is called by the transport after the @fc_vport's symbolic name
 * has been changed. This function re-registers the symbolic name with the
L
Lucas De Marchi 已提交
4858
 * switch to propagate the change into the fabric if the vport is active.
4859 4860 4861 4862 4863 4864 4865 4866 4867
 **/
static void
lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport)
{
	struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;

	if (vport->port_state == LPFC_VPORT_READY)
		lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
}
已提交
4868

4869 4870 4871 4872 4873 4874
/**
 * lpfc_hba_log_verbose_init - Set hba's log verbose level
 * @phba: Pointer to lpfc_hba struct.
 *
 * This function is called by the lpfc_get_cfgparam() routine to set the
 * module lpfc_log_verbose into the @phba cfg_log_verbose for use with
4875
 * log message according to the module's lpfc_log_verbose parameter setting
4876 4877 4878 4879 4880 4881 4882 4883
 * before hba port or vport created.
 **/
static void
lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose)
{
	phba->cfg_log_verbose = verbose;
}

已提交
4884 4885 4886 4887 4888 4889 4890 4891
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,
4892
	.show_host_symbolic_name = 1,
已提交
4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918

	/* 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,
4919
	.reset_fc_host_stats = lpfc_reset_stats,
已提交
4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935

	.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,
4936 4937

	.issue_fc_host_lip = lpfc_issue_lip,
4938 4939
	.dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
	.terminate_rport_io = lpfc_terminate_rport_io,
4940 4941

	.dd_fcvport_size = sizeof(struct lpfc_vport *),
4942 4943 4944 4945

	.vport_disable = lpfc_vport_disable,

	.set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
4946 4947 4948

	.bsg_request = lpfc_bsg_request,
	.bsg_timeout = lpfc_bsg_timeout,
4949 4950
};

4951 4952 4953 4954 4955 4956 4957 4958
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,
4959
	.show_host_symbolic_name = 1,
4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007

	/* 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,
5008 5009

	.set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
5010 5011
};

5012
/**
5013
 * lpfc_get_cfgparam - Used during probe_one to init the adapter structure
5014 5015
 * @phba: lpfc_hba pointer.
 **/
已提交
5016 5017 5018
void
lpfc_get_cfgparam(struct lpfc_hba *phba)
{
5019 5020
	lpfc_cr_delay_init(phba, lpfc_cr_delay);
	lpfc_cr_count_init(phba, lpfc_cr_count);
5021
	lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
5022 5023
	lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
	lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
5024 5025 5026
	lpfc_ack0_init(phba, lpfc_ack0);
	lpfc_topology_init(phba, lpfc_topology);
	lpfc_link_speed_init(phba, lpfc_link_speed);
5027
	lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
5028
	lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
5029
	lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);
5030
	lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
5031
	lpfc_use_msi_init(phba, lpfc_use_msi);
5032 5033 5034
	lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
	lpfc_fcp_wq_count_init(phba, lpfc_fcp_wq_count);
	lpfc_fcp_eq_count_init(phba, lpfc_fcp_eq_count);
5035 5036
	lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
	lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
5037
	lpfc_enable_bg_init(phba, lpfc_enable_bg);
5038 5039 5040
	if (phba->sli_rev == LPFC_SLI_REV4)
		phba->cfg_poll = 0;
	else
5041
	phba->cfg_poll = lpfc_poll;
5042
	phba->cfg_soft_wwnn = 0L;
5043
	phba->cfg_soft_wwpn = 0L;
5044
	lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
5045
	lpfc_prot_sg_seg_cnt_init(phba, lpfc_prot_sg_seg_cnt);
5046
	lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
5047
	lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
J
James Smart 已提交
5048
	lpfc_aer_support_init(phba, lpfc_aer_support);
5049
	lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
5050
	lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
5051
	lpfc_iocb_cnt_init(phba, lpfc_iocb_cnt);
5052
	phba->cfg_enable_dss = 1;
5053 5054
	return;
}
5055

5056
/**
5057
 * lpfc_get_vport_cfgparam - Used during port create, init the vport structure
5058 5059
 * @vport: lpfc_vport pointer.
 **/
5060 5061 5062
void
lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
{
5063
	lpfc_log_verbose_init(vport, lpfc_log_verbose);
5064
	lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
5065
	lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth);
5066 5067 5068 5069 5070 5071
	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);
5072
	lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
5073 5074 5075 5076
	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);
J
James Smart 已提交
5077
	lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
已提交
5078 5079
	return;
}