lpfc_attr.c 178.1 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-2016 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>
26
#include <linux/module.h>
J
James Smart 已提交
27
#include <linux/aer.h>
28
#include <linux/gfp.h>
29
#include <linux/kernel.h>
已提交
30

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

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

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

56 57 58 59 60 61 62
/*
 * 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"

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

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

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
/**
 * 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");
}

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 157
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;

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

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;

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

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;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

已提交
359
	lpfc_decode_firmware_rev(phba, fwrev, 1);
360 361 362 363 364 365 366 367 368 369 370
	if_type = phba->sli4_hba.pc_sli4_params.if_type;
	sli_family = phba->sli4_hba.pc_sli4_params.sli_family;

	if (phba->sli_rev < LPFC_SLI_REV4)
		len = snprintf(buf, PAGE_SIZE, "%s, sli-%d\n",
			       fwrev, phba->sli_rev);
	else
		len = snprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n",
			       fwrev, phba->sli_rev, if_type, sli_family);

	return len;
已提交
371 372
}

373
/**
374
 * lpfc_hdw_show - Return the jedec information about the hba
375 376 377 378 379 380
 * @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.
 **/
已提交
381
static ssize_t
382
lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
已提交
383 384
{
	char hdw[9];
385
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
386 387
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
388
	lpfc_vpd_t *vp = &phba->vpd;
J
James Smart 已提交
389

已提交
390 391 392
	lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
	return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
}
393 394

/**
395
 * lpfc_option_rom_version_show - Return the adapter ROM FCode version
396 397 398 399 400 401
 * @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.
 **/
已提交
402
static ssize_t
403 404
lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
已提交
405
{
406
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
407 408
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
409 410 411 412
	char fwrev[FW_REV_STR_SIZE];

	if (phba->sli_rev < LPFC_SLI_REV4)
		return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
J
James Smart 已提交
413

414 415
	lpfc_decode_firmware_rev(phba, fwrev, 1);
	return snprintf(buf, PAGE_SIZE, "%s\n", fwrev);
已提交
416
}
417 418

/**
419
 * lpfc_state_show - Return the link state of the port
420 421 422 423 424 425 426 427 428
 * @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.
 **/
已提交
429
static ssize_t
430 431
lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
		     char *buf)
已提交
432
{
433
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
434 435 436 437 438 439
	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:
440
	case LPFC_WARM_START:
已提交
441 442 443
	case LPFC_INIT_START:
	case LPFC_INIT_MBX_CMDS:
	case LPFC_LINK_DOWN:
J
James Smart 已提交
444
	case LPFC_HBA_ERROR:
445 446 447 448 449 450
		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");
已提交
451 452 453 454
		break;
	case LPFC_LINK_UP:
	case LPFC_CLEAR_LA:
	case LPFC_HBA_READY:
455
		len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
J
James Smart 已提交
456 457 458 459

		switch (vport->port_state) {
		case LPFC_LOCAL_CFG_LINK:
			len += snprintf(buf + len, PAGE_SIZE-len,
460
					"Configuring Link\n");
J
James Smart 已提交
461
			break;
462
		case LPFC_FDISC:
J
James Smart 已提交
463 464 465 466 467 468 469 470 471 472 473 474 475
		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;

476 477 478 479 480
		case LPFC_VPORT_FAILED:
			len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n");
			break;

		case LPFC_VPORT_UNKNOWN:
J
James Smart 已提交
481 482 483 484
			len += snprintf(buf + len, PAGE_SIZE - len,
					"Unknown\n");
			break;
		}
485 486 487
		if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
			len += snprintf(buf + len, PAGE_SIZE-len,
					"   Menlo Maint Mode\n");
488
		else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
J
James Smart 已提交
489
			if (vport->fc_flag & FC_PUBLIC_LOOP)
已提交
490 491 492 493 494 495
				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 已提交
496
			if (vport->fc_flag & FC_FABRIC)
已提交
497 498 499 500 501 502 503
				len += snprintf(buf + len, PAGE_SIZE-len,
						"   Fabric\n");
			else
				len += snprintf(buf + len, PAGE_SIZE-len,
						"   Point-2-Point\n");
		}
	}
J
James Smart 已提交
504

已提交
505 506 507
	return len;
}

508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
/**
 * lpfc_sli4_protocol_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_sli4_protocol_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->sli_rev < LPFC_SLI_REV4)
		return snprintf(buf, PAGE_SIZE, "fc\n");

	if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL) {
		if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_GE)
			return snprintf(buf, PAGE_SIZE, "fcoe\n");
		if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC)
			return snprintf(buf, PAGE_SIZE, "fc\n");
	}
	return snprintf(buf, PAGE_SIZE, "unknown\n");
}

536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
/**
 * lpfc_oas_supported_show - Return whether or not Optimized Access Storage
 *			    (OAS) is supported.
 * @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_oas_supported_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->sli4_hba.pc_sli4_params.oas_supported);
}

557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
/**
 * 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))
581
		status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
582 583
	else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
			(phba->link_state >= LPFC_LINK_UP))
584
		status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT);
585 586 587 588 589 590 591

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

592
/**
593
 * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
594 595 596 597 598 599 600 601 602 603
 * @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.
 **/
已提交
604
static ssize_t
605 606
lpfc_num_discovered_ports_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
已提交
607
{
608
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
609 610 611 612
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;

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

615
/**
616
 * lpfc_issue_lip - Misnomer, name carried over from long ago
617 618 619 620 621 622 623 624 625 626 627 628
 * @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
 **/
629
static int
J
James Smart 已提交
630
lpfc_issue_lip(struct Scsi_Host *shost)
已提交
631
{
J
James Smart 已提交
632 633
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
634 635 636
	LPFC_MBOXQ_t *pmboxq;
	int mbxstatus = MBXERR_ERROR;

J
James Smart 已提交
637
	if ((vport->fc_flag & FC_OFFLINE_MODE) ||
638
	    (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
已提交
639 640 641 642 643 644 645 646
		return -EPERM;

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

	if (!pmboxq)
		return -ENOMEM;

	memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
647 648
	pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
	pmboxq->u.mb.mbxOwner = OWN_HOST;
649

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

652 653 654
	if ((mbxstatus == MBX_SUCCESS) &&
	    (pmboxq->u.mb.mbxStatus == 0 ||
	     pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) {
655 656 657 658 659
		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);
660 661 662 663 664
		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");
665 666
	}

667
	lpfc_set_loopback_flag(phba);
J
James Smart 已提交
668
	if (mbxstatus != MBX_TIMEOUT)
669
		mempool_free(pmboxq, phba->mbox_mem_pool);
已提交
670 671 672 673

	if (mbxstatus == MBXERR_ERROR)
		return -EIO;

674
	return 0;
已提交
675 676
}

677
/**
678
 * lpfc_do_offline - Issues a mailbox command to bring the link down
679 680 681 682 683 684 685
 * @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.
686
 * lpfc_workq_post_event() returns a non-zero return code if call fails.
687 688 689 690 691
 *
 * Returns:
 * -EIO error posting the event
 * zero for success
 **/
692
static int
693
lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
694 695
{
	struct completion online_compl;
696 697
	struct lpfc_sli_ring *pring;
	struct lpfc_sli *psli;
698
	int status = 0;
699 700
	int cnt = 0;
	int i;
701
	int rc;
702 703

	init_completion(&online_compl);
704
	rc = lpfc_workq_post_event(phba, &status, &online_compl,
705
			      LPFC_EVT_OFFLINE_PREP);
706 707 708
	if (rc == 0)
		return -ENOMEM;

709 710 711 712 713 714 715
	wait_for_completion(&online_compl);

	if (status != 0)
		return -EIO;

	psli = &phba->sli;

716 717 718
	/* Wait a little for things to settle down, but not
	 * long enough for dev loss timeout to expire.
	 */
719 720
	for (i = 0; i < psli->num_rings; i++) {
		pring = &psli->ring[i];
721
		while (!list_empty(&pring->txcmplq)) {
722
			msleep(10);
723
			if (cnt++ > 500) {  /* 5 secs */
724 725
				lpfc_printf_log(phba,
					KERN_WARNING, LOG_INIT,
726 727
					"0466 Outstanding IO when "
					"bringing Adapter offline\n");
728 729 730 731 732 733
				break;
			}
		}
	}

	init_completion(&online_compl);
734 735 736 737
	rc = lpfc_workq_post_event(phba, &status, &online_compl, type);
	if (rc == 0)
		return -ENOMEM;

738 739 740 741 742
	wait_for_completion(&online_compl);

	if (status != 0)
		return -EIO;

743 744 745
	return 0;
}

746
/**
747
 * lpfc_selective_reset - Offline then onlines the port
748 749 750 751 752 753 754 755
 * @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.
756
 * Do not make this function static.
757 758 759 760 761 762
 *
 * Returns:
 * lpfc_do_offline() return code if not zero
 * -EIO reset not configured or error posting the event
 * zero for success
 **/
763
int
764 765 766 767
lpfc_selective_reset(struct lpfc_hba *phba)
{
	struct completion online_compl;
	int status = 0;
768
	int rc;
769

770
	if (!phba->cfg_enable_hba_reset)
771
		return -EACCES;
772

773 774
	if (!(phba->pport->fc_flag & FC_OFFLINE_MODE)) {
		status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
775

776 777 778
		if (status != 0)
			return status;
	}
779

780
	init_completion(&online_compl);
781
	rc = lpfc_workq_post_event(phba, &status, &online_compl,
782
			      LPFC_EVT_ONLINE);
783 784 785
	if (rc == 0)
		return -ENOMEM;

786 787 788 789 790 791 792 793
	wait_for_completion(&online_compl);

	if (status != 0)
		return -EIO;

	return 0;
}

794
/**
795
 * lpfc_issue_reset - Selectively resets an adapter
796 797 798 799 800 801 802 803 804 805 806 807
 * @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
808
 * is returned which indicates success
809 810 811 812 813 814
 *
 * 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
**/
815
static ssize_t
816 817
lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
		 const char *buf, size_t count)
818
{
819
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
820 821
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
822 823
	int status = -EINVAL;

824 825 826
	if (!phba->cfg_enable_hba_reset)
		return -EACCES;

827
	if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
828
		status = phba->lpfc_selective_reset(phba);
829 830 831 832 833 834 835

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

836 837 838 839 840 841 842 843 844
/**
 * 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:
M
Masanari Iida 已提交
845
 * zero for success, -EPERM when port does not have privilege to perform the
846 847 848 849 850
 * reset, -EIO when port timeout from recovering from the reset.
 *
 * Note:
 * As the caller will interpret the return code by value, be careful in making
 * change or addition to return codes.
851
 **/
852
int
853 854
lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba)
{
855
	struct lpfc_register portstat_reg = {0};
856 857
	int i;

858
	msleep(100);
859 860 861
	lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
		   &portstat_reg.word0);

M
Masanari Iida 已提交
862
	/* verify if privileged for the request operation */
863 864 865 866
	if (!bf_get(lpfc_sliport_status_rn, &portstat_reg) &&
	    !bf_get(lpfc_sliport_status_err, &portstat_reg))
		return -EPERM;

867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
	/* 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;
}

887
/**
888
 * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
889 890 891
 * @phba: lpfc_hba pointer.
 *
 * Description:
892 893
 * Request SLI4 interface type-2 device to perform a physical register set
 * access.
894 895 896 897 898
 *
 * Returns:
 * zero for success
 **/
static ssize_t
899
lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
900 901
{
	struct completion online_compl;
902
	struct pci_dev *pdev = phba->pcidev;
903 904
	uint32_t before_fc_flag;
	uint32_t sriov_nr_virtfn;
905
	uint32_t reg_val;
906 907
	int status = 0, rc = 0;
	int job_posted = 1, sriov_err;
908 909

	if (!phba->cfg_enable_hba_reset)
910
		return -EACCES;
911

912 913 914 915 916
	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;

917 918 919 920
	/* Keep state if we need to restore back */
	before_fc_flag = phba->pport->fc_flag;
	sriov_nr_virtfn = phba->cfg_sriov_nr_virtfn;

921 922 923 924 925
	/* Disable SR-IOV virtual functions if enabled */
	if (phba->cfg_sriov_nr_virtfn) {
		pci_disable_sriov(pdev);
		phba->cfg_sriov_nr_virtfn = 0;
	}
926

J
James Smart 已提交
927 928 929
	if (opcode == LPFC_FW_DUMP)
		phba->hba_flag |= HBA_FW_DUMP_OP;

930 931
	status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);

J
James Smart 已提交
932 933
	if (status != 0) {
		phba->hba_flag &= ~HBA_FW_DUMP_OP;
934
		return status;
J
James Smart 已提交
935
	}
936 937 938 939 940 941

	/* 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);
942 943 944 945 946 947 948 949

	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;

950 951 952 953 954 955
	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 */
956 957
	rc = lpfc_sli4_pdev_status_reg_wait(phba);

958
	if (rc == -EPERM) {
M
Masanari Iida 已提交
959
		/* no privilege for reset */
960
		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
M
Masanari Iida 已提交
961
				"3150 No privilege to perform the requested "
962
				"access: x%x\n", reg_val);
963 964
	} else if (rc == -EIO) {
		/* reset failed, there is nothing more we can do */
965 966 967
		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
				"3153 Fail to perform the requested "
				"access: x%x\n", reg_val);
968
		return rc;
969 970 971 972 973
	}

	/* keep the original port state */
	if (before_fc_flag & FC_OFFLINE_MODE)
		goto out;
974 975

	init_completion(&online_compl);
976 977 978 979
	job_posted = lpfc_workq_post_event(phba, &status, &online_compl,
					   LPFC_EVT_ONLINE);
	if (!job_posted)
		goto out;
980 981 982

	wait_for_completion(&online_compl);

983 984 985 986 987 988 989 990
out:
	/* in any case, restore the virtual functions enabled as before */
	if (sriov_nr_virtfn) {
		sriov_err =
			lpfc_sli_probe_sriov_nr_virtfn(phba, sriov_nr_virtfn);
		if (!sriov_err)
			phba->cfg_sriov_nr_virtfn = sriov_nr_virtfn;
	}
991

992 993 994 995 996 997 998 999
	/* return proper error code */
	if (!rc) {
		if (!job_posted)
			rc = -ENOMEM;
		else if (status)
			rc = -EIO;
	}
	return rc;
1000 1001
}

1002
/**
1003
 * lpfc_nport_evt_cnt_show - Return the number of nport events
1004 1005 1006 1007 1008 1009
 * @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.
 **/
已提交
1010
static ssize_t
1011 1012
lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
			char *buf)
已提交
1013
{
1014
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1015 1016 1017
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;

已提交
1018 1019 1020
	return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
}

1021
/**
1022
 * lpfc_board_mode_show - Return the state of the board
1023 1024 1025 1026 1027 1028
 * @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.
 **/
1029
static ssize_t
1030 1031
lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
		     char *buf)
1032
{
1033
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1034 1035
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
1036 1037
	char  * state;

J
James Smart 已提交
1038
	if (phba->link_state == LPFC_HBA_ERROR)
1039
		state = "error";
J
James Smart 已提交
1040
	else if (phba->link_state == LPFC_WARM_START)
1041
		state = "warm start";
J
James Smart 已提交
1042
	else if (phba->link_state == LPFC_INIT_START)
1043 1044 1045 1046 1047 1048 1049
		state = "offline";
	else
		state = "online";

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

1050
/**
1051
 * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
 * @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
 **/
1063
static ssize_t
1064 1065
lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
		      const char *buf, size_t count)
1066
{
1067
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1068 1069
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
1070
	struct completion online_compl;
1071 1072
	char *board_mode_str = NULL;
	int status = 0;
1073
	int rc;
1074

1075 1076 1077 1078
	if (!phba->cfg_enable_hba_reset) {
		status = -EACCES;
		goto board_mode_out;
	}
1079 1080

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

1083 1084
	init_completion(&online_compl);

1085
	if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
1086
		rc = lpfc_workq_post_event(phba, &status, &online_compl,
1087
				      LPFC_EVT_ONLINE);
1088 1089 1090 1091
		if (rc == 0) {
			status = -ENOMEM;
			goto board_mode_out;
		}
1092 1093 1094
		wait_for_completion(&online_compl);
	} else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
		status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1095
	else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
1096
		if (phba->sli_rev == LPFC_SLI_REV4)
1097
			status = -EINVAL;
1098 1099
		else
			status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
1100
	else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
1101
		if (phba->sli_rev == LPFC_SLI_REV4)
1102
			status = -EINVAL;
1103 1104
		else
			status = lpfc_do_offline(phba, LPFC_EVT_KILL);
1105
	else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
1106 1107 1108 1109 1110
		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);
1111
	else
1112
		status = -EINVAL;
1113

1114
board_mode_out:
1115 1116
	if (!status)
		return strlen(buf);
1117 1118 1119 1120 1121 1122 1123 1124
	else {
		board_mode_str = strchr(buf, '\n');
		if (board_mode_str)
			*board_mode_str = '\0';
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
				 "3097 Failed \"%s\", status(%d), "
				 "fc_flag(x%x)\n",
				 buf, status, phba->pport->fc_flag);
1125
		return status;
1126
	}
1127 1128
}

1129
/**
1130
 * lpfc_get_hba_info - Return various bits of informaton about the adapter
1131
 * @phba: pointer to the adapter structure.
1132 1133 1134 1135 1136 1137
 * @mxri: max xri count.
 * @axri: available xri count.
 * @mrpi: max rpi count.
 * @arpi: available rpi count.
 * @mvpi: max vpi count.
 * @avpi: available vpi count.
1138 1139 1140 1141 1142 1143 1144 1145 1146
 *
 * 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 已提交
1147
static int
J
James Smart 已提交
1148 1149 1150 1151
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)
1152
{
1153
	struct lpfc_mbx_read_config *rd_config;
1154 1155 1156
	LPFC_MBOXQ_t *pmboxq;
	MAILBOX_t *pmb;
	int rc = 0;
1157
	uint32_t max_vpi;
1158 1159 1160 1161 1162 1163 1164

	/*
	 * prevent udev from issuing mailbox commands until the port is
	 * configured.
	 */
	if (phba->link_state < LPFC_LINK_DOWN ||
	    !phba->mbox_mem_pool ||
1165
	    (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
		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));

1176
	pmb = &pmboxq->u.mb;
1177 1178 1179 1180
	pmb->mbxCommand = MBX_READ_CONFIG;
	pmb->mbxOwner = OWN_HOST;
	pmboxq->context1 = NULL;

1181
	if (phba->pport->fc_flag & FC_OFFLINE_MODE)
1182 1183 1184 1185 1186
		rc = MBX_NOT_FINISHED;
	else
		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);

	if (rc != MBX_SUCCESS) {
J
James Smart 已提交
1187
		if (rc != MBX_TIMEOUT)
1188 1189 1190 1191
			mempool_free(pmboxq, phba->mbox_mem_pool);
		return 0;
	}

1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
	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;
1204 1205 1206 1207 1208 1209 1210

		/* 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;

1211
		if (mvpi)
1212
			*mvpi = max_vpi;
1213
		if (avpi)
1214
			*avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used;
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
	} 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;
	}
1229 1230 1231 1232 1233

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

1234
/**
1235
 * lpfc_max_rpi_show - Return maximum rpi
1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247
 * @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.
 **/
1248
static ssize_t
1249 1250
lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
		  char *buf)
1251
{
1252
	struct Scsi_Host  *shost = class_to_shost(dev);
1253 1254 1255 1256
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	uint32_t cnt;

J
James Smart 已提交
1257
	if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
1258 1259 1260 1261
		return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
	return snprintf(buf, PAGE_SIZE, "Unknown\n");
}

1262
/**
1263
 * lpfc_used_rpi_show - Return maximum rpi minus available rpi
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275
 * @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.
 **/
1276
static ssize_t
1277 1278
lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
		   char *buf)
1279
{
1280
	struct Scsi_Host  *shost = class_to_shost(dev);
1281 1282 1283 1284
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	uint32_t cnt, acnt;

J
James Smart 已提交
1285
	if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
1286 1287 1288 1289
		return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
	return snprintf(buf, PAGE_SIZE, "Unknown\n");
}

1290
/**
1291
 * lpfc_max_xri_show - Return maximum xri
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
 * @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.
 **/
1304
static ssize_t
1305 1306
lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
		  char *buf)
1307
{
1308
	struct Scsi_Host  *shost = class_to_shost(dev);
1309 1310 1311 1312
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	uint32_t cnt;

J
James Smart 已提交
1313
	if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
1314 1315 1316 1317
		return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
	return snprintf(buf, PAGE_SIZE, "Unknown\n");
}

1318
/**
1319
 * lpfc_used_xri_show - Return maximum xpi minus the available xpi
1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331
 * @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.
 **/
1332
static ssize_t
1333 1334
lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
		   char *buf)
1335
{
1336
	struct Scsi_Host  *shost = class_to_shost(dev);
1337 1338 1339 1340
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	uint32_t cnt, acnt;

J
James Smart 已提交
1341 1342 1343 1344 1345
	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");
}

1346
/**
1347
 * lpfc_max_vpi_show - Return maximum vpi
1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
 * @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 已提交
1360
static ssize_t
1361 1362
lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
		  char *buf)
J
James Smart 已提交
1363
{
1364
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1365 1366 1367 1368 1369 1370 1371 1372 1373
	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");
}

1374
/**
1375
 * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
 * @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 已提交
1388
static ssize_t
1389 1390
lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
		   char *buf)
J
James Smart 已提交
1391
{
1392
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1393 1394 1395 1396 1397
	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))
1398 1399 1400 1401
		return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
	return snprintf(buf, PAGE_SIZE, "Unknown\n");
}

1402
/**
1403
 * lpfc_npiv_info_show - Return text about NPIV support for the adapter
1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
 * @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.
 **/
1415
static ssize_t
1416 1417
lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
1418
{
1419
	struct Scsi_Host  *shost = class_to_shost(dev);
1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
	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);
}

1430
/**
1431
 * lpfc_poll_show - Return text about poll support for the adapter
1432 1433 1434 1435 1436 1437 1438 1439 1440
 * @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.
 **/
1441
static ssize_t
1442 1443
lpfc_poll_show(struct device *dev, struct device_attribute *attr,
	       char *buf)
1444
{
1445
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1446 1447
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
1448 1449 1450 1451

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

1452
/**
1453
 * lpfc_poll_store - Set the value of cfg_poll for the adapter
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
 * @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
 **/
1466
static ssize_t
1467 1468
lpfc_poll_store(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
1469
{
1470
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
1471 1472
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
	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;

1486 1487 1488
	if (phba->sli_rev == LPFC_SLI_REV4)
		val = 0;

1489 1490 1491 1492
	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
		"3051 lpfc_poll changed from %d to %d\n",
		phba->cfg_poll, val);

J
James Smart 已提交
1493
	spin_lock_irq(&phba->hbalock);
1494 1495 1496 1497 1498 1499

	old_val = phba->cfg_poll;

	if (val & ENABLE_FCP_RING_POLLING) {
		if ((val & DISABLE_FCP_RING_INT) &&
		    !(old_val & DISABLE_FCP_RING_INT)) {
1500 1501 1502 1503
			if (lpfc_readl(phba->HCregaddr, &creg_val)) {
				spin_unlock_irq(&phba->hbalock);
				return -EINVAL;
			}
1504 1505 1506 1507 1508 1509 1510
			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 已提交
1511
		spin_unlock_irq(&phba->hbalock);
1512 1513 1514 1515 1516 1517
		return -EINVAL;
	}

	if (!(val & DISABLE_FCP_RING_INT) &&
	    (old_val & DISABLE_FCP_RING_INT))
	{
J
James Smart 已提交
1518
		spin_unlock_irq(&phba->hbalock);
1519
		del_timer(&phba->fcp_poll_timer);
J
James Smart 已提交
1520
		spin_lock_irq(&phba->hbalock);
1521 1522 1523 1524
		if (lpfc_readl(phba->HCregaddr, &creg_val)) {
			spin_unlock_irq(&phba->hbalock);
			return -EINVAL;
		}
1525 1526 1527 1528 1529 1530 1531
		creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
		writel(creg_val, phba->HCregaddr);
		readl(phba->HCregaddr); /* flush */
	}

	phba->cfg_poll = val;

J
James Smart 已提交
1532
	spin_unlock_irq(&phba->hbalock);
1533 1534 1535

	return strlen(buf);
}
已提交
1536

1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
/**
 * 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);
}

1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
/**
 * 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 ");
}

1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
/**
 * 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;
1617
	uint16_t max_nr_virtfn;
1618

1619 1620
	max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
	return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
1621 1622
}

1623
/**
1624
 * lpfc_param_show - Return a cfg attribute value in decimal
1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636
 *
 * 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.
 **/
已提交
1637 1638
#define lpfc_param_show(attr)	\
static ssize_t \
1639 1640
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
		   char *buf) \
已提交
1641
{ \
1642
	struct Scsi_Host  *shost = class_to_shost(dev);\
J
James Smart 已提交
1643 1644
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
	struct lpfc_hba   *phba = vport->phba;\
1645 1646 1647 1648
	return snprintf(buf, PAGE_SIZE, "%d\n",\
			phba->cfg_##attr);\
}

1649
/**
1650
 * lpfc_param_hex_show - Return a cfg attribute value in hex
1651 1652 1653 1654 1655 1656 1657 1658
 *
 * 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.
1659
 * @buf: on return contains the attribute value in hexadecimal.
1660 1661 1662
 *
 * Returns: size of formatted string.
 **/
1663 1664
#define lpfc_param_hex_show(attr)	\
static ssize_t \
1665 1666
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
		   char *buf) \
1667
{ \
1668
	struct Scsi_Host  *shost = class_to_shost(dev);\
J
James Smart 已提交
1669 1670
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
	struct lpfc_hba   *phba = vport->phba;\
1671
	uint val = 0;\
1672 1673 1674 1675 1676
	val = phba->cfg_##attr;\
	return snprintf(buf, PAGE_SIZE, "%#x\n",\
			phba->cfg_##attr);\
}

1677
/**
1678
 * lpfc_param_init - Initializes a cfg attribute
1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 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_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
 **/
1696 1697
#define lpfc_param_init(attr, default, minval, maxval)	\
static int \
1698
lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
1699 1700 1701 1702
{ \
	if (val >= minval && val <= maxval) {\
		phba->cfg_##attr = val;\
		return 0;\
已提交
1703
	}\
1704
	lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1705 1706
			"0449 lpfc_"#attr" attribute cannot be set to %d, "\
			"allowed range is ["#minval", "#maxval"]\n", val); \
1707 1708
	phba->cfg_##attr = default;\
	return -EINVAL;\
已提交
1709 1710
}

1711
/**
1712
 * lpfc_param_set - Set a cfg attribute value
1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730
 *
 * 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
 **/
1731 1732
#define lpfc_param_set(attr, default, minval, maxval)	\
static int \
1733
lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
1734 1735
{ \
	if (val >= minval && val <= maxval) {\
1736 1737 1738
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
			"3052 lpfc_" #attr " changed from %d to %d\n", \
			phba->cfg_##attr, val); \
1739 1740 1741 1742
		phba->cfg_##attr = val;\
		return 0;\
	}\
	lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1743 1744
			"0450 lpfc_"#attr" attribute cannot be set to %d, "\
			"allowed range is ["#minval", "#maxval"]\n", val); \
1745 1746 1747
	return -EINVAL;\
}

1748
/**
1749
 * lpfc_param_store - Set a vport attribute value
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
 *
 * 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.
 **/
1769
#define lpfc_param_store(attr)	\
已提交
1770
static ssize_t \
1771 1772
lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
		    const char *buf, size_t count) \
已提交
1773
{ \
1774
	struct Scsi_Host  *shost = class_to_shost(dev);\
J
James Smart 已提交
1775 1776
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
	struct lpfc_hba   *phba = vport->phba;\
1777
	uint val = 0;\
1778 1779 1780 1781
	if (!isdigit(buf[0]))\
		return -EINVAL;\
	if (sscanf(buf, "%i", &val) != 1)\
		return -EINVAL;\
1782
	if (lpfc_##attr##_set(phba, val) == 0) \
1783
		return strlen(buf);\
1784 1785
	else \
		return -EINVAL;\
已提交
1786 1787
}

1788
/**
1789
 * lpfc_vport_param_show - Return decimal formatted cfg attribute value
1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
 *
 * 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.
 **/
1802 1803
#define lpfc_vport_param_show(attr)	\
static ssize_t \
1804 1805
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
		   char *buf) \
1806
{ \
1807
	struct Scsi_Host  *shost = class_to_shost(dev);\
1808 1809 1810 1811
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
	return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
}

1812
/**
1813
 * lpfc_vport_param_hex_show - Return hex formatted attribute value
1814 1815 1816 1817 1818 1819
 *
 * Description:
 * Macro that given an attr e.g.
 * hba_queue_depth expands into a function with the name
 * lpfc_hba_queue_depth_show
 *
1820
 * lpfc_##attr##_show: prints the attribute value in hexadecimal.
1821 1822
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
1823
 * @buf: on return contains the attribute value in hexadecimal.
1824 1825 1826
 *
 * Returns: length of formatted string.
 **/
1827 1828
#define lpfc_vport_param_hex_show(attr)	\
static ssize_t \
1829 1830
lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
		   char *buf) \
1831
{ \
1832
	struct Scsi_Host  *shost = class_to_shost(dev);\
1833 1834 1835 1836
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
	return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
}

1837
/**
1838
 * lpfc_vport_param_init - Initialize a vport cfg attribute
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
 *
 * 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
 **/
1855 1856
#define lpfc_vport_param_init(attr, default, minval, maxval)	\
static int \
1857
lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
1858 1859 1860 1861 1862
{ \
	if (val >= minval && val <= maxval) {\
		vport->cfg_##attr = val;\
		return 0;\
	}\
1863
	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1864
			 "0423 lpfc_"#attr" attribute cannot be set to %d, "\
1865
			 "allowed range is ["#minval", "#maxval"]\n", val); \
1866 1867 1868 1869
	vport->cfg_##attr = default;\
	return -EINVAL;\
}

1870
/**
1871
 * lpfc_vport_param_set - Set a vport cfg attribute
1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
 *
 * 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
 **/
1887 1888
#define lpfc_vport_param_set(attr, default, minval, maxval)	\
static int \
1889
lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
1890 1891
{ \
	if (val >= minval && val <= maxval) {\
1892
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1893 1894 1895 1896
			"3053 lpfc_" #attr \
			" changed from %d (x%x) to %d (x%x)\n", \
			vport->cfg_##attr, vport->cfg_##attr, \
			val, val); \
1897 1898 1899
		vport->cfg_##attr = val;\
		return 0;\
	}\
1900
	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1901
			 "0424 lpfc_"#attr" attribute cannot be set to %d, "\
1902
			 "allowed range is ["#minval", "#maxval"]\n", val); \
1903 1904 1905
	return -EINVAL;\
}

1906
/**
1907
 * lpfc_vport_param_store - Set a vport attribute
1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922
 *
 * 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.
 **/
1923 1924
#define lpfc_vport_param_store(attr)	\
static ssize_t \
1925 1926
lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
		    const char *buf, size_t count) \
1927
{ \
1928
	struct Scsi_Host  *shost = class_to_shost(dev);\
1929
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1930
	uint val = 0;\
1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
	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;\
}


1942
#define LPFC_ATTR(name, defval, minval, maxval, desc) \
1943
static uint lpfc_##name = defval;\
1944
module_param(lpfc_##name, uint, S_IRUGO);\
已提交
1945
MODULE_PARM_DESC(lpfc_##name, desc);\
1946
lpfc_param_init(name, defval, minval, maxval)
已提交
1947 1948

#define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
1949
static uint lpfc_##name = defval;\
1950
module_param(lpfc_##name, uint, S_IRUGO);\
已提交
1951 1952
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_param_show(name)\
1953
lpfc_param_init(name, defval, minval, maxval)\
1954
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
已提交
1955 1956

#define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
1957
static uint lpfc_##name = defval;\
1958
module_param(lpfc_##name, uint, S_IRUGO);\
已提交
1959 1960
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_param_show(name)\
1961 1962 1963
lpfc_param_init(name, defval, minval, maxval)\
lpfc_param_set(name, defval, minval, maxval)\
lpfc_param_store(name)\
1964 1965
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
		   lpfc_##name##_show, lpfc_##name##_store)
已提交
1966

1967
#define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1968
static uint lpfc_##name = defval;\
1969
module_param(lpfc_##name, uint, S_IRUGO);\
1970 1971 1972
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_param_hex_show(name)\
lpfc_param_init(name, defval, minval, maxval)\
1973
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1974 1975

#define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1976
static uint lpfc_##name = defval;\
1977
module_param(lpfc_##name, uint, S_IRUGO);\
1978 1979 1980 1981 1982
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)\
1983 1984
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
		   lpfc_##name##_show, lpfc_##name##_store)
1985

1986
#define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
1987
static uint lpfc_##name = defval;\
1988
module_param(lpfc_##name, uint, S_IRUGO);\
1989 1990 1991 1992
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_vport_param_init(name, defval, minval, maxval)

#define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
1993
static uint lpfc_##name = defval;\
1994
module_param(lpfc_##name, uint, S_IRUGO);\
1995 1996 1997
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_vport_param_show(name)\
lpfc_vport_param_init(name, defval, minval, maxval)\
1998
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1999

2000 2001 2002 2003 2004 2005 2006 2007
#define LPFC_VPORT_ULL_ATTR_R(name, defval, minval, maxval, desc) \
static uint64_t lpfc_##name = defval;\
module_param(lpfc_##name, ullong, S_IRUGO);\
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_vport_param_show(name)\
lpfc_vport_param_init(name, defval, minval, maxval)\
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)

2008
#define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
2009
static uint lpfc_##name = defval;\
2010
module_param(lpfc_##name, uint, S_IRUGO);\
2011 2012 2013 2014 2015
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)\
2016 2017
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
		   lpfc_##name##_show, lpfc_##name##_store)
2018 2019

#define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
2020
static uint lpfc_##name = defval;\
2021
module_param(lpfc_##name, uint, S_IRUGO);\
2022 2023 2024
MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_vport_param_hex_show(name)\
lpfc_vport_param_init(name, defval, minval, maxval)\
2025
static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
2026 2027

#define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
2028
static uint lpfc_##name = defval;\
2029
module_param(lpfc_##name, uint, S_IRUGO);\
2030 2031 2032 2033 2034
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)\
2035 2036 2037
static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
		   lpfc_##name##_show, lpfc_##name##_store)

2038 2039 2040 2041
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);
2042 2043 2044 2045 2046 2047 2048 2049
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);
2050 2051
static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
		lpfc_link_state_store);
2052 2053 2054 2055
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);
2056
static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
2057 2058
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);
2059
static DEVICE_ATTR(lpfc_enable_fip, S_IRUGO, lpfc_enable_fip_show, NULL);
2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070
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);
2071 2072
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);
2073
static DEVICE_ATTR(lpfc_dss, S_IRUGO, lpfc_dss_show, NULL);
2074 2075
static DEVICE_ATTR(lpfc_sriov_hw_max_virtfn, S_IRUGO,
		   lpfc_sriov_hw_max_virtfn_show, NULL);
2076
static DEVICE_ATTR(protocol, S_IRUGO, lpfc_sli4_protocol_show, NULL);
2077 2078
static DEVICE_ATTR(lpfc_xlane_supported, S_IRUGO, lpfc_oas_supported_show,
		   NULL);
2079

2080
static char *lpfc_soft_wwn_key = "C99G71SL8032A";
2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
#define WWN_SZ 8
/**
 * lpfc_wwn_set - Convert string to the 8 byte WWN value.
 * @buf: WWN string.
 * @cnt: Length of string.
 * @wwn: Array to receive converted wwn value.
 *
 * Returns:
 * -EINVAL if the buffer does not contain a valid wwn
 * 0 success
 **/
static size_t
lpfc_wwn_set(const char *buf, size_t cnt, char wwn[])
{
	unsigned int i, j;

	/* Count may include a LF at end of string */
	if (buf[cnt-1] == '\n')
		cnt--;
2100

2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123
	if ((cnt < 16) || (cnt > 18) || ((cnt == 17) && (*buf++ != 'x')) ||
	    ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
		return -EINVAL;

	memset(wwn, 0, WWN_SZ);

	/* Validate and store the new name */
	for (i = 0, j = 0; i < 16; i++) {
		if ((*buf >= 'a') && (*buf <= 'f'))
			j = ((j << 4) | ((*buf++ - 'a') + 10));
		else if ((*buf >= 'A') && (*buf <= 'F'))
			j = ((j << 4) | ((*buf++ - 'A') + 10));
		else if ((*buf >= '0') && (*buf <= '9'))
			j = ((j << 4) | (*buf++ - '0'));
		else
			return -EINVAL;
		if (i % 2) {
			wwn[i/2] = j & 0xff;
			j = 0;
		}
	}
	return 0;
}
2124
/**
2125
 * lpfc_soft_wwn_enable_store - Allows setting of the wwn if the key is valid
2126 2127 2128 2129 2130 2131 2132 2133 2134
 * @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
 **/
2135
static ssize_t
2136 2137
lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
2138
{
2139
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
2140 2141
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160
	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--;

2161 2162
	if ((cnt != strlen(lpfc_soft_wwn_key)) ||
	    (strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0))
2163 2164
		return -EINVAL;

2165
	phba->soft_wwn_enable = 1;
2166 2167
	return count;
}
2168 2169
static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
		   lpfc_soft_wwn_enable_store);
2170

2171
/**
2172
 * lpfc_soft_wwpn_show - Return the cfg soft ww port name of the adapter
2173 2174
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
2175
 * @buf: on return contains the wwpn in hexadecimal.
2176 2177 2178
 *
 * Returns: size of formatted string.
 **/
2179
static ssize_t
2180 2181
lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
2182
{
2183
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
2184 2185 2186
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;

2187 2188
	return snprintf(buf, PAGE_SIZE, "0x%llx\n",
			(unsigned long long)phba->cfg_soft_wwpn);
2189 2190
}

2191
/**
2192
 * lpfc_soft_wwpn_store - Set the ww port name of the adapter
2193 2194
 * @dev class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
2195
 * @buf: contains the wwpn in hexadecimal.
2196 2197 2198 2199 2200 2201 2202 2203
 * @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
 **/
2204
static ssize_t
2205 2206
lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr,
		     const char *buf, size_t count)
2207
{
2208
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
2209 2210
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
2211
	struct completion online_compl;
2212 2213 2214
	int stat1 = 0, stat2 = 0;
	unsigned int cnt = count;
	u8 wwpn[WWN_SZ];
2215
	int rc;
2216

2217 2218
	if (!phba->cfg_enable_hba_reset)
		return -EACCES;
2219 2220 2221
	spin_lock_irq(&phba->hbalock);
	if (phba->over_temp_state == HBA_OVER_TEMP) {
		spin_unlock_irq(&phba->hbalock);
2222
		return -EACCES;
2223 2224
	}
	spin_unlock_irq(&phba->hbalock);
2225 2226 2227 2228
	/* count may include a LF at end of string */
	if (buf[cnt-1] == '\n')
		cnt--;

2229
	if (!phba->soft_wwn_enable)
2230 2231
		return -EINVAL;

2232
	/* lock setting wwpn, wwnn down */
2233
	phba->soft_wwn_enable = 0;
2234

2235 2236 2237 2238 2239
	rc = lpfc_wwn_set(buf, cnt, wwpn);
	if (!rc) {
		/* not able to set wwpn, unlock it */
		phba->soft_wwn_enable = 1;
		return rc;
2240
	}
2241

2242
	phba->cfg_soft_wwpn = wwn_to_u64(wwpn);
J
James Smart 已提交
2243
	fc_host_port_name(shost) = phba->cfg_soft_wwpn;
2244
	if (phba->cfg_soft_wwnn)
J
James Smart 已提交
2245
		fc_host_node_name(shost) = phba->cfg_soft_wwnn;
2246 2247 2248 2249

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

2250
	stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
2251 2252
	if (stat1)
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2253 2254
				"0463 lpfc_soft_wwpn attribute set failed to "
				"reinit adapter - %d\n", stat1);
2255
	init_completion(&online_compl);
2256 2257 2258 2259 2260
	rc = lpfc_workq_post_event(phba, &stat2, &online_compl,
				   LPFC_EVT_ONLINE);
	if (rc == 0)
		return -ENOMEM;

2261 2262 2263
	wait_for_completion(&online_compl);
	if (stat2)
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2264 2265
				"0464 lpfc_soft_wwpn attribute set failed to "
				"reinit adapter - %d\n", stat2);
2266 2267
	return (stat1 || stat2) ? -EIO : count;
}
2268
static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,
2269
		   lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
2270

2271
/**
2272
 * lpfc_soft_wwnn_show - Return the cfg soft ww node name for the adapter
2273 2274
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
2275
 * @buf: on return contains the wwnn in hexadecimal.
2276 2277 2278
 *
 * Returns: size of formatted string.
 **/
2279
static ssize_t
2280 2281
lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
2282
{
2283
	struct Scsi_Host *shost = class_to_shost(dev);
2284
	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2285 2286 2287 2288
	return snprintf(buf, PAGE_SIZE, "0x%llx\n",
			(unsigned long long)phba->cfg_soft_wwnn);
}

2289
/**
2290
 * lpfc_soft_wwnn_store - sets the ww node name of the adapter
2291
 * @cdev: class device that is converted into a Scsi_host.
2292
 * @buf: contains the ww node name in hexadecimal.
2293 2294 2295 2296 2297 2298
 * @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
 **/
2299
static ssize_t
2300 2301
lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr,
		     const char *buf, size_t count)
2302
{
2303
	struct Scsi_Host *shost = class_to_shost(dev);
2304
	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2305 2306 2307
	unsigned int cnt = count;
	u8 wwnn[WWN_SZ];
	int rc;
2308 2309 2310 2311 2312

	/* count may include a LF at end of string */
	if (buf[cnt-1] == '\n')
		cnt--;

2313
	if (!phba->soft_wwn_enable)
2314 2315
		return -EINVAL;

2316 2317 2318 2319 2320 2321
	rc = lpfc_wwn_set(buf, cnt, wwnn);
	if (!rc) {
		/* Allow wwnn to be set many times, as long as the enable
		 * is set. However, once the wwpn is set, everything locks.
		 */
		return rc;
2322
	}
2323

2324 2325 2326 2327 2328 2329 2330 2331
	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;
}
2332
static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,
2333
		   lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
2334

2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378
/**
 * lpfc_oas_tgt_show - Return wwpn of target whose luns maybe enabled for
 *		      Optimized Access Storage (OAS) operations.
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 *
 * Returns:
 * value of count
 **/
static ssize_t
lpfc_oas_tgt_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, "0x%llx\n",
			wwn_to_u64(phba->cfg_oas_tgt_wwpn));
}

/**
 * lpfc_oas_tgt_store - Store wwpn of target whose luns maybe enabled for
 *		      Optimized Access Storage (OAS) operations.
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 * @count: Size of the data buffer.
 *
 * Returns:
 * -EINVAL count is invalid, invalid wwpn byte invalid
 * -EPERM oas is not supported by hba
 * value of count on success
 **/
static ssize_t
lpfc_oas_tgt_store(struct device *dev, struct device_attribute *attr,
		   const char *buf, size_t count)
{
	struct Scsi_Host *shost = class_to_shost(dev);
	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
	unsigned int cnt = count;
	uint8_t wwpn[WWN_SZ];
	int rc;

2379
	if (!phba->cfg_fof)
2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402
		return -EPERM;

	/* count may include a LF at end of string */
	if (buf[cnt-1] == '\n')
		cnt--;

	rc = lpfc_wwn_set(buf, cnt, wwpn);
	if (rc)
		return rc;

	memcpy(phba->cfg_oas_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
	memcpy(phba->sli4_hba.oas_next_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
	if (wwn_to_u64(wwpn) == 0)
		phba->cfg_oas_flags |= OAS_FIND_ANY_TARGET;
	else
		phba->cfg_oas_flags &= ~OAS_FIND_ANY_TARGET;
	phba->cfg_oas_flags &= ~OAS_LUN_VALID;
	phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
	return count;
}
static DEVICE_ATTR(lpfc_xlane_tgt, S_IRUGO | S_IWUSR,
		   lpfc_oas_tgt_show, lpfc_oas_tgt_store);

2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465
/**
 * lpfc_oas_priority_show - Return wwpn of target whose luns maybe enabled for
 *		      Optimized Access Storage (OAS) operations.
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 *
 * Returns:
 * value of count
 **/
static ssize_t
lpfc_oas_priority_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->cfg_oas_priority);
}

/**
 * lpfc_oas_priority_store - Store wwpn of target whose luns maybe enabled for
 *		      Optimized Access Storage (OAS) operations.
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 * @count: Size of the data buffer.
 *
 * Returns:
 * -EINVAL count is invalid, invalid wwpn byte invalid
 * -EPERM oas is not supported by hba
 * value of count on success
 **/
static ssize_t
lpfc_oas_priority_store(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
{
	struct Scsi_Host *shost = class_to_shost(dev);
	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
	unsigned int cnt = count;
	unsigned long val;
	int ret;

	if (!phba->cfg_fof)
		return -EPERM;

	/* count may include a LF at end of string */
	if (buf[cnt-1] == '\n')
		cnt--;

	ret = kstrtoul(buf, 0, &val);
	if (ret || (val > 0x7f))
		return -EINVAL;

	if (val)
		phba->cfg_oas_priority = (uint8_t)val;
	else
		phba->cfg_oas_priority = phba->cfg_XLanePriority;
	return count;
}
static DEVICE_ATTR(lpfc_xlane_priority, S_IRUGO | S_IWUSR,
		   lpfc_oas_priority_show, lpfc_oas_priority_store);

2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509
/**
 * lpfc_oas_vpt_show - Return wwpn of vport whose targets maybe enabled
 *		      for Optimized Access Storage (OAS) operations.
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 *
 * Returns:
 * value of count on success
 **/
static ssize_t
lpfc_oas_vpt_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, "0x%llx\n",
			wwn_to_u64(phba->cfg_oas_vpt_wwpn));
}

/**
 * lpfc_oas_vpt_store - Store wwpn of vport whose targets maybe enabled
 *		      for Optimized Access Storage (OAS) operations.
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 * @count: Size of the data buffer.
 *
 * Returns:
 * -EINVAL count is invalid, invalid wwpn byte invalid
 * -EPERM oas is not supported by hba
 * value of count on success
 **/
static ssize_t
lpfc_oas_vpt_store(struct device *dev, struct device_attribute *attr,
		   const char *buf, size_t count)
{
	struct Scsi_Host *shost = class_to_shost(dev);
	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
	unsigned int cnt = count;
	uint8_t wwpn[WWN_SZ];
	int rc;

2510
	if (!phba->cfg_fof)
2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527
		return -EPERM;

	/* count may include a LF at end of string */
	if (buf[cnt-1] == '\n')
		cnt--;

	rc = lpfc_wwn_set(buf, cnt, wwpn);
	if (rc)
		return rc;

	memcpy(phba->cfg_oas_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
	memcpy(phba->sli4_hba.oas_next_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
	if (wwn_to_u64(wwpn) == 0)
		phba->cfg_oas_flags |= OAS_FIND_ANY_VPORT;
	else
		phba->cfg_oas_flags &= ~OAS_FIND_ANY_VPORT;
	phba->cfg_oas_flags &= ~OAS_LUN_VALID;
2528
	phba->cfg_oas_priority = phba->cfg_XLanePriority;
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
	phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
	return count;
}
static DEVICE_ATTR(lpfc_xlane_vpt, S_IRUGO | S_IWUSR,
		   lpfc_oas_vpt_show, lpfc_oas_vpt_store);

/**
 * lpfc_oas_lun_state_show - Return the current state (enabled or disabled)
 *			    of whether luns will be enabled or disabled
 *			    for Optimized Access Storage (OAS) operations.
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 *
 * Returns:
 * size of formatted string.
 **/
static ssize_t
lpfc_oas_lun_state_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->cfg_oas_lun_state);
}

/**
 * lpfc_oas_lun_state_store - Store the state (enabled or disabled)
 *			    of whether luns will be enabled or disabled
 *			    for Optimized Access Storage (OAS) operations.
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 * @count: Size of the data buffer.
 *
 * Returns:
 * -EINVAL count is invalid, invalid wwpn byte invalid
 * -EPERM oas is not supported by hba
 * value of count on success
 **/
static ssize_t
lpfc_oas_lun_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_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
	int val = 0;

2578
	if (!phba->cfg_fof)
2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637
		return -EPERM;

	if (!isdigit(buf[0]))
		return -EINVAL;

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

	if ((val != 0) && (val != 1))
		return -EINVAL;

	phba->cfg_oas_lun_state = val;
	return strlen(buf);
}
static DEVICE_ATTR(lpfc_xlane_lun_state, S_IRUGO | S_IWUSR,
		   lpfc_oas_lun_state_show, lpfc_oas_lun_state_store);

/**
 * lpfc_oas_lun_status_show - Return the status of the Optimized Access
 *                          Storage (OAS) lun returned by the
 *                          lpfc_oas_lun_show function.
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 *
 * Returns:
 * size of formatted string.
 **/
static ssize_t
lpfc_oas_lun_status_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;

	if (!(phba->cfg_oas_flags & OAS_LUN_VALID))
		return -EFAULT;

	return snprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_status);
}
static DEVICE_ATTR(lpfc_xlane_lun_status, S_IRUGO,
		   lpfc_oas_lun_status_show, NULL);


/**
 * lpfc_oas_lun_state_set - enable or disable a lun for Optimized Access Storage
 *			   (OAS) operations.
 * @phba: lpfc_hba pointer.
 * @ndlp: pointer to fcp target node.
 * @lun: the fc lun for setting oas state.
 * @oas_state: the oas state to be set to the lun.
 *
 * Returns:
 * SUCCESS : 0
 * -EPERM OAS is not enabled or not supported by this port.
 *
 */
static size_t
lpfc_oas_lun_state_set(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
2638 2639
		       uint8_t tgt_wwpn[], uint64_t lun,
		       uint32_t oas_state, uint8_t pri)
2640 2641 2642 2643
{

	int rc = 0;

2644
	if (!phba->cfg_fof)
2645 2646 2647 2648
		return -EPERM;

	if (oas_state) {
		if (!lpfc_enable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
2649 2650
					 (struct lpfc_name *)tgt_wwpn,
					 lun, pri))
2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
			rc = -ENOMEM;
	} else {
		lpfc_disable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
				     (struct lpfc_name *)tgt_wwpn, lun);
	}
	return rc;

}

/**
 * lpfc_oas_lun_get_next - get the next lun that has been enabled for Optimized
 *			  Access Storage (OAS) operations.
 * @phba: lpfc_hba pointer.
 * @vpt_wwpn: wwpn of the vport associated with the returned lun
 * @tgt_wwpn: wwpn of the target associated with the returned lun
 * @lun_status: status of the lun returned lun
 *
 * Returns the first or next lun enabled for OAS operations for the vport/target
 * specified.  If a lun is found, its vport wwpn, target wwpn and status is
 * returned.  If the lun is not found, NOT_OAS_ENABLED_LUN is returned.
 *
 * Return:
 * lun that is OAS enabled for the vport/target
 * NOT_OAS_ENABLED_LUN when no oas enabled lun found.
 */
static uint64_t
lpfc_oas_lun_get_next(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
		      uint8_t tgt_wwpn[], uint32_t *lun_status)
{
	uint64_t found_lun;

	if (unlikely(!phba) || !vpt_wwpn || !tgt_wwpn)
		return NOT_OAS_ENABLED_LUN;
	if (lpfc_find_next_oas_lun(phba, (struct lpfc_name *)
				   phba->sli4_hba.oas_next_vpt_wwpn,
				   (struct lpfc_name *)
				   phba->sli4_hba.oas_next_tgt_wwpn,
				   &phba->sli4_hba.oas_next_lun,
				   (struct lpfc_name *)vpt_wwpn,
				   (struct lpfc_name *)tgt_wwpn,
				   &found_lun, lun_status))
		return found_lun;
	else
		return NOT_OAS_ENABLED_LUN;
}

/**
 * lpfc_oas_lun_state_change - enable/disable a lun for OAS operations
 * @phba: lpfc_hba pointer.
 * @vpt_wwpn: vport wwpn by reference.
 * @tgt_wwpn: target wwpn by reference.
 * @lun: the fc lun for setting oas state.
 * @oas_state: the oas state to be set to the oas_lun.
 *
 * This routine enables (OAS_LUN_ENABLE) or disables (OAS_LUN_DISABLE)
 * a lun for OAS operations.
 *
 * Return:
 * SUCCESS: 0
 * -ENOMEM: failed to enable an lun for OAS operations
 * -EPERM: OAS is not enabled
 */
static ssize_t
lpfc_oas_lun_state_change(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
			  uint8_t tgt_wwpn[], uint64_t lun,
2716
			  uint32_t oas_state, uint8_t pri)
2717 2718 2719 2720 2721
{

	int rc;

	rc = lpfc_oas_lun_state_set(phba, vpt_wwpn, tgt_wwpn, lun,
2722
				    oas_state, pri);
2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749
	return rc;
}

/**
 * lpfc_oas_lun_show - Return oas enabled luns from a chosen target
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 *
 * This routine returns a lun enabled for OAS each time the function
 * is called.
 *
 * Returns:
 * SUCCESS: size of formatted string.
 * -EFAULT: target or vport wwpn was not set properly.
 * -EPERM: oas is not enabled.
 **/
static ssize_t
lpfc_oas_lun_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;

	uint64_t oas_lun;
	int len = 0;

2750
	if (!phba->cfg_fof)
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 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
		return -EPERM;

	if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
		if (!(phba->cfg_oas_flags & OAS_FIND_ANY_VPORT))
			return -EFAULT;

	if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
		if (!(phba->cfg_oas_flags & OAS_FIND_ANY_TARGET))
			return -EFAULT;

	oas_lun = lpfc_oas_lun_get_next(phba, phba->cfg_oas_vpt_wwpn,
					phba->cfg_oas_tgt_wwpn,
					&phba->cfg_oas_lun_status);
	if (oas_lun != NOT_OAS_ENABLED_LUN)
		phba->cfg_oas_flags |= OAS_LUN_VALID;

	len += snprintf(buf + len, PAGE_SIZE-len, "0x%llx", oas_lun);

	return len;
}

/**
 * lpfc_oas_lun_store - Sets the OAS state for lun
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: buffer for passing information.
 *
 * This function sets the OAS state for lun.  Before this function is called,
 * the vport wwpn, target wwpn, and oas state need to be set.
 *
 * Returns:
 * SUCCESS: size of formatted string.
 * -EFAULT: target or vport wwpn was not set properly.
 * -EPERM: oas is not enabled.
 * size of formatted string.
 **/
static ssize_t
lpfc_oas_lun_store(struct device *dev, struct device_attribute *attr,
		   const char *buf, size_t count)
{
	struct Scsi_Host *shost = class_to_shost(dev);
	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
	uint64_t scsi_lun;
	ssize_t rc;

2796
	if (!phba->cfg_fof)
2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811
		return -EPERM;

	if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
		return -EFAULT;

	if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
		return -EFAULT;

	if (!isdigit(buf[0]))
		return -EINVAL;

	if (sscanf(buf, "0x%llx", &scsi_lun) != 1)
		return -EINVAL;

	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2812 2813
			"3372 Try to set vport 0x%llx target 0x%llx lun:0x%llx "
			"priority 0x%x with oas state %d\n",
2814 2815
			wwn_to_u64(phba->cfg_oas_vpt_wwpn),
			wwn_to_u64(phba->cfg_oas_tgt_wwpn), scsi_lun,
2816
			phba->cfg_oas_priority, phba->cfg_oas_lun_state);
2817 2818

	rc = lpfc_oas_lun_state_change(phba, phba->cfg_oas_vpt_wwpn,
2819 2820 2821
				       phba->cfg_oas_tgt_wwpn, scsi_lun,
				       phba->cfg_oas_lun_state,
				       phba->cfg_oas_priority);
2822 2823 2824 2825 2826 2827 2828
	if (rc)
		return rc;

	return count;
}
static DEVICE_ATTR(lpfc_xlane_lun, S_IRUGO | S_IWUSR,
		   lpfc_oas_lun_show, lpfc_oas_lun_store);
2829

2830
static int lpfc_poll = 0;
2831
module_param(lpfc_poll, int, S_IRUGO);
2832 2833 2834 2835 2836
MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
		 " 0 - none,"
		 " 1 - poll with interrupts enabled"
		 " 3 - poll and disable FCP ring interrupts");

2837 2838
static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
		   lpfc_poll_show, lpfc_poll_store);
已提交
2839

2840 2841 2842 2843 2844
LPFC_ATTR(sli_mode, 0, 0, 3,
	"SLI mode selector:"
	" 0 - auto (SLI-3 if supported),"
	" 2 - select SLI-2 even on SLI-3 capable HBAs,"
	" 3 - select SLI-3");
2845

2846 2847
LPFC_ATTR_R(enable_npiv, 1, 0, 1,
	"Enable NPIV functionality");
2848

2849 2850 2851
LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,
	"FCF Fast failover=1 Priority failover=2");

2852
int lpfc_enable_rrq = 2;
2853
module_param(lpfc_enable_rrq, int, S_IRUGO);
2854 2855
MODULE_PARM_DESC(lpfc_enable_rrq, "Enable RRQ functionality");
lpfc_param_show(enable_rrq);
2856 2857 2858 2859 2860 2861 2862
/*
# lpfc_enable_rrq: Track XRI/OXID reuse after IO failures
#	0x0 = disabled, XRI/OXID use not tracked.
#	0x1 = XRI/OXID reuse is timed with ratov, RRQ sent.
#	0x2 = XRI/OXID reuse is timed with ratov, No RRQ sent.
*/
lpfc_param_init(enable_rrq, 2, 0, 2);
2863 2864
static DEVICE_ATTR(lpfc_enable_rrq, S_IRUGO, lpfc_enable_rrq_show, NULL);

2865 2866 2867 2868 2869 2870 2871
/*
# 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.
*/
2872 2873 2874
LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
		LPFC_DELAY_INIT_LINK_INDEFINITELY,
		"Suppress Link Up at initialization");
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 2912 2913 2914 2915 2916 2917 2918 2919 2920
/*
# 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;
2921
module_param(lpfc_iocb_cnt, int, S_IRUGO);
2922 2923 2924 2925 2926 2927
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);
2928

2929 2930 2931 2932 2933 2934 2935 2936 2937 2938
/*
# 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");
2939 2940

/**
2941
 * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
2942 2943 2944 2945 2946 2947
 * @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.
 **/
2948
static ssize_t
2949 2950
lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
		    char *buf)
2951
{
2952
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
2953
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2954

2955
	return snprintf(buf, PAGE_SIZE, "%d\n",	vport->cfg_devloss_tmo);
2956 2957
}

2958
/**
2959
 * lpfc_nodev_tmo_init - Set the hba nodev timeout value
2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972
 * @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
 **/
2973
static int
2974 2975 2976 2977 2978
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)
2979
			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2980
					 "0407 Ignoring nodev_tmo module "
2981 2982
					 "parameter because devloss_tmo is "
					 "set.\n");
2983 2984 2985 2986
		return 0;
	}

	if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2987 2988
		vport->cfg_nodev_tmo = val;
		vport->cfg_devloss_tmo = val;
2989 2990
		return 0;
	}
2991 2992 2993 2994
	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);
2995
	vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
2996 2997 2998
	return -EINVAL;
}

2999
/**
3000
 * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
3001 3002 3003 3004 3005
 * @vport: lpfc vport structure pointer.
 *
 * Description:
 * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
 **/
3006
static void
3007
lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
3008
{
J
James Smart 已提交
3009
	struct Scsi_Host  *shost;
3010 3011
	struct lpfc_nodelist  *ndlp;

3012 3013 3014
	shost = lpfc_shost_from_vport(vport);
	spin_lock_irq(shost->host_lock);
	list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
3015
		if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport)
3016 3017
			ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
	spin_unlock_irq(shost->host_lock);
3018 3019
}

3020
/**
3021
 * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034
 * @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
 **/
3035
static int
3036
lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
3037
{
3038 3039
	if (vport->dev_loss_tmo_changed ||
	    (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
3040 3041 3042
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
				 "0401 Ignoring change to nodev_tmo "
				 "because devloss_tmo is set.\n");
3043 3044 3045
		return 0;
	}
	if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3046 3047
		vport->cfg_nodev_tmo = val;
		vport->cfg_devloss_tmo = val;
3048 3049 3050 3051 3052
		/*
		 * 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;
3053
		lpfc_update_rport_devloss_tmo(vport);
3054 3055
		return 0;
	}
3056 3057 3058 3059
	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);
3060 3061 3062
	return -EINVAL;
}

3063
lpfc_vport_param_store(nodev_tmo)
3064

3065 3066
static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
		   lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
3067 3068 3069 3070 3071 3072

/*
# 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.
*/
3073
module_param(lpfc_devloss_tmo, int, S_IRUGO);
3074 3075 3076
MODULE_PARM_DESC(lpfc_devloss_tmo,
		 "Seconds driver will hold I/O waiting "
		 "for a device to come back");
3077 3078 3079
lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
		      LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
lpfc_vport_param_show(devloss_tmo)
3080 3081

/**
3082
 * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094
 * @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
 **/
3095
static int
3096
lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
3097 3098
{
	if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3099 3100 3101
		vport->cfg_nodev_tmo = val;
		vport->cfg_devloss_tmo = val;
		vport->dev_loss_tmo_changed = 1;
3102
		fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3103
		lpfc_update_rport_devloss_tmo(vport);
3104 3105 3106
		return 0;
	}

3107 3108 3109 3110
	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);
3111 3112 3113
	return -EINVAL;
}

3114
lpfc_vport_param_store(devloss_tmo)
3115 3116
static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
		   lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
3117

已提交
3118 3119 3120 3121
/*
# 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:
3122
# See lpfc_logmsh.h for definitions.
已提交
3123
*/
3124
LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
3125
		       "Verbose logging bit-mask");
已提交
3126

J
James Smart 已提交
3127 3128 3129 3130
/*
# lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
# objects that have been registered with the nameserver after login.
*/
3131
LPFC_VPORT_ATTR_R(enable_da_id, 1, 0, 1,
J
James Smart 已提交
3132 3133
		  "Deregister nameserver objects before LOGO");

已提交
3134 3135
/*
# lun_queue_depth:  This parameter is used to limit the number of outstanding
3136 3137 3138 3139
# commands per FCP LUN. Value range is [1,512]. Default value is 30.
# If this parameter value is greater than 1/8th the maximum number of exchanges
# supported by the HBA port, then the lun queue depth will be reduced to
# 1/8th the maximum number of exchanges.
已提交
3140
*/
3141
LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 512,
3142
		  "Max number of FCP commands we can queue to a specific LUN");
已提交
3143

3144 3145 3146 3147 3148
/*
# 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,
3149
		  "Max number of FCP commands we can queue to a specific target port");
3150

3151 3152 3153 3154 3155 3156 3157 3158 3159 3160
/*
# 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");

3161 3162 3163 3164 3165 3166 3167 3168 3169
/*
# 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.
*/
3170 3171 3172
LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
		  "Allow peer ports on the same physical port to login to each "
		  "other.");
3173 3174

/*
3175
# restrict_login:  This parameter allows/prevents logins
3176 3177 3178 3179 3180 3181 3182 3183 3184
# 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.
*/
3185
static int lpfc_restrict_login = 1;
3186
module_param(lpfc_restrict_login, int, S_IRUGO);
3187 3188 3189 3190
MODULE_PARM_DESC(lpfc_restrict_login,
		 "Restrict virtual ports login to remote initiators.");
lpfc_vport_param_show(restrict_login);

3191
/**
3192
 * lpfc_restrict_login_init - Set the vport restrict login flag
3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205
 * @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
 **/
3206 3207 3208 3209
static int
lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
{
	if (val < 0 || val > 1) {
3210
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3211
				 "0422 lpfc_restrict_login attribute cannot "
3212 3213
				 "be set to %d, allowed range is [0, 1]\n",
				 val);
3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224
		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;
}

3225
/**
3226
 * lpfc_restrict_login_set - Set the vport restrict login flag
3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240
 * @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
 **/
3241 3242 3243 3244
static int
lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
{
	if (val < 0 || val > 1) {
3245
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3246
				 "0425 lpfc_restrict_login attribute cannot "
3247 3248
				 "be set to %d, allowed range is [0, 1]\n",
				 val);
3249 3250 3251 3252
		vport->cfg_restrict_login = 1;
		return -EINVAL;
	}
	if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
3253 3254 3255
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
				 "0468 lpfc_restrict_login must be 0 for "
				 "Physical ports.\n");
3256 3257 3258 3259 3260 3261 3262
		vport->cfg_restrict_login = 0;
		return 0;
	}
	vport->cfg_restrict_login = val;
	return 0;
}
lpfc_vport_param_store(restrict_login);
3263 3264
static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
		   lpfc_restrict_login_show, lpfc_restrict_login_store);
3265

已提交
3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282
/*
# 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.)
*/
3283 3284
LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
		  "Start scanning for devices from highest ALPA to lowest");
已提交
3285 3286 3287 3288

/*
# lpfc_topology:  link topology for init link
#            0x0  = attempt loop mode then point-to-point
3289
#            0x01 = internal loopback mode
已提交
3290 3291 3292 3293 3294 3295 3296
#            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.
*/
3297 3298

/**
3299
 * lpfc_topology_set - Set the adapters topology field
3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313
 * @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
 **/
3314 3315 3316
static ssize_t
lpfc_topology_store(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
3317
{
3318 3319 3320 3321 3322 3323
	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;
3324 3325
	int err;
	uint32_t prev_val;
3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336

	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;

3337 3338
	if (val >= 0 && val <= 6) {
		prev_val = phba->cfg_topology;
3339 3340 3341 3342
		if (phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G &&
			val == 4) {
			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
				"3113 Loop mode not supported at speed %d\n",
3343
				val);
3344 3345
			return -EINVAL;
		}
3346 3347 3348 3349 3350 3351 3352
		if (phba->pcidev->device == PCI_DEVICE_ID_LANCER_G6_FC &&
			val == 4) {
			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
				"3114 Loop mode not supported\n");
			return -EINVAL;
		}
		phba->cfg_topology = val;
3353 3354 3355
		if (nolip)
			return strlen(buf);

3356 3357 3358
		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
			"3054 lpfc_topology changed from %d to %d\n",
			prev_val, val);
3359 3360
		if (prev_val != val && phba->sli_rev == LPFC_SLI_REV4)
			phba->fc_topology_changed = 1;
3361
		err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
3362
		if (err) {
3363
			phba->cfg_topology = prev_val;
3364 3365 3366
			return -EINVAL;
		} else
			return strlen(buf);
3367 3368 3369 3370 3371 3372 3373 3374
	}
	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;
3375
module_param(lpfc_topology, int, S_IRUGO);
3376 3377 3378
MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology");
lpfc_param_show(topology)
lpfc_param_init(topology, 0, 0, 6)
3379
static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR,
3380
		lpfc_topology_show, lpfc_topology_store);
已提交
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
/**
 * 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);
3412 3413

/**
3414
 * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file
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
 * @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"))) {
3449
		if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1))
3450 3451
			return -EINVAL;

3452
		strncpy(bucket_data, buf, LPFC_MAX_DATA_CTRL_LEN);
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
		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;

3487
		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501
			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;

3502
		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518
			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;

3519
		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577
			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;
}


/**
3578
 * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file
3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654
 * @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)


/**
3655
 * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
3656
 * @filp: sysfs file
3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667
 * @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
3668 3669
sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj,
		struct bin_attribute *bin_attr,
3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738
		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,
};

已提交
3739 3740 3741
/*
# lpfc_link_speed: Link speed selection for initializing the Fibre Channel
# connection.
3742
# Value range is [0,16]. Default value is 0.
已提交
3743
*/
3744
/**
3745
 * lpfc_link_speed_set - Set the adapters link speed
3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760
 * @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
 **/
3761 3762 3763
static ssize_t
lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
3764
{
3765 3766 3767
	struct Scsi_Host  *shost = class_to_shost(dev);
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
3768
	int val = LPFC_USER_LINK_SPEED_AUTO;
3769 3770
	int nolip = 0;
	const char *val_buf = buf;
3771 3772 3773
	int err;
	uint32_t prev_val;

3774 3775 3776 3777 3778 3779 3780 3781 3782 3783
	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;

3784 3785 3786 3787
	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)");

3788 3789 3790 3791 3792
	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)) ||
3793 3794
	    ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb)) ||
	    ((val == LPFC_USER_LINK_SPEED_32G) && !(phba->lmt & LMT_32Gb))) {
3795 3796 3797 3798
		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);
3799
		return -EINVAL;
3800
	}
3801 3802 3803 3804 3805 3806 3807 3808
	if (val == LPFC_USER_LINK_SPEED_16G &&
		 phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
				"3112 lpfc_link_speed attribute cannot be set "
				"to %d. Speed is not supported in loop mode.\n",
				val);
		return -EINVAL;
	}
3809 3810
	if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
	    (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
3811 3812
		prev_val = phba->cfg_link_speed;
		phba->cfg_link_speed = val;
3813 3814 3815
		if (nolip)
			return strlen(buf);

3816
		err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
3817
		if (err) {
3818
			phba->cfg_link_speed = prev_val;
3819 3820 3821
			return -EINVAL;
		} else
			return strlen(buf);
3822 3823
	}
	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3824 3825
		"0469 lpfc_link_speed attribute cannot be set to %d, "
		"allowed values are ["LPFC_LINK_SPEED_STRING"]\n", val);
3826 3827 3828 3829
	return -EINVAL;
}

static int lpfc_link_speed = 0;
3830
module_param(lpfc_link_speed, int, S_IRUGO);
3831 3832
MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
lpfc_param_show(link_speed)
3833 3834

/**
3835
 * lpfc_link_speed_init - Set the adapters link speed
3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849
 * @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
 **/
3850 3851 3852
static int
lpfc_link_speed_init(struct lpfc_hba *phba, int val)
{
3853 3854 3855 3856 3857 3858 3859
	if (val == LPFC_USER_LINK_SPEED_16G && phba->cfg_topology == 4) {
		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
			"3111 lpfc_link_speed of %d cannot "
			"support loop mode, setting topology to default.\n",
			 val);
		phba->cfg_topology = 0;
	}
3860 3861
	if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
	    (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
3862 3863 3864 3865
		phba->cfg_link_speed = val;
		return 0;
	}
	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3866
			"0405 lpfc_link_speed attribute cannot "
3867 3868
			"be set to %d, allowed values are "
			"["LPFC_LINK_SPEED_STRING"]\n", val);
3869
	phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
3870 3871 3872
	return -EINVAL;
}

3873
static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
3874
		   lpfc_link_speed_show, lpfc_link_speed_store);
已提交
3875

J
James Smart 已提交
3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887
/*
# 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.
3888
 * @buf: containing enable or disable aer flag.
J
James Smart 已提交
3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934
 * @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 已提交
3935 3936
				rc = -EPERM;
		} else {
J
James Smart 已提交
3937
			phba->cfg_aer_support = 0;
J
James Smart 已提交
3938 3939
			rc = strlen(buf);
		}
J
James Smart 已提交
3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950
		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 已提交
3951 3952
				 rc = -EPERM;
		} else {
J
James Smart 已提交
3953
			phba->cfg_aer_support = 1;
J
James Smart 已提交
3954 3955
			rc = strlen(buf);
		}
J
James Smart 已提交
3956 3957 3958 3959 3960 3961 3962 3963 3964
		break;
	default:
		rc = -EINVAL;
		break;
	}
	return rc;
}

static int lpfc_aer_support = 1;
3965
module_param(lpfc_aer_support, int, S_IRUGO);
J
James Smart 已提交
3966 3967 3968 3969 3970 3971
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.
3972
 * @val: enable aer or disable aer flag.
J
James Smart 已提交
3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998
 *
 * 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 已提交
3999
	/* By default, try to enable AER on a device */
J
James Smart 已提交
4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010
	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.
4011
 * @buf: containing flag 1 for aer cleanup state.
J
James Smart 已提交
4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038
 * @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 已提交
4039 4040
	if (val != 1)
		return -EINVAL;
J
James Smart 已提交
4041

J
James Smart 已提交
4042
	if (phba->hba_flag & HBA_AER_ENABLED)
J
James Smart 已提交
4043 4044 4045 4046 4047
		rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev);

	if (rc == 0)
		return strlen(buf);
	else
J
James Smart 已提交
4048
		return -EPERM;
J
James Smart 已提交
4049 4050 4051 4052 4053
}

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

4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183
/**
 * 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);

4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254
/**
 * lpfc_request_firmware_store - Request for Linux generic firmware upgrade
 *
 * @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:
 *
 * 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_request_firmware_upgrade_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;

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

	rc = lpfc_sli4_request_firmware_update(phba, RUN_FW_UPGRADE);
	if (rc)
		rc = -EPERM;
	else
		rc = strlen(buf);
	return rc;
}

static int lpfc_req_fw_upgrade;
module_param(lpfc_req_fw_upgrade, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(lpfc_req_fw_upgrade, "Enable Linux generic firmware upgrade");
lpfc_param_show(request_firmware_upgrade)

/**
 * lpfc_request_firmware_upgrade_init - Enable initial linux generic fw upgrade
 * @phba: lpfc_hba pointer.
 * @val: 0 or 1.
 *
 * Description:
 * Set the initial Linux generic firmware upgrade enable or disable flag.
 *
 * Returns:
 * zero if val saved.
 * -EINVAL val out of range
 **/
static int
lpfc_request_firmware_upgrade_init(struct lpfc_hba *phba, int val)
{
	if (val >= 0 && val <= 1) {
		phba->cfg_request_firmware_upgrade = val;
		return 0;
	}
	return -EINVAL;
}
static DEVICE_ATTR(lpfc_req_fw_upgrade, S_IRUGO | S_IWUSR,
		   lpfc_request_firmware_upgrade_show,
		   lpfc_request_firmware_upgrade_store);

4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280
/**
 * lpfc_fcp_imax_store
 *
 * @dev: class device that is converted into a Scsi_host.
 * @attr: device attribute, not used.
 * @buf: string with the number of fast-path FCP interrupts per second.
 * @count: unused variable.
 *
 * Description:
 * If val is in a valid range [636,651042], then set the adapter's
 * maximum number of fast-path FCP interrupts per second.
 *
 * 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_fcp_imax_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, i;

4281 4282 4283 4284
	/* fcp_imax is only valid for SLI4 */
	if (phba->sli_rev != LPFC_SLI_REV4)
		return -EINVAL;

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

4291 4292 4293 4294 4295
	/*
	 * Value range for the HBA is [5000,5000000]
	 * The value for each EQ depends on how many EQs are configured.
	 */
	if (val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX)
4296 4297 4298
		return -EINVAL;

	phba->cfg_fcp_imax = (uint32_t)val;
4299
	for (i = 0; i < phba->cfg_fcp_io_channel; i += LPFC_MAX_EQ_DELAY)
4300 4301 4302 4303 4304 4305 4306
		lpfc_modify_fcp_eq_delay(phba, i);

	return strlen(buf);
}

/*
# lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second
4307
# for the HBA.
4308
#
4309
# Value range is [5,000 to 5,000,000]. Default value is 50,000.
4310
*/
4311
static int lpfc_fcp_imax = LPFC_DEF_IMAX;
4312 4313
module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(lpfc_fcp_imax,
4314
	    "Set the maximum number of FCP interrupts per second per HBA");
4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332
lpfc_param_show(fcp_imax)

/**
 * lpfc_fcp_imax_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 [636,651042], then initialize the adapter's
 * maximum number of fast-path FCP interrupts per second.
 *
 * Returns:
 * zero if val saved.
 * -EINVAL val out of range
 **/
static int
lpfc_fcp_imax_init(struct lpfc_hba *phba, int val)
{
4333 4334 4335 4336 4337 4338
	if (phba->sli_rev != LPFC_SLI_REV4) {
		phba->cfg_fcp_imax = 0;
		return 0;
	}

	if (val >= LPFC_MIN_IMAX && val <= LPFC_MAX_IMAX) {
4339 4340 4341 4342 4343 4344
		phba->cfg_fcp_imax = val;
		return 0;
	}

	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
			"3016 fcp_imax: %d out of range, using default\n", val);
4345
	phba->cfg_fcp_imax = LPFC_DEF_IMAX;
4346 4347 4348 4349 4350 4351 4352

	return 0;
}

static DEVICE_ATTR(lpfc_fcp_imax, S_IRUGO | S_IWUSR,
		   lpfc_fcp_imax_show, lpfc_fcp_imax_store);

4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368
/**
 * lpfc_state_show - Display current driver CPU affinity
 * @dev: class converted to a Scsi_host structure.
 * @attr: device attribute, not used.
 * @buf: on return contains text describing the state of the link.
 *
 * Returns: size of formatted string.
 **/
static ssize_t
lpfc_fcp_cpu_map_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;
	struct lpfc_vector_map_info *cpup;
4369
	int  len = 0;
4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396

	if ((phba->sli_rev != LPFC_SLI_REV4) ||
	    (phba->intr_type != MSIX))
		return len;

	switch (phba->cfg_fcp_cpu_map) {
	case 0:
		len += snprintf(buf + len, PAGE_SIZE-len,
				"fcp_cpu_map: No mapping (%d)\n",
				phba->cfg_fcp_cpu_map);
		return len;
	case 1:
		len += snprintf(buf + len, PAGE_SIZE-len,
				"fcp_cpu_map: HBA centric mapping (%d): "
				"%d online CPUs\n",
				phba->cfg_fcp_cpu_map,
				phba->sli4_hba.num_online_cpu);
		break;
	case 2:
		len += snprintf(buf + len, PAGE_SIZE-len,
				"fcp_cpu_map: Driver centric mapping (%d): "
				"%d online CPUs\n",
				phba->cfg_fcp_cpu_map,
				phba->sli4_hba.num_online_cpu);
		break;
	}

4397 4398 4399 4400
	while (phba->sli4_hba.curr_disp_cpu < phba->sli4_hba.num_present_cpu) {
		cpup = &phba->sli4_hba.cpu_map[phba->sli4_hba.curr_disp_cpu];

		/* margin should fit in this and the truncated message */
4401 4402 4403 4404
		if (cpup->irq == LPFC_VECTOR_MAP_EMPTY)
			len += snprintf(buf + len, PAGE_SIZE-len,
					"CPU %02d io_chan %02d "
					"physid %d coreid %d\n",
4405 4406
					phba->sli4_hba.curr_disp_cpu,
					cpup->channel_id, cpup->phys_id,
4407 4408 4409 4410 4411
					cpup->core_id);
		else
			len += snprintf(buf + len, PAGE_SIZE-len,
					"CPU %02d io_chan %02d "
					"physid %d coreid %d IRQ %d\n",
4412 4413
					phba->sli4_hba.curr_disp_cpu,
					cpup->channel_id, cpup->phys_id,
4414 4415
					cpup->core_id, cpup->irq);

4416 4417 4418 4419 4420 4421 4422 4423 4424
		phba->sli4_hba.curr_disp_cpu++;

		/* display max number of CPUs keeping some margin */
		if (phba->sli4_hba.curr_disp_cpu <
				phba->sli4_hba.num_present_cpu &&
				(len >= (PAGE_SIZE - 64))) {
			len += snprintf(buf + len, PAGE_SIZE-len, "more...\n");
			break;
		}
4425
	}
4426 4427 4428 4429

	if (phba->sli4_hba.curr_disp_cpu == phba->sli4_hba.num_present_cpu)
		phba->sli4_hba.curr_disp_cpu = 0;

4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503
	return len;
}

/**
 * lpfc_fcp_cpu_map_store - Change CPU affinity of driver vectors
 * @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  - Not implemented yet.
 **/
static ssize_t
lpfc_fcp_cpu_map_store(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
{
	int status = -EINVAL;
	return status;
}

/*
# lpfc_fcp_cpu_map: Defines how to map CPUs to IRQ vectors
# for the HBA.
#
# Value range is [0 to 2]. Default value is LPFC_DRIVER_CPU_MAP (2).
#	0 - Do not affinitze IRQ vectors
#	1 - Affintize HBA vectors with respect to each HBA
#	    (start with CPU0 for each HBA)
#	2 - Affintize HBA vectors with respect to the entire driver
#	    (round robin thru all CPUs across all HBAs)
*/
static int lpfc_fcp_cpu_map = LPFC_DRIVER_CPU_MAP;
module_param(lpfc_fcp_cpu_map, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(lpfc_fcp_cpu_map,
		 "Defines how to map CPUs to IRQ vectors per HBA");

/**
 * lpfc_fcp_cpu_map_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-2], then affinitze the adapter's
 * MSIX vectors.
 *
 * Returns:
 * zero if val saved.
 * -EINVAL val out of range
 **/
static int
lpfc_fcp_cpu_map_init(struct lpfc_hba *phba, int val)
{
	if (phba->sli_rev != LPFC_SLI_REV4) {
		phba->cfg_fcp_cpu_map = 0;
		return 0;
	}

	if (val >= LPFC_MIN_CPU_MAP && val <= LPFC_MAX_CPU_MAP) {
		phba->cfg_fcp_cpu_map = val;
		return 0;
	}

	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
			"3326 fcp_cpu_map: %d out of range, using default\n",
			val);
	phba->cfg_fcp_cpu_map = LPFC_DRIVER_CPU_MAP;

	return 0;
}

static DEVICE_ATTR(lpfc_fcp_cpu_map, S_IRUGO | S_IWUSR,
		   lpfc_fcp_cpu_map_show, lpfc_fcp_cpu_map_store);

已提交
4504 4505 4506 4507
/*
# lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
# Value range is [2,3]. Default value is 3.
*/
4508 4509
LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
		  "Select Fibre Channel class of service for FCP sequences");
已提交
4510 4511 4512 4513 4514

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

4518 4519 4520 4521 4522 4523 4524 4525
/*
# lpfc_first_burst_size: First burst size to use on the NPorts
# that support first burst.
# Value range is [0,65536]. Default value is 0.
*/
LPFC_VPORT_ATTR_RW(first_burst_size, 0, 0, 65536,
		   "First burst size for Targets that support first burst");

4526 4527 4528 4529 4530 4531 4532 4533 4534
/*
# 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;
4535
module_param(lpfc_max_scsicmpl_time, int, S_IRUGO);
4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557
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;
4558
		ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
4559 4560 4561 4562 4563 4564 4565 4566 4567
	}
	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);

已提交
4568 4569 4570 4571 4572 4573
/*
# 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");

4574 4575 4576 4577 4578 4579
/*
# lpfc_fcp_io_sched: Determine scheduling algrithmn for issuing FCP cmds
# range is [0,1]. Default value is 0.
# For [0], FCP commands are issued to Work Queues ina round robin fashion.
# For [1], FCP commands are issued to a Work Queue associated with the
#          current CPU.
4580 4581 4582
# It would be set to 1 by the driver if it's able to set up cpu affinity
# for FCP I/Os through Work Queue associated with the current CPU. Otherwise,
# roundrobin scheduling of FCP I/Os through WQs will be used.
4583
*/
4584
LPFC_ATTR_RW(fcp_io_sched, 0, 0, 1, "Determine scheduling algorithm for "
4585 4586
		"issuing commands [0] - Round Robin, [1] - Current CPU");

4587 4588 4589 4590 4591 4592 4593 4594 4595 4596
/*
# lpfc_fcp2_no_tgt_reset: Determine bus reset behavior
# range is [0,1]. Default value is 0.
# For [0], bus reset issues target reset to ALL devices
# For [1], bus reset issues target reset to non-FCP2 devices
*/
LPFC_ATTR_RW(fcp2_no_tgt_reset, 0, 0, 1, "Determine bus reset behavior for "
	     "FCP2 devices [0] - issue tgt reset, [1] - no tgt reset");


已提交
4597 4598 4599
/*
# lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
# cr_delay (msec) or cr_count outstanding commands. cr_delay can take
4600
# value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
已提交
4601 4602 4603
# is 0. Default value of cr_count is 1. The cr_count feature is disabled if
# cr_delay is set to 0.
*/
4604
LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
已提交
4605 4606
		"interrupt response is generated");

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

4610 4611 4612 4613 4614 4615 4616 4617
/*
# 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");

4618 4619 4620 4621 4622
/*
# 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).
*/
4623
LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
4624 4625 4626 4627 4628 4629 4630
	     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).
*/
4631
LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
4632 4633
	     255, "Identifies TYPE for additional ring configuration");

已提交
4634
/*
4635 4636 4637 4638 4639
# lpfc_enable_SmartSAN: Sets up FDMI support for SmartSAN
#       0  = SmartSAN functionality disabled (default)
#       1  = SmartSAN functionality enabled
# This parameter will override the value of lpfc_fdmi_on module parameter.
# Value range is [0,1]. Default value is 0.
已提交
4640
*/
4641 4642 4643 4644 4645 4646
LPFC_ATTR_R(enable_SmartSAN, 0, 0, 1, "Enable SmartSAN functionality");

/*
# lpfc_fdmi_on: Controls FDMI support.
#       0       No FDMI support (default)
#       1       Traditional FDMI support
4647 4648 4649 4650 4651 4652
# Traditional FDMI support means the driver will assume FDMI-2 support;
# however, if that fails, it will fallback to FDMI-1.
# If lpfc_enable_SmartSAN is set to 1, the driver ignores lpfc_fdmi_on.
# If lpfc_enable_SmartSAN is set 0, the driver uses the current value of
# lpfc_fdmi_on.
# Value range [0,1]. Default value is 0.
4653
*/
4654
LPFC_ATTR_R(fdmi_on, 0, 0, 1, "Enable FDMI support");
已提交
4655 4656 4657 4658 4659

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

/*
4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681
# lpfc_max_luns: maximum allowed LUN ID. This is the highest LUN ID that
#    will be scanned by the SCSI midlayer when sequential scanning is
#    used; and is also the highest LUN ID allowed when the SCSI midlayer
#    parses REPORT_LUN responses. The lpfc driver has no LUN count or
#    LUN ID limit, but the SCSI midlayer requires this field for the uses
#    above. The lpfc driver limits the default value to 255 for two reasons.
#    As it bounds the sequential scan loop, scanning for thousands of luns
#    on a target can take minutes of wall clock time.  Additionally,
#    there are FC targets, such as JBODs, that only recognize 8-bits of
#    LUN ID. When they receive a value greater than 8 bits, they chop off
#    the high order bits. In other words, they see LUN IDs 0, 256, 512,
#    and so on all as LUN ID 0. This causes the linux kernel, which sees
#    valid responses at each of the LUN IDs, to believe there are multiple
#    devices present, when in fact, there is only 1.
#    A customer that is aware of their target behaviors, and the results as
#    indicated above, is welcome to increase the lpfc_max_luns value.
#    As mentioned, this value is not used by the lpfc driver, only the
#    SCSI midlayer.
J
James Smart 已提交
4682 4683
# Value range is [0,65535]. Default value is 255.
# NOTE: The SCSI layer might probe all allowed LUN on some old targets.
已提交
4684
*/
4685
LPFC_VPORT_ULL_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN ID");
已提交
4686

4687 4688 4689 4690 4691 4692 4693
/*
# 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");

4694
/*
4695 4696 4697 4698 4699 4700
# lpfc_task_mgmt_tmo: Maximum time to wait for task management commands
# to complete in seconds. Value range is [5,180], default value is 60.
*/
LPFC_ATTR_RW(task_mgmt_tmo, 60, 5, 180,
	     "Maximum time to wait for task management commands to complete");
/*
4701 4702
# lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
#		support this feature
4703
#       0  = MSI disabled
4704
#       1  = MSI enabled
4705 4706
#       2  = MSI-X enabled (default)
# Value range is [0,2]. Default value is 2.
4707
*/
4708
LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
4709
	    "MSI-X (2), if possible");
4710

4711 4712 4713 4714 4715 4716 4717 4718 4719
/*
# lpfc_fcp_io_channel: Set the number of FCP EQ/CQ/WQ IO channels
#
# Value range is [1,7]. Default value is 4.
*/
LPFC_ATTR_R(fcp_io_channel, LPFC_FCP_IO_CHAN_DEF, LPFC_FCP_IO_CHAN_MIN,
	    LPFC_FCP_IO_CHAN_MAX,
	    "Set the number of FCP I/O channels");

4720 4721 4722 4723 4724 4725 4726
/*
# 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.");
4727

4728
/*
4729
# lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
4730 4731 4732 4733
#       0  = HBA Heartbeat disabled
#       1  = HBA Heartbeat enabled (default)
# Value range is [0,1]. Default value is 1.
*/
4734
LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
4735

4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748
/*
# lpfc_EnableXLane: Enable Express Lane Feature
#      0x0   Express Lane Feature disabled
#      0x1   Express Lane Feature enabled
# Value range is [0,1]. Default value is 0.
*/
LPFC_ATTR_R(EnableXLane, 0, 0, 1, "Enable Express Lane Feature.");

/*
# lpfc_XLanePriority:  Define CS_CTL priority for Express Lane Feature
#       0x0 - 0x7f  = CS_CTL field in FC header (high 7 bits)
# Value range is [0x0,0x7f]. Default value is 0
*/
4749
LPFC_ATTR_RW(XLanePriority, 0, 0x0, 0x7f, "CS_CTL for Express Lane Feature.");
4750

4751 4752 4753 4754 4755 4756 4757 4758
/*
# 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");

4759 4760 4761 4762 4763
/*
# lpfc_fcp_look_ahead: Look ahead for completions in FCP start routine
#       0  = disabled (default)
#       1  = enabled
# Value range is [0,1]. Default value is 0.
4764 4765
#
# This feature in under investigation and may be supported in the future.
4766 4767 4768
*/
unsigned int lpfc_fcp_look_ahead = LPFC_LOOK_AHEAD_OFF;

4769 4770 4771 4772 4773 4774 4775
/*
# 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.
4776 4777 4778 4779 4780 4781
#	- SHOST_DIF_TYPE1_PROTECTION	1
#		HBA supports T10 DIF Type 1: HBA to Target Type 1 Protection
#	- SHOST_DIX_TYPE0_PROTECTION	8
#		HBA supports DIX Type 0: Host to HBA protection only
#	- SHOST_DIX_TYPE1_PROTECTION	16
#		HBA supports DIX Type 1: Host to HBA  Type 1 protection
4782 4783
#
*/
J
James Smart 已提交
4784 4785 4786
unsigned int lpfc_prot_mask = SHOST_DIF_TYPE1_PROTECTION |
			      SHOST_DIX_TYPE0_PROTECTION |
			      SHOST_DIX_TYPE1_PROTECTION;
4787

4788
module_param(lpfc_prot_mask, uint, S_IRUGO);
4789 4790 4791 4792 4793
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
4794
#	- Guard types are currently either 1) T10-DIF CRC 2) IP checksum
4795 4796 4797 4798 4799
#	- 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;
4800
module_param(lpfc_prot_guard, byte, S_IRUGO);
4801 4802
MODULE_PARM_DESC(lpfc_prot_guard, "host protection guard type");

4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816
/*
 * 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.
 */
4817 4818
LPFC_ATTR(delay_discovery, 0, 0, 1,
	"Delay NPort discovery when Clean Address bit is cleared.");
4819

4820
/*
4821
 * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
4822
 * This value can be set to values between 64 and 4096. The default value is
4823 4824
 * 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).
4825 4826 4827
 * Because of the additional overhead involved in setting up T10-DIF,
 * this parameter will be limited to 128 if BlockGuard is enabled under SLI4
 * and will be limited to 512 if BlockGuard is enabled under SLI3.
4828 4829 4830 4831
 */
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");

4832 4833 4834 4835 4836 4837 4838
/*
 * This parameter will be depricated, the driver cannot limit the
 * protection data s/g list.
 */
LPFC_ATTR_R(prot_sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT,
	    LPFC_DEFAULT_SG_SEG_CNT, LPFC_MAX_SG_SEG_CNT,
	    "Max Protection Scatter Gather Segment Count");
4839

J
James Smart 已提交
4840 4841 4842 4843 4844 4845 4846 4847
/*
 * lpfc_enable_mds_diags: Enable MDS Diagnostics
 *       0  = MDS Diagnostics disabled (default)
 *       1  = MDS Diagnostics enabled
 * Value range is [0,1]. Default value is 0.
 */
LPFC_ATTR_R(enable_mds_diags, 0, 0, 1, "Enable MDS Diagnostics");

4848
struct device_attribute *lpfc_hba_attrs[] = {
4849 4850 4851 4852
	&dev_attr_bg_info,
	&dev_attr_bg_guard_err,
	&dev_attr_bg_apptag_err,
	&dev_attr_bg_reftag_err,
4853 4854 4855 4856 4857 4858 4859 4860 4861
	&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,
4862
	&dev_attr_link_state,
4863
	&dev_attr_num_discovered_ports,
4864
	&dev_attr_menlo_mgmt_mode,
4865
	&dev_attr_lpfc_drvr_version,
4866
	&dev_attr_lpfc_enable_fip,
4867 4868 4869
	&dev_attr_lpfc_temp_sensor,
	&dev_attr_lpfc_log_verbose,
	&dev_attr_lpfc_lun_queue_depth,
4870
	&dev_attr_lpfc_tgt_queue_depth,
4871 4872 4873 4874 4875 4876
	&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,
4877
	&dev_attr_lpfc_first_burst_size,
4878 4879 4880 4881
	&dev_attr_lpfc_ack0,
	&dev_attr_lpfc_topology,
	&dev_attr_lpfc_scan_down,
	&dev_attr_lpfc_link_speed,
4882
	&dev_attr_lpfc_fcp_io_sched,
4883
	&dev_attr_lpfc_fcp2_no_tgt_reset,
4884 4885 4886 4887 4888 4889
	&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,
4890
	&dev_attr_lpfc_enable_SmartSAN,
4891 4892
	&dev_attr_lpfc_max_luns,
	&dev_attr_lpfc_enable_npiv,
4893
	&dev_attr_lpfc_fcf_failover_policy,
4894
	&dev_attr_lpfc_enable_rrq,
4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906
	&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,
4907
	&dev_attr_lpfc_task_mgmt_tmo,
4908
	&dev_attr_lpfc_use_msi,
4909
	&dev_attr_lpfc_fcp_imax,
4910
	&dev_attr_lpfc_fcp_cpu_map,
4911
	&dev_attr_lpfc_fcp_io_channel,
4912
	&dev_attr_lpfc_enable_bg,
4913 4914 4915 4916 4917
	&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,
4918 4919 4920 4921 4922 4923 4924
	&dev_attr_lpfc_EnableXLane,
	&dev_attr_lpfc_XLanePriority,
	&dev_attr_lpfc_xlane_lun,
	&dev_attr_lpfc_xlane_tgt,
	&dev_attr_lpfc_xlane_vpt,
	&dev_attr_lpfc_xlane_lun_state,
	&dev_attr_lpfc_xlane_lun_status,
4925
	&dev_attr_lpfc_xlane_priority,
4926
	&dev_attr_lpfc_sg_seg_cnt,
4927
	&dev_attr_lpfc_max_scsicmpl_time,
4928
	&dev_attr_lpfc_stat_data_ctrl,
4929
	&dev_attr_lpfc_prot_sg_seg_cnt,
J
James Smart 已提交
4930 4931
	&dev_attr_lpfc_aer_support,
	&dev_attr_lpfc_aer_state_cleanup,
4932
	&dev_attr_lpfc_sriov_nr_virtfn,
4933
	&dev_attr_lpfc_req_fw_upgrade,
4934
	&dev_attr_lpfc_suppress_link_up,
4935 4936 4937 4938
	&dev_attr_lpfc_iocb_cnt,
	&dev_attr_iocb_hw,
	&dev_attr_txq_hw,
	&dev_attr_txcmplq_hw,
4939 4940
	&dev_attr_lpfc_fips_level,
	&dev_attr_lpfc_fips_rev,
4941
	&dev_attr_lpfc_dss,
4942
	&dev_attr_lpfc_sriov_hw_max_virtfn,
4943
	&dev_attr_protocol,
4944
	&dev_attr_lpfc_xlane_supported,
J
James Smart 已提交
4945
	&dev_attr_lpfc_enable_mds_diags,
已提交
4946 4947 4948
	NULL,
};

4949 4950
struct device_attribute *lpfc_vport_attrs[] = {
	&dev_attr_info,
4951
	&dev_attr_link_state,
4952 4953 4954 4955
	&dev_attr_num_discovered_ports,
	&dev_attr_lpfc_drvr_version,
	&dev_attr_lpfc_log_verbose,
	&dev_attr_lpfc_lun_queue_depth,
4956
	&dev_attr_lpfc_tgt_queue_depth,
4957 4958 4959 4960 4961 4962 4963
	&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,
4964
	&dev_attr_lpfc_first_burst_size,
4965 4966 4967 4968
	&dev_attr_lpfc_max_luns,
	&dev_attr_nport_evt_cnt,
	&dev_attr_npiv_info,
	&dev_attr_lpfc_enable_da_id,
4969 4970
	&dev_attr_lpfc_max_scsicmpl_time,
	&dev_attr_lpfc_stat_data_ctrl,
4971
	&dev_attr_lpfc_static_vport,
4972 4973
	&dev_attr_lpfc_fips_level,
	&dev_attr_lpfc_fips_rev,
4974 4975 4976
	NULL,
};

4977
/**
4978
 * sysfs_ctlreg_write - Write method for writing to ctlreg
4979
 * @filp: open sysfs file
4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995
 * @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
 **/
已提交
4996
static ssize_t
4997 4998
sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
		   struct bin_attribute *bin_attr,
4999
		   char *buf, loff_t off, size_t count)
已提交
5000 5001
{
	size_t buf_off;
5002 5003
	struct device *dev = container_of(kobj, struct device, kobj);
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
5004 5005
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
5006

5007 5008 5009
	if (phba->sli_rev >= LPFC_SLI_REV4)
		return -EPERM;

已提交
5010 5011 5012
	if ((off + count) > FF_REG_AREA_SIZE)
		return -ERANGE;

5013 5014
	if (count <= LPFC_REG_WRITE_KEY_SIZE)
		return 0;
已提交
5015 5016 5017 5018

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

5019 5020 5021 5022 5023
	/* 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))
已提交
5024 5025
		return -EPERM;

J
James Smart 已提交
5026
	spin_lock_irq(&phba->hbalock);
5027 5028 5029
	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)),
已提交
5030 5031
		       phba->ctrl_regs_memmap_p + off + buf_off);

J
James Smart 已提交
5032
	spin_unlock_irq(&phba->hbalock);
已提交
5033 5034 5035 5036

	return count;
}

5037
/**
5038
 * sysfs_ctlreg_read - Read method for reading from ctlreg
5039
 * @filp: open sysfs file
5040 5041
 * @kobj: kernel kobject that contains the kernel class device.
 * @bin_attr: kernel attributes passed to us.
5042
 * @buf: if successful contains the data from the adapter IOREG space.
5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054
 * @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
 **/
已提交
5055
static ssize_t
5056 5057
sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
		  struct bin_attribute *bin_attr,
5058
		  char *buf, loff_t off, size_t count)
已提交
5059 5060 5061
{
	size_t buf_off;
	uint32_t * tmp_ptr;
5062 5063
	struct device *dev = container_of(kobj, struct device, kobj);
	struct Scsi_Host  *shost = class_to_shost(dev);
J
James Smart 已提交
5064 5065
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
5066

5067 5068 5069
	if (phba->sli_rev >= LPFC_SLI_REV4)
		return -EPERM;

已提交
5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080
	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 已提交
5081
	spin_lock_irq(&phba->hbalock);
已提交
5082 5083 5084 5085 5086 5087

	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 已提交
5088
	spin_unlock_irq(&phba->hbalock);
已提交
5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102

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

5103
/**
5104
 * sysfs_mbox_write - Write method for writing information via mbox
5105
 * @filp: open sysfs file
5106 5107 5108 5109 5110 5111 5112
 * @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:
5113 5114
 * Deprecated function. All mailbox access from user space is performed via the
 * bsg interface.
5115 5116
 *
 * Returns:
5117
 * -EPERM operation not permitted
5118
 **/
已提交
5119
static ssize_t
5120 5121
sysfs_mbox_write(struct file *filp, struct kobject *kobj,
		 struct bin_attribute *bin_attr,
5122
		 char *buf, loff_t off, size_t count)
已提交
5123
{
5124
	return -EPERM;
已提交
5125 5126
}

5127
/**
5128
 * sysfs_mbox_read - Read method for reading information via mbox
5129
 * @filp: open sysfs file
5130 5131 5132 5133 5134 5135 5136
 * @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:
5137 5138
 * Deprecated function. All mailbox access from user space is performed via the
 * bsg interface.
5139 5140
 *
 * Returns:
5141
 * -EPERM operation not permitted
5142
 **/
已提交
5143
static ssize_t
5144 5145
sysfs_mbox_read(struct file *filp, struct kobject *kobj,
		struct bin_attribute *bin_attr,
5146
		char *buf, loff_t off, size_t count)
已提交
5147
{
5148
	return -EPERM;
已提交
5149 5150 5151 5152 5153 5154 5155
}

static struct bin_attribute sysfs_mbox_attr = {
	.attr = {
		.name = "mbox",
		.mode = S_IRUSR | S_IWUSR,
	},
5156
	.size = MAILBOX_SYSFS_MAX,
已提交
5157 5158 5159 5160
	.read = sysfs_mbox_read,
	.write = sysfs_mbox_write,
};

5161
/**
5162
 * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
5163 5164 5165 5166 5167 5168
 * @vport: address of lpfc vport structure.
 *
 * Return codes:
 * zero on success
 * error return code from sysfs_create_bin_file()
 **/
已提交
5169
int
J
James Smart 已提交
5170
lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
已提交
5171
{
J
James Smart 已提交
5172
	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
已提交
5173 5174
	int error;

5175
	error = sysfs_create_bin_file(&shost->shost_dev.kobj,
5176 5177 5178 5179
				      &sysfs_drvr_stat_data_attr);

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

5182
	error = sysfs_create_bin_file(&shost->shost_dev.kobj,
5183
				      &sysfs_ctlreg_attr);
已提交
5184
	if (error)
5185
		goto out_remove_stat_attr;
已提交
5186

5187
	error = sysfs_create_bin_file(&shost->shost_dev.kobj,
5188
				      &sysfs_mbox_attr);
5189
	if (error)
5190
		goto out_remove_ctlreg_attr;
5191

已提交
5192 5193
	return 0;
out_remove_ctlreg_attr:
5194
	sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
5195 5196 5197
out_remove_stat_attr:
	sysfs_remove_bin_file(&shost->shost_dev.kobj,
			&sysfs_drvr_stat_data_attr);
已提交
5198 5199 5200 5201
out:
	return error;
}

5202
/**
5203
 * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
5204 5205
 * @vport: address of lpfc vport structure.
 **/
已提交
5206
void
J
James Smart 已提交
5207
lpfc_free_sysfs_attr(struct lpfc_vport *vport)
已提交
5208
{
J
James Smart 已提交
5209
	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5210 5211
	sysfs_remove_bin_file(&shost->shost_dev.kobj,
		&sysfs_drvr_stat_data_attr);
5212 5213 5214
	/* Virtual ports do not need ctrl_reg and mbox */
	if (vport->port_type == LPFC_NPIV_PORT)
		return;
5215 5216
	sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
	sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
已提交
5217 5218 5219 5220 5221 5222
}

/*
 * Dynamic FC Host Attributes Support
 */

5223
/**
5224
 * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
5225 5226
 * @shost: kernel scsi host pointer.
 **/
已提交
5227 5228 5229
static void
lpfc_get_host_port_id(struct Scsi_Host *shost)
{
J
James Smart 已提交
5230 5231
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;

已提交
5232
	/* note: fc_myDID already in cpu endianness */
J
James Smart 已提交
5233
	fc_host_port_id(shost) = vport->fc_myDID;
已提交
5234 5235
}

5236
/**
5237
 * lpfc_get_host_port_type - Set the value of the scsi host port type
5238 5239
 * @shost: kernel scsi host pointer.
 **/
已提交
5240 5241 5242
static void
lpfc_get_host_port_type(struct Scsi_Host *shost)
{
J
James Smart 已提交
5243 5244
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
5245 5246 5247

	spin_lock_irq(shost->host_lock);

5248 5249 5250
	if (vport->port_type == LPFC_NPIV_PORT) {
		fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
	} else if (lpfc_is_link_up(phba)) {
5251
		if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
J
James Smart 已提交
5252
			if (vport->fc_flag & FC_PUBLIC_LOOP)
已提交
5253 5254 5255 5256
				fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
			else
				fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
		} else {
J
James Smart 已提交
5257
			if (vport->fc_flag & FC_FABRIC)
已提交
5258 5259 5260 5261 5262 5263 5264 5265 5266 5267
				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);
}

5268
/**
5269
 * lpfc_get_host_port_state - Set the value of the scsi host port state
5270 5271
 * @shost: kernel scsi host pointer.
 **/
已提交
5272 5273 5274
static void
lpfc_get_host_port_state(struct Scsi_Host *shost)
{
J
James Smart 已提交
5275 5276
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
5277 5278 5279

	spin_lock_irq(shost->host_lock);

J
James Smart 已提交
5280
	if (vport->fc_flag & FC_OFFLINE_MODE)
已提交
5281 5282
		fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
	else {
J
James Smart 已提交
5283 5284
		switch (phba->link_state) {
		case LPFC_LINK_UNKNOWN:
已提交
5285 5286 5287 5288 5289 5290
		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:
5291 5292 5293 5294 5295 5296 5297
			/* Links up, reports port state accordingly */
			if (vport->port_state < LPFC_VPORT_READY)
				fc_host_port_state(shost) =
							FC_PORTSTATE_BYPASSED;
			else
				fc_host_port_state(shost) =
							FC_PORTSTATE_ONLINE;
已提交
5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310
			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);
}

5311
/**
5312
 * lpfc_get_host_speed - Set the value of the scsi host speed
5313 5314
 * @shost: kernel scsi host pointer.
 **/
已提交
5315 5316 5317
static void
lpfc_get_host_speed(struct Scsi_Host *shost)
{
J
James Smart 已提交
5318 5319
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
5320 5321 5322

	spin_lock_irq(shost->host_lock);

5323
	if ((lpfc_is_link_up(phba)) && (!(phba->hba_flag & HBA_FCOE_MODE))) {
已提交
5324
		switch(phba->fc_linkspeed) {
5325 5326
		case LPFC_LINK_SPEED_1GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
已提交
5327
			break;
5328 5329
		case LPFC_LINK_SPEED_2GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
已提交
5330
			break;
5331 5332
		case LPFC_LINK_SPEED_4GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
已提交
5333
			break;
5334 5335
		case LPFC_LINK_SPEED_8GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
5336
			break;
5337 5338
		case LPFC_LINK_SPEED_10GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
5339
			break;
5340 5341 5342
		case LPFC_LINK_SPEED_16GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
			break;
5343 5344 5345
		case LPFC_LINK_SPEED_32GHZ:
			fc_host_speed(shost) = FC_PORTSPEED_32GBIT;
			break;
5346 5347
		default:
			fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
已提交
5348 5349
			break;
		}
5350 5351
	} else
		fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
已提交
5352 5353 5354 5355

	spin_unlock_irq(shost->host_lock);
}

5356
/**
5357
 * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
5358 5359
 * @shost: kernel scsi host pointer.
 **/
已提交
5360 5361 5362
static void
lpfc_get_host_fabric_name (struct Scsi_Host *shost)
{
J
James Smart 已提交
5363 5364
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
5365
	u64 node_name;
已提交
5366 5367 5368

	spin_lock_irq(shost->host_lock);

5369 5370 5371 5372
	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 已提交
5373
		node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
已提交
5374 5375
	else
		/* fabric is local port if there is no F/FL_Port */
5376
		node_name = 0;
已提交
5377 5378 5379

	spin_unlock_irq(shost->host_lock);

5380
	fc_host_fabric_name(shost) = node_name;
已提交
5381 5382
}

5383
/**
5384
 * lpfc_get_stats - Return statistical information about the adapter
5385 5386 5387 5388 5389 5390 5391 5392 5393 5394
 * @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
 **/
已提交
5395 5396 5397
static struct fc_host_statistics *
lpfc_get_stats(struct Scsi_Host *shost)
{
J
James Smart 已提交
5398 5399 5400
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	struct lpfc_sli   *psli = &phba->sli;
5401
	struct fc_host_statistics *hs = &phba->link_stats;
5402
	struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
已提交
5403 5404
	LPFC_MBOXQ_t *pmboxq;
	MAILBOX_t *pmb;
5405
	unsigned long seconds;
5406
	int rc = 0;
已提交
5407

5408 5409 5410 5411
	/*
	 * prevent udev from issuing mailbox commands until the port is
	 * configured.
	 */
J
James Smart 已提交
5412 5413
	if (phba->link_state < LPFC_LINK_DOWN ||
	    !phba->mbox_mem_pool ||
5414
	    (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
5415
		return NULL;
J
James Smart 已提交
5416 5417

	if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
5418 5419
		return NULL;

已提交
5420 5421 5422 5423 5424
	pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
	if (!pmboxq)
		return NULL;
	memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));

5425
	pmb = &pmboxq->u.mb;
已提交
5426 5427 5428
	pmb->mbxCommand = MBX_READ_STATUS;
	pmb->mbxOwner = OWN_HOST;
	pmboxq->context1 = NULL;
5429
	pmboxq->vport = vport;
已提交
5430

5431
	if (vport->fc_flag & FC_OFFLINE_MODE)
已提交
5432
		rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
5433
	else
已提交
5434 5435 5436
		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);

	if (rc != MBX_SUCCESS) {
J
James Smart 已提交
5437
		if (rc != MBX_TIMEOUT)
5438
			mempool_free(pmboxq, phba->mbox_mem_pool);
已提交
5439 5440 5441
		return NULL;
	}

5442 5443
	memset(hs, 0, sizeof (struct fc_host_statistics));

已提交
5444
	hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
5445 5446 5447 5448 5449 5450 5451
	/*
	 * 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);
已提交
5452
	hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
5453 5454 5455
	hs->rx_words = (uint64_t)
			((uint64_t)pmb->un.varRdStatus.rcvByteCnt
			 * (uint64_t)256);
已提交
5456

5457
	memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
已提交
5458 5459 5460
	pmb->mbxCommand = MBX_READ_LNK_STAT;
	pmb->mbxOwner = OWN_HOST;
	pmboxq->context1 = NULL;
5461
	pmboxq->vport = vport;
已提交
5462

5463
	if (vport->fc_flag & FC_OFFLINE_MODE)
已提交
5464
		rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
5465
	else
已提交
5466 5467 5468
		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);

	if (rc != MBX_SUCCESS) {
J
James Smart 已提交
5469
		if (rc != MBX_TIMEOUT)
5470
			mempool_free(pmboxq, phba->mbox_mem_pool);
已提交
5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481
		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;

5482 5483 5484 5485 5486 5487 5488 5489
	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;

5490
	if (phba->hba_flag & HBA_FCOE_MODE) {
5491 5492 5493
		hs->lip_count = -1;
		hs->nos_count = (phba->link_events >> 1);
		hs->nos_count -= lso->link_events;
5494
	} else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
已提交
5495
		hs->lip_count = (phba->fc_eventTag >> 1);
5496
		hs->lip_count -= lso->link_events;
已提交
5497 5498 5499 5500
		hs->nos_count = -1;
	} else {
		hs->lip_count = -1;
		hs->nos_count = (phba->fc_eventTag >> 1);
5501
		hs->nos_count -= lso->link_events;
已提交
5502 5503 5504 5505
	}

	hs->dumped_frames = -1;

5506 5507 5508 5509 5510 5511
	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;
已提交
5512

5513 5514
	mempool_free(pmboxq, phba->mbox_mem_pool);

已提交
5515 5516 5517
	return hs;
}

5518
/**
5519
 * lpfc_reset_stats - Copy the adapter link stats information
5520 5521
 * @shost: kernel scsi host pointer.
 **/
5522 5523 5524
static void
lpfc_reset_stats(struct Scsi_Host *shost)
{
J
James Smart 已提交
5525 5526 5527 5528
	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;
5529 5530 5531 5532
	LPFC_MBOXQ_t *pmboxq;
	MAILBOX_t *pmb;
	int rc = 0;

J
James Smart 已提交
5533
	if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
5534 5535
		return;

5536 5537 5538 5539 5540
	pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
	if (!pmboxq)
		return;
	memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));

5541
	pmb = &pmboxq->u.mb;
5542 5543 5544 5545
	pmb->mbxCommand = MBX_READ_STATUS;
	pmb->mbxOwner = OWN_HOST;
	pmb->un.varWords[0] = 0x1; /* reset request */
	pmboxq->context1 = NULL;
5546
	pmboxq->vport = vport;
5547

J
James Smart 已提交
5548
	if ((vport->fc_flag & FC_OFFLINE_MODE) ||
5549
		(!(psli->sli_flag & LPFC_SLI_ACTIVE)))
5550 5551 5552 5553 5554
		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 已提交
5555
		if (rc != MBX_TIMEOUT)
5556 5557 5558 5559 5560 5561 5562 5563
			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;
5564
	pmboxq->vport = vport;
5565

J
James Smart 已提交
5566
	if ((vport->fc_flag & FC_OFFLINE_MODE) ||
5567
	    (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
5568 5569 5570 5571 5572
		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 已提交
5573
		if (rc != MBX_TIMEOUT)
5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584
			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;
5585
	if (phba->hba_flag & HBA_FCOE_MODE)
5586 5587 5588
		lso->link_events = (phba->link_events >> 1);
	else
		lso->link_events = (phba->fc_eventTag >> 1);
5589 5590 5591

	psli->stats_start = get_seconds();

5592 5593
	mempool_free(pmboxq, phba->mbox_mem_pool);

5594 5595
	return;
}
已提交
5596 5597 5598 5599 5600

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

5602
/**
5603
 * lpfc_get_node_by_target - Return the nodelist for a target
5604 5605 5606 5607 5608 5609
 * @starget: kernel scsi target pointer.
 *
 * Returns:
 * address of the node list if found
 * NULL target not found
 **/
5610 5611
static struct lpfc_nodelist *
lpfc_get_node_by_target(struct scsi_target *starget)
已提交
5612
{
J
James Smart 已提交
5613 5614
	struct Scsi_Host  *shost = dev_to_shost(starget->dev.parent);
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5615
	struct lpfc_nodelist *ndlp;
已提交
5616 5617

	spin_lock_irq(shost->host_lock);
5618
	/* Search for this, mapped, target ID */
J
James Smart 已提交
5619
	list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
5620 5621
		if (NLP_CHK_NODE_ACT(ndlp) &&
		    ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
5622 5623 5624
		    starget->id == ndlp->nlp_sid) {
			spin_unlock_irq(shost->host_lock);
			return ndlp;
已提交
5625 5626 5627
		}
	}
	spin_unlock_irq(shost->host_lock);
5628 5629
	return NULL;
}
已提交
5630

5631
/**
5632
 * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
5633 5634
 * @starget: kernel scsi target pointer.
 **/
5635 5636 5637 5638 5639 5640
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;
已提交
5641 5642
}

5643
/**
5644
 * lpfc_get_starget_node_name - Set the target node name
5645 5646 5647 5648
 * @starget: kernel scsi target pointer.
 *
 * Description: Set the target node name to the ndlp node name wwn or zero.
 **/
已提交
5649 5650 5651
static void
lpfc_get_starget_node_name(struct scsi_target *starget)
{
5652
	struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
已提交
5653

5654 5655
	fc_starget_node_name(starget) =
		ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
已提交
5656 5657
}

5658
/**
5659
 * lpfc_get_starget_port_name - Set the target port name
5660 5661 5662 5663
 * @starget: kernel scsi target pointer.
 *
 * Description:  set the target port name to the ndlp port name wwn or zero.
 **/
已提交
5664 5665 5666
static void
lpfc_get_starget_port_name(struct scsi_target *starget)
{
5667
	struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
已提交
5668

5669 5670
	fc_starget_port_name(starget) =
		ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
已提交
5671 5672
}

5673
/**
5674
 * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
5675 5676 5677 5678 5679 5680 5681
 * @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.
 **/
已提交
5682 5683 5684 5685
static void
lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
{
	if (timeout)
5686
		rport->dev_loss_tmo = timeout;
已提交
5687
	else
5688
		rport->dev_loss_tmo = 1;
已提交
5689 5690
}

5691
/**
5692
 * lpfc_rport_show_function - Return rport target information
5693 5694 5695 5696 5697 5698 5699 5700 5701 5702
 *
 * 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.
 **/
已提交
5703 5704
#define lpfc_rport_show_function(field, format_string, sz, cast)	\
static ssize_t								\
5705 5706 5707
lpfc_show_rport_##field (struct device *dev,				\
			 struct device_attribute *attr,			\
			 char *buf)					\
已提交
5708
{									\
5709
	struct fc_rport *rport = transport_class_to_rport(dev);		\
已提交
5710 5711 5712 5713 5714 5715 5716 5717 5718
	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)

5719
/**
5720
 * lpfc_set_vport_symbolic_name - Set the vport's symbolic name
5721 5722 5723 5724 5725
 * @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 已提交
5726
 * switch to propagate the change into the fabric if the vport is active.
5727 5728 5729 5730 5731 5732 5733 5734 5735
 **/
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);
}
已提交
5736

5737 5738 5739 5740 5741 5742
/**
 * 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
5743
 * log message according to the module's lpfc_log_verbose parameter setting
5744 5745 5746 5747 5748 5749 5750 5751
 * 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;
}

已提交
5752 5753 5754 5755 5756 5757 5758 5759
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,
5760
	.show_host_symbolic_name = 1,
已提交
5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786

	/* 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,
5787
	.reset_fc_host_stats = lpfc_reset_stats,
已提交
5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803

	.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,
5804 5805

	.issue_fc_host_lip = lpfc_issue_lip,
5806 5807
	.dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
	.terminate_rport_io = lpfc_terminate_rport_io,
5808 5809

	.dd_fcvport_size = sizeof(struct lpfc_vport *),
5810 5811 5812 5813

	.vport_disable = lpfc_vport_disable,

	.set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
5814 5815 5816

	.bsg_request = lpfc_bsg_request,
	.bsg_timeout = lpfc_bsg_timeout,
5817 5818
};

5819 5820 5821 5822 5823 5824 5825 5826
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,
5827
	.show_host_symbolic_name = 1,
5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875

	/* 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,
5876 5877

	.set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
5878 5879
};

5880
/**
5881
 * lpfc_get_cfgparam - Used during probe_one to init the adapter structure
5882 5883
 * @phba: lpfc_hba pointer.
 **/
已提交
5884 5885 5886
void
lpfc_get_cfgparam(struct lpfc_hba *phba)
{
5887
	lpfc_fcp_io_sched_init(phba, lpfc_fcp_io_sched);
5888
	lpfc_fcp2_no_tgt_reset_init(phba, lpfc_fcp2_no_tgt_reset);
5889 5890
	lpfc_cr_delay_init(phba, lpfc_cr_delay);
	lpfc_cr_count_init(phba, lpfc_cr_count);
5891
	lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
5892 5893
	lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
	lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
5894 5895 5896
	lpfc_ack0_init(phba, lpfc_ack0);
	lpfc_topology_init(phba, lpfc_topology);
	lpfc_link_speed_init(phba, lpfc_link_speed);
5897
	lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
5898
	lpfc_task_mgmt_tmo_init(phba, lpfc_task_mgmt_tmo);
5899
	lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
5900
	lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);
5901
	lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
5902 5903
	lpfc_fdmi_on_init(phba, lpfc_fdmi_on);
	lpfc_enable_SmartSAN_init(phba, lpfc_enable_SmartSAN);
5904
	lpfc_use_msi_init(phba, lpfc_use_msi);
5905
	lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
5906
	lpfc_fcp_cpu_map_init(phba, lpfc_fcp_cpu_map);
5907
	lpfc_fcp_io_channel_init(phba, lpfc_fcp_io_channel);
5908 5909
	lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
	lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
5910 5911 5912 5913 5914 5915 5916 5917 5918
	lpfc_EnableXLane_init(phba, lpfc_EnableXLane);
	if (phba->sli_rev != LPFC_SLI_REV4)
		phba->cfg_EnableXLane = 0;
	lpfc_XLanePriority_init(phba, lpfc_XLanePriority);
	memset(phba->cfg_oas_tgt_wwpn, 0, (8 * sizeof(uint8_t)));
	memset(phba->cfg_oas_vpt_wwpn, 0, (8 * sizeof(uint8_t)));
	phba->cfg_oas_lun_state = 0;
	phba->cfg_oas_lun_status = 0;
	phba->cfg_oas_flags = 0;
5919
	phba->cfg_oas_priority = 0;
5920
	lpfc_enable_bg_init(phba, lpfc_enable_bg);
5921 5922 5923
	if (phba->sli_rev == LPFC_SLI_REV4)
		phba->cfg_poll = 0;
	else
5924
		phba->cfg_poll = lpfc_poll;
5925

5926
	phba->cfg_soft_wwnn = 0L;
5927
	phba->cfg_soft_wwpn = 0L;
5928
	lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
5929
	lpfc_prot_sg_seg_cnt_init(phba, lpfc_prot_sg_seg_cnt);
5930
	lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
5931
	lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
J
James Smart 已提交
5932
	lpfc_aer_support_init(phba, lpfc_aer_support);
5933
	lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
5934
	lpfc_request_firmware_upgrade_init(phba, lpfc_req_fw_upgrade);
5935
	lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
5936
	lpfc_iocb_cnt_init(phba, lpfc_iocb_cnt);
5937
	lpfc_delay_discovery_init(phba, lpfc_delay_discovery);
5938
	lpfc_sli_mode_init(phba, lpfc_sli_mode);
5939
	phba->cfg_enable_dss = 1;
J
James Smart 已提交
5940
	lpfc_enable_mds_diags_init(phba, lpfc_enable_mds_diags);
5941 5942
	return;
}
5943

5944
/**
5945
 * lpfc_get_vport_cfgparam - Used during port create, init the vport structure
5946 5947
 * @vport: lpfc_vport pointer.
 **/
5948 5949 5950
void
lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
{
5951
	lpfc_log_verbose_init(vport, lpfc_log_verbose);
5952
	lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
5953
	lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth);
5954 5955 5956 5957 5958 5959
	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);
5960
	lpfc_first_burst_size_init(vport, lpfc_first_burst_size);
5961
	lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
5962 5963 5964
	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 已提交
5965
	lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
已提交
5966 5967
	return;
}