bfad.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
   4 * Copyright (c) 2014- QLogic Corporation.
   5 * All rights reserved
   6 * www.qlogic.com
   7 *
   8 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
   9 */
  10
  11/*
  12 *  bfad.c Linux driver PCI interface module.
  13 */
  14#include <linux/module.h>
  15#include <linux/kthread.h>
  16#include <linux/errno.h>
  17#include <linux/sched.h>
  18#include <linux/init.h>
  19#include <linux/fs.h>
  20#include <linux/pci.h>
  21#include <linux/firmware.h>
  22#include <linux/uaccess.h>
  23#include <asm/fcntl.h>
  24
  25#include "bfad_drv.h"
  26#include "bfad_im.h"
  27#include "bfa_fcs.h"
  28#include "bfa_defs.h"
  29#include "bfa.h"
  30
  31BFA_TRC_FILE(LDRV, BFAD);
  32DEFINE_MUTEX(bfad_mutex);
  33LIST_HEAD(bfad_list);
  34
  35static int	bfad_inst;
  36static int      num_sgpgs_parm;
  37int		supported_fc4s;
  38char		*host_name, *os_name, *os_patch;
  39int		num_rports, num_ios, num_tms;
  40int		num_fcxps, num_ufbufs;
  41int		reqq_size, rspq_size, num_sgpgs;
  42int		rport_del_timeout = BFA_FCS_RPORT_DEF_DEL_TIMEOUT;
  43int		bfa_lun_queue_depth = BFAD_LUN_QUEUE_DEPTH;
  44int		bfa_io_max_sge = BFAD_IO_MAX_SGE;
  45int		bfa_log_level = 3; /* WARNING log level */
  46int		ioc_auto_recover = BFA_TRUE;
  47int		bfa_linkup_delay = -1;
  48int		fdmi_enable = BFA_TRUE;
  49int		pcie_max_read_reqsz;
  50int		bfa_debugfs_enable = 1;
  51int		msix_disable_cb = 0, msix_disable_ct = 0;
  52int		max_xfer_size = BFAD_MAX_SECTORS >> 1;
  53static int	max_rport_logins = BFA_FCS_MAX_RPORT_LOGINS;
  54
  55/* Firmware releated */
  56u32	bfi_image_cb_size, bfi_image_ct_size, bfi_image_ct2_size;
  57u32	*bfi_image_cb, *bfi_image_ct, *bfi_image_ct2;
  58
  59#define BFAD_FW_FILE_CB		"cbfw-3.2.5.1.bin"
  60#define BFAD_FW_FILE_CT		"ctfw-3.2.5.1.bin"
  61#define BFAD_FW_FILE_CT2	"ct2fw-3.2.5.1.bin"
  62
  63static u32 *bfad_load_fwimg(struct pci_dev *pdev);
  64static void bfad_free_fwimg(void);
  65static void bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
  66		u32 *bfi_image_size, char *fw_name);
  67
  68static const char *msix_name_ct[] = {
  69	"ctrl",
  70	"cpe0", "cpe1", "cpe2", "cpe3",
  71	"rme0", "rme1", "rme2", "rme3" };
  72
  73static const char *msix_name_cb[] = {
  74	"cpe0", "cpe1", "cpe2", "cpe3",
  75	"rme0", "rme1", "rme2", "rme3",
  76	"eemc", "elpu0", "elpu1", "epss", "mlpu" };
  77
  78MODULE_FIRMWARE(BFAD_FW_FILE_CB);
  79MODULE_FIRMWARE(BFAD_FW_FILE_CT);
  80MODULE_FIRMWARE(BFAD_FW_FILE_CT2);
  81
  82module_param(os_name, charp, S_IRUGO | S_IWUSR);
  83MODULE_PARM_DESC(os_name, "OS name of the hba host machine");
  84module_param(os_patch, charp, S_IRUGO | S_IWUSR);
  85MODULE_PARM_DESC(os_patch, "OS patch level of the hba host machine");
  86module_param(host_name, charp, S_IRUGO | S_IWUSR);
  87MODULE_PARM_DESC(host_name, "Hostname of the hba host machine");
  88module_param(num_rports, int, S_IRUGO | S_IWUSR);
  89MODULE_PARM_DESC(num_rports, "Max number of rports supported per port "
  90				"(physical/logical), default=1024");
  91module_param(num_ios, int, S_IRUGO | S_IWUSR);
  92MODULE_PARM_DESC(num_ios, "Max number of ioim requests, default=2000");
  93module_param(num_tms, int, S_IRUGO | S_IWUSR);
  94MODULE_PARM_DESC(num_tms, "Max number of task im requests, default=128");
  95module_param(num_fcxps, int, S_IRUGO | S_IWUSR);
  96MODULE_PARM_DESC(num_fcxps, "Max number of fcxp requests, default=64");
  97module_param(num_ufbufs, int, S_IRUGO | S_IWUSR);
  98MODULE_PARM_DESC(num_ufbufs, "Max number of unsolicited frame "
  99				"buffers, default=64");
 100module_param(reqq_size, int, S_IRUGO | S_IWUSR);
 101MODULE_PARM_DESC(reqq_size, "Max number of request queue elements, "
 102				"default=256");
 103module_param(rspq_size, int, S_IRUGO | S_IWUSR);
 104MODULE_PARM_DESC(rspq_size, "Max number of response queue elements, "
 105				"default=64");
 106module_param(num_sgpgs, int, S_IRUGO | S_IWUSR);
 107MODULE_PARM_DESC(num_sgpgs, "Number of scatter/gather pages, default=2048");
 108module_param(rport_del_timeout, int, S_IRUGO | S_IWUSR);
 109MODULE_PARM_DESC(rport_del_timeout, "Rport delete timeout, default=90 secs, "
 110					"Range[>0]");
 111module_param(bfa_lun_queue_depth, int, S_IRUGO | S_IWUSR);
 112MODULE_PARM_DESC(bfa_lun_queue_depth, "Lun queue depth, default=32, Range[>0]");
 113module_param(bfa_io_max_sge, int, S_IRUGO | S_IWUSR);
 114MODULE_PARM_DESC(bfa_io_max_sge, "Max io scatter/gather elements, default=255");
 115module_param(bfa_log_level, int, S_IRUGO | S_IWUSR);
 116MODULE_PARM_DESC(bfa_log_level, "Driver log level, default=3, "
 117				"Range[Critical:1|Error:2|Warning:3|Info:4]");
 118module_param(ioc_auto_recover, int, S_IRUGO | S_IWUSR);
 119MODULE_PARM_DESC(ioc_auto_recover, "IOC auto recovery, default=1, "
 120				"Range[off:0|on:1]");
 121module_param(bfa_linkup_delay, int, S_IRUGO | S_IWUSR);
 122MODULE_PARM_DESC(bfa_linkup_delay, "Link up delay, default=30 secs for "
 123			"boot port. Otherwise 10 secs in RHEL4 & 0 for "
 124			"[RHEL5, SLES10, ESX40] Range[>0]");
 125module_param(msix_disable_cb, int, S_IRUGO | S_IWUSR);
 126MODULE_PARM_DESC(msix_disable_cb, "Disable Message Signaled Interrupts for QLogic-415/425/815/825 cards, default=0 Range[false:0|true:1]");
 127module_param(msix_disable_ct, int, S_IRUGO | S_IWUSR);
 128MODULE_PARM_DESC(msix_disable_ct, "Disable Message Signaled Interrupts if possible for QLogic-1010/1020/804/1007/902/1741 cards, default=0, Range[false:0|true:1]");
 129module_param(fdmi_enable, int, S_IRUGO | S_IWUSR);
 130MODULE_PARM_DESC(fdmi_enable, "Enables fdmi registration, default=1, "
 131				"Range[false:0|true:1]");
 132module_param(pcie_max_read_reqsz, int, S_IRUGO | S_IWUSR);
 133MODULE_PARM_DESC(pcie_max_read_reqsz, "PCIe max read request size, default=0 "
 134		"(use system setting), Range[128|256|512|1024|2048|4096]");
 135module_param(bfa_debugfs_enable, int, S_IRUGO | S_IWUSR);
 136MODULE_PARM_DESC(bfa_debugfs_enable, "Enables debugfs feature, default=1,"
 137		" Range[false:0|true:1]");
 138module_param(max_xfer_size, int, S_IRUGO | S_IWUSR);
 139MODULE_PARM_DESC(max_xfer_size, "default=32MB,"
 140		" Range[64k|128k|256k|512k|1024k|2048k]");
 141module_param(max_rport_logins, int, S_IRUGO | S_IWUSR);
 142MODULE_PARM_DESC(max_rport_logins, "Max number of logins to initiator and target rports on a port (physical/logical), default=1024");
 143
 144static void
 145bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event);
 146static void
 147bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event);
 148static void
 149bfad_sm_initializing(struct bfad_s *bfad, enum bfad_sm_event event);
 150static void
 151bfad_sm_operational(struct bfad_s *bfad, enum bfad_sm_event event);
 152static void
 153bfad_sm_stopping(struct bfad_s *bfad, enum bfad_sm_event event);
 154static void
 155bfad_sm_failed(struct bfad_s *bfad, enum bfad_sm_event event);
 156static void
 157bfad_sm_fcs_exit(struct bfad_s *bfad, enum bfad_sm_event event);
 158
 159/*
 160 * Beginning state for the driver instance, awaiting the pci_probe event
 161 */
 162static void
 163bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event)
 164{
 165	bfa_trc(bfad, event);
 166
 167	switch (event) {
 168	case BFAD_E_CREATE:
 169		bfa_sm_set_state(bfad, bfad_sm_created);
 170		bfad->bfad_tsk = kthread_create(bfad_worker, (void *) bfad,
 171						"%s", "bfad_worker");
 172		if (IS_ERR(bfad->bfad_tsk)) {
 173			printk(KERN_INFO "bfad[%d]: Kernel thread "
 174				"creation failed!\n", bfad->inst_no);
 175			bfa_sm_send_event(bfad, BFAD_E_KTHREAD_CREATE_FAILED);
 176		}
 177		bfa_sm_send_event(bfad, BFAD_E_INIT);
 178		break;
 179
 180	case BFAD_E_STOP:
 181		/* Ignore stop; already in uninit */
 182		break;
 183
 184	default:
 185		bfa_sm_fault(bfad, event);
 186	}
 187}
 188
 189/*
 190 * Driver Instance is created, awaiting event INIT to initialize the bfad
 191 */
 192static void
 193bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event)
 194{
 195	unsigned long flags;
 196	bfa_status_t ret;
 197
 198	bfa_trc(bfad, event);
 199
 200	switch (event) {
 201	case BFAD_E_INIT:
 202		bfa_sm_set_state(bfad, bfad_sm_initializing);
 203
 204		init_completion(&bfad->comp);
 205
 206		/* Enable Interrupt and wait bfa_init completion */
 207		if (bfad_setup_intr(bfad)) {
 208			printk(KERN_WARNING "bfad%d: bfad_setup_intr failed\n",
 209					bfad->inst_no);
 210			bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED);
 211			break;
 212		}
 213
 214		spin_lock_irqsave(&bfad->bfad_lock, flags);
 215		bfa_iocfc_init(&bfad->bfa);
 216		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 217
 218		/* Set up interrupt handler for each vectors */
 219		if ((bfad->bfad_flags & BFAD_MSIX_ON) &&
 220			bfad_install_msix_handler(bfad)) {
 221			printk(KERN_WARNING "%s: install_msix failed, bfad%d\n",
 222				__func__, bfad->inst_no);
 223		}
 224
 225		bfad_init_timer(bfad);
 226
 227		wait_for_completion(&bfad->comp);
 228
 229		if ((bfad->bfad_flags & BFAD_HAL_INIT_DONE)) {
 230			bfa_sm_send_event(bfad, BFAD_E_INIT_SUCCESS);
 231		} else {
 232			printk(KERN_WARNING
 233				"bfa %s: bfa init failed\n",
 234				bfad->pci_name);
 235			spin_lock_irqsave(&bfad->bfad_lock, flags);
 236			bfa_fcs_init(&bfad->bfa_fcs);
 237			spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 238
 239			ret = bfad_cfg_pport(bfad, BFA_LPORT_ROLE_FCP_IM);
 240			if (ret != BFA_STATUS_OK) {
 241				init_completion(&bfad->comp);
 242
 243				spin_lock_irqsave(&bfad->bfad_lock, flags);
 244				bfad->pport.flags |= BFAD_PORT_DELETE;
 245				bfa_fcs_exit(&bfad->bfa_fcs);
 246				spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 247
 248				wait_for_completion(&bfad->comp);
 249
 250				bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED);
 251				break;
 252			}
 253			bfad->bfad_flags |= BFAD_HAL_INIT_FAIL;
 254			bfa_sm_send_event(bfad, BFAD_E_HAL_INIT_FAILED);
 255		}
 256
 257		break;
 258
 259	case BFAD_E_KTHREAD_CREATE_FAILED:
 260		bfa_sm_set_state(bfad, bfad_sm_uninit);
 261		break;
 262
 263	default:
 264		bfa_sm_fault(bfad, event);
 265	}
 266}
 267
 268static void
 269bfad_sm_initializing(struct bfad_s *bfad, enum bfad_sm_event event)
 270{
 271	int	retval;
 272	unsigned long	flags;
 273
 274	bfa_trc(bfad, event);
 275
 276	switch (event) {
 277	case BFAD_E_INIT_SUCCESS:
 278		kthread_stop(bfad->bfad_tsk);
 279		spin_lock_irqsave(&bfad->bfad_lock, flags);
 280		bfad->bfad_tsk = NULL;
 281		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 282
 283		retval = bfad_start_ops(bfad);
 284		if (retval != BFA_STATUS_OK) {
 285			bfa_sm_set_state(bfad, bfad_sm_failed);
 286			break;
 287		}
 288		bfa_sm_set_state(bfad, bfad_sm_operational);
 289		break;
 290
 291	case BFAD_E_INIT_FAILED:
 292		bfa_sm_set_state(bfad, bfad_sm_uninit);
 293		kthread_stop(bfad->bfad_tsk);
 294		spin_lock_irqsave(&bfad->bfad_lock, flags);
 295		bfad->bfad_tsk = NULL;
 296		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 297		break;
 298
 299	case BFAD_E_HAL_INIT_FAILED:
 300		bfa_sm_set_state(bfad, bfad_sm_failed);
 301		break;
 302	default:
 303		bfa_sm_fault(bfad, event);
 304	}
 305}
 306
 307static void
 308bfad_sm_failed(struct bfad_s *bfad, enum bfad_sm_event event)
 309{
 310	int	retval;
 311
 312	bfa_trc(bfad, event);
 313
 314	switch (event) {
 315	case BFAD_E_INIT_SUCCESS:
 316		retval = bfad_start_ops(bfad);
 317		if (retval != BFA_STATUS_OK)
 318			break;
 319		bfa_sm_set_state(bfad, bfad_sm_operational);
 320		break;
 321
 322	case BFAD_E_STOP:
 323		bfa_sm_set_state(bfad, bfad_sm_fcs_exit);
 324		bfa_sm_send_event(bfad, BFAD_E_FCS_EXIT_COMP);
 325		break;
 326
 327	case BFAD_E_EXIT_COMP:
 328		bfa_sm_set_state(bfad, bfad_sm_uninit);
 329		bfad_remove_intr(bfad);
 330		timer_delete_sync(&bfad->hal_tmo);
 331		break;
 332
 333	default:
 334		bfa_sm_fault(bfad, event);
 335	}
 336}
 337
 338static void
 339bfad_sm_operational(struct bfad_s *bfad, enum bfad_sm_event event)
 340{
 341	bfa_trc(bfad, event);
 342
 343	switch (event) {
 344	case BFAD_E_STOP:
 345		bfa_sm_set_state(bfad, bfad_sm_fcs_exit);
 346		bfad_fcs_stop(bfad);
 347		break;
 348
 349	default:
 350		bfa_sm_fault(bfad, event);
 351	}
 352}
 353
 354static void
 355bfad_sm_fcs_exit(struct bfad_s *bfad, enum bfad_sm_event event)
 356{
 357	bfa_trc(bfad, event);
 358
 359	switch (event) {
 360	case BFAD_E_FCS_EXIT_COMP:
 361		bfa_sm_set_state(bfad, bfad_sm_stopping);
 362		bfad_stop(bfad);
 363		break;
 364
 365	default:
 366		bfa_sm_fault(bfad, event);
 367	}
 368}
 369
 370static void
 371bfad_sm_stopping(struct bfad_s *bfad, enum bfad_sm_event event)
 372{
 373	bfa_trc(bfad, event);
 374
 375	switch (event) {
 376	case BFAD_E_EXIT_COMP:
 377		bfa_sm_set_state(bfad, bfad_sm_uninit);
 378		bfad_remove_intr(bfad);
 379		timer_delete_sync(&bfad->hal_tmo);
 380		bfad_im_probe_undo(bfad);
 381		bfad->bfad_flags &= ~BFAD_FC4_PROBE_DONE;
 382		bfad_uncfg_pport(bfad);
 383		break;
 384
 385	default:
 386		bfa_sm_fault(bfad, event);
 387		break;
 388	}
 389}
 390
 391/*
 392 *  BFA callbacks
 393 */
 394void
 395bfad_hcb_comp(void *arg, bfa_status_t status)
 396{
 397	struct bfad_hal_comp *fcomp = (struct bfad_hal_comp *)arg;
 398
 399	fcomp->status = status;
 400	complete(&fcomp->comp);
 401}
 402
 403/*
 404 * bfa_init callback
 405 */
 406void
 407bfa_cb_init(void *drv, bfa_status_t init_status)
 408{
 409	struct bfad_s	      *bfad = drv;
 410
 411	if (init_status == BFA_STATUS_OK) {
 412		bfad->bfad_flags |= BFAD_HAL_INIT_DONE;
 413
 414		/*
 415		 * If BFAD_HAL_INIT_FAIL flag is set:
 416		 * Wake up the kernel thread to start
 417		 * the bfad operations after HAL init done
 418		 */
 419		if ((bfad->bfad_flags & BFAD_HAL_INIT_FAIL)) {
 420			bfad->bfad_flags &= ~BFAD_HAL_INIT_FAIL;
 421			wake_up_process(bfad->bfad_tsk);
 422		}
 423	}
 424
 425	complete(&bfad->comp);
 426}
 427
 428/*
 429 *  BFA_FCS callbacks
 430 */
 431struct bfad_port_s *
 432bfa_fcb_lport_new(struct bfad_s *bfad, struct bfa_fcs_lport_s *port,
 433		 enum bfa_lport_role roles, struct bfad_vf_s *vf_drv,
 434		 struct bfad_vport_s *vp_drv)
 435{
 436	bfa_status_t	rc;
 437	struct bfad_port_s    *port_drv;
 438
 439	if (!vp_drv && !vf_drv) {
 440		port_drv = &bfad->pport;
 441		port_drv->pvb_type = BFAD_PORT_PHYS_BASE;
 442	} else if (!vp_drv && vf_drv) {
 443		port_drv = &vf_drv->base_port;
 444		port_drv->pvb_type = BFAD_PORT_VF_BASE;
 445	} else if (vp_drv && !vf_drv) {
 446		port_drv = &vp_drv->drv_port;
 447		port_drv->pvb_type = BFAD_PORT_PHYS_VPORT;
 448	} else {
 449		port_drv = &vp_drv->drv_port;
 450		port_drv->pvb_type = BFAD_PORT_VF_VPORT;
 451	}
 452
 453	port_drv->fcs_port = port;
 454	port_drv->roles = roles;
 455
 456	if (roles & BFA_LPORT_ROLE_FCP_IM) {
 457		rc = bfad_im_port_new(bfad, port_drv);
 458		if (rc != BFA_STATUS_OK) {
 459			bfad_im_port_delete(bfad, port_drv);
 460			port_drv = NULL;
 461		}
 462	}
 463
 464	return port_drv;
 465}
 466
 467/*
 468 * FCS RPORT alloc callback, after successful PLOGI by FCS
 469 */
 470bfa_status_t
 471bfa_fcb_rport_alloc(struct bfad_s *bfad, struct bfa_fcs_rport_s **rport,
 472		    struct bfad_rport_s **rport_drv)
 473{
 474	bfa_status_t	rc = BFA_STATUS_OK;
 475
 476	*rport_drv = kzalloc(sizeof(struct bfad_rport_s), GFP_ATOMIC);
 477	if (*rport_drv == NULL) {
 478		rc = BFA_STATUS_ENOMEM;
 479		goto ext;
 480	}
 481
 482	*rport = &(*rport_drv)->fcs_rport;
 483
 484ext:
 485	return rc;
 486}
 487
 488/*
 489 * FCS PBC VPORT Create
 490 */
 491void
 492bfa_fcb_pbc_vport_create(struct bfad_s *bfad, struct bfi_pbc_vport_s pbc_vport)
 493{
 494
 495	struct bfa_lport_cfg_s port_cfg = {0};
 496	struct bfad_vport_s   *vport;
 497	int rc;
 498
 499	vport = kzalloc(sizeof(struct bfad_vport_s), GFP_ATOMIC);
 500	if (!vport) {
 501		bfa_trc(bfad, 0);
 502		return;
 503	}
 504
 505	vport->drv_port.bfad = bfad;
 506	port_cfg.roles = BFA_LPORT_ROLE_FCP_IM;
 507	port_cfg.pwwn = pbc_vport.vp_pwwn;
 508	port_cfg.nwwn = pbc_vport.vp_nwwn;
 509	port_cfg.preboot_vp  = BFA_TRUE;
 510
 511	rc = bfa_fcs_pbc_vport_create(&vport->fcs_vport, &bfad->bfa_fcs, 0,
 512				  &port_cfg, vport);
 513
 514	if (rc != BFA_STATUS_OK) {
 515		bfa_trc(bfad, 0);
 516		return;
 517	}
 518
 519	list_add_tail(&vport->list_entry, &bfad->pbc_vport_list);
 520}
 521
 522void
 523bfad_hal_mem_release(struct bfad_s *bfad)
 524{
 525	struct bfa_meminfo_s *hal_meminfo = &bfad->meminfo;
 526	struct bfa_mem_dma_s *dma_info, *dma_elem;
 527	struct bfa_mem_kva_s *kva_info, *kva_elem;
 528	struct list_head *dm_qe, *km_qe;
 529
 530	dma_info = &hal_meminfo->dma_info;
 531	kva_info = &hal_meminfo->kva_info;
 532
 533	/* Iterate through the KVA meminfo queue */
 534	list_for_each(km_qe, &kva_info->qe) {
 535		kva_elem = (struct bfa_mem_kva_s *) km_qe;
 536		vfree(kva_elem->kva);
 537	}
 538
 539	/* Iterate through the DMA meminfo queue */
 540	list_for_each(dm_qe, &dma_info->qe) {
 541		dma_elem = (struct bfa_mem_dma_s *) dm_qe;
 542		dma_free_coherent(&bfad->pcidev->dev,
 543				dma_elem->mem_len, dma_elem->kva,
 544				(dma_addr_t) dma_elem->dma);
 545	}
 546
 547	memset(hal_meminfo, 0, sizeof(struct bfa_meminfo_s));
 548}
 549
 550void
 551bfad_update_hal_cfg(struct bfa_iocfc_cfg_s *bfa_cfg)
 552{
 553	if (num_rports > 0)
 554		bfa_cfg->fwcfg.num_rports = num_rports;
 555	if (num_ios > 0)
 556		bfa_cfg->fwcfg.num_ioim_reqs = num_ios;
 557	if (num_tms > 0)
 558		bfa_cfg->fwcfg.num_tskim_reqs = num_tms;
 559	if (num_fcxps > 0 && num_fcxps <= BFA_FCXP_MAX)
 560		bfa_cfg->fwcfg.num_fcxp_reqs = num_fcxps;
 561	if (num_ufbufs > 0 && num_ufbufs <= BFA_UF_MAX)
 562		bfa_cfg->fwcfg.num_uf_bufs = num_ufbufs;
 563	if (reqq_size > 0)
 564		bfa_cfg->drvcfg.num_reqq_elems = reqq_size;
 565	if (rspq_size > 0)
 566		bfa_cfg->drvcfg.num_rspq_elems = rspq_size;
 567	if (num_sgpgs > 0 && num_sgpgs <= BFA_SGPG_MAX)
 568		bfa_cfg->drvcfg.num_sgpgs = num_sgpgs;
 569
 570	/*
 571	 * populate the hal values back to the driver for sysfs use.
 572	 * otherwise, the default values will be shown as 0 in sysfs
 573	 */
 574	num_rports = bfa_cfg->fwcfg.num_rports;
 575	num_ios = bfa_cfg->fwcfg.num_ioim_reqs;
 576	num_tms = bfa_cfg->fwcfg.num_tskim_reqs;
 577	num_fcxps = bfa_cfg->fwcfg.num_fcxp_reqs;
 578	num_ufbufs = bfa_cfg->fwcfg.num_uf_bufs;
 579	reqq_size = bfa_cfg->drvcfg.num_reqq_elems;
 580	rspq_size = bfa_cfg->drvcfg.num_rspq_elems;
 581	num_sgpgs = bfa_cfg->drvcfg.num_sgpgs;
 582}
 583
 584bfa_status_t
 585bfad_hal_mem_alloc(struct bfad_s *bfad)
 586{
 587	struct bfa_meminfo_s *hal_meminfo = &bfad->meminfo;
 588	struct bfa_mem_dma_s *dma_info, *dma_elem;
 589	struct bfa_mem_kva_s *kva_info, *kva_elem;
 590	struct list_head *dm_qe, *km_qe;
 591	bfa_status_t	rc = BFA_STATUS_OK;
 592	dma_addr_t	phys_addr;
 593
 594	bfa_cfg_get_default(&bfad->ioc_cfg);
 595	bfad_update_hal_cfg(&bfad->ioc_cfg);
 596	bfad->cfg_data.ioc_queue_depth = bfad->ioc_cfg.fwcfg.num_ioim_reqs;
 597	bfa_cfg_get_meminfo(&bfad->ioc_cfg, hal_meminfo, &bfad->bfa);
 598
 599	dma_info = &hal_meminfo->dma_info;
 600	kva_info = &hal_meminfo->kva_info;
 601
 602	/* Iterate through the KVA meminfo queue */
 603	list_for_each(km_qe, &kva_info->qe) {
 604		kva_elem = (struct bfa_mem_kva_s *) km_qe;
 605		kva_elem->kva = vzalloc(kva_elem->mem_len);
 606		if (kva_elem->kva == NULL) {
 607			bfad_hal_mem_release(bfad);
 608			rc = BFA_STATUS_ENOMEM;
 609			goto ext;
 610		}
 611	}
 612
 613	/* Iterate through the DMA meminfo queue */
 614	list_for_each(dm_qe, &dma_info->qe) {
 615		dma_elem = (struct bfa_mem_dma_s *) dm_qe;
 616		dma_elem->kva = dma_alloc_coherent(&bfad->pcidev->dev,
 617						dma_elem->mem_len,
 618						&phys_addr, GFP_KERNEL);
 619		if (dma_elem->kva == NULL) {
 620			bfad_hal_mem_release(bfad);
 621			rc = BFA_STATUS_ENOMEM;
 622			goto ext;
 623		}
 624		dma_elem->dma = phys_addr;
 625		memset(dma_elem->kva, 0, dma_elem->mem_len);
 626	}
 627ext:
 628	return rc;
 629}
 630
 631/*
 632 * Create a vport under a vf.
 633 */
 634bfa_status_t
 635bfad_vport_create(struct bfad_s *bfad, u16 vf_id,
 636		  struct bfa_lport_cfg_s *port_cfg, struct device *dev)
 637{
 638	struct bfad_vport_s   *vport;
 639	int		rc = BFA_STATUS_OK;
 640	unsigned long	flags;
 641	struct completion fcomp;
 642
 643	vport = kzalloc(sizeof(struct bfad_vport_s), GFP_KERNEL);
 644	if (!vport) {
 645		rc = BFA_STATUS_ENOMEM;
 646		goto ext;
 647	}
 648
 649	vport->drv_port.bfad = bfad;
 650	spin_lock_irqsave(&bfad->bfad_lock, flags);
 651	rc = bfa_fcs_vport_create(&vport->fcs_vport, &bfad->bfa_fcs, vf_id,
 652				  port_cfg, vport);
 653	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 654
 655	if (rc != BFA_STATUS_OK)
 656		goto ext_free_vport;
 657
 658	if (port_cfg->roles & BFA_LPORT_ROLE_FCP_IM) {
 659		rc = bfad_im_scsi_host_alloc(bfad, vport->drv_port.im_port,
 660							dev);
 661		if (rc != BFA_STATUS_OK)
 662			goto ext_free_fcs_vport;
 663	}
 664
 665	spin_lock_irqsave(&bfad->bfad_lock, flags);
 666	bfa_fcs_vport_start(&vport->fcs_vport);
 667	list_add_tail(&vport->list_entry, &bfad->vport_list);
 668	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 669
 670	return BFA_STATUS_OK;
 671
 672ext_free_fcs_vport:
 673	spin_lock_irqsave(&bfad->bfad_lock, flags);
 674	vport->comp_del = &fcomp;
 675	init_completion(vport->comp_del);
 676	bfa_fcs_vport_delete(&vport->fcs_vport);
 677	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 678	wait_for_completion(vport->comp_del);
 679ext_free_vport:
 680	kfree(vport);
 681ext:
 682	return rc;
 683}
 684
 685void
 686bfad_bfa_tmo(struct timer_list *t)
 687{
 688	struct bfad_s	      *bfad = timer_container_of(bfad, t,
 689							      hal_tmo);
 690	unsigned long	flags;
 691	struct list_head	       doneq;
 692
 693	spin_lock_irqsave(&bfad->bfad_lock, flags);
 694
 695	bfa_timer_beat(&bfad->bfa.timer_mod);
 696
 697	bfa_comp_deq(&bfad->bfa, &doneq);
 698	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 699
 700	if (!list_empty(&doneq)) {
 701		bfa_comp_process(&bfad->bfa, &doneq);
 702		spin_lock_irqsave(&bfad->bfad_lock, flags);
 703		bfa_comp_free(&bfad->bfa, &doneq);
 704		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 705	}
 706
 707	mod_timer(&bfad->hal_tmo,
 708		  jiffies + msecs_to_jiffies(BFA_TIMER_FREQ));
 709}
 710
 711void
 712bfad_init_timer(struct bfad_s *bfad)
 713{
 714	timer_setup(&bfad->hal_tmo, bfad_bfa_tmo, 0);
 715
 716	mod_timer(&bfad->hal_tmo,
 717		  jiffies + msecs_to_jiffies(BFA_TIMER_FREQ));
 718}
 719
 720int
 721bfad_pci_init(struct pci_dev *pdev, struct bfad_s *bfad)
 722{
 723	int rc = -ENODEV;
 724
 725	if (pci_enable_device(pdev)) {
 726		printk(KERN_ERR "pci_enable_device fail %p\n", pdev);
 727		goto out;
 728	}
 729
 730	if (pci_request_regions(pdev, BFAD_DRIVER_NAME))
 731		goto out_disable_device;
 732
 733	pci_set_master(pdev);
 734
 735	rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
 736	if (rc) {
 737		rc = -ENODEV;
 738		printk(KERN_ERR "dma_set_mask_and_coherent fail %p\n", pdev);
 739		goto out_release_region;
 740	}
 741
 742	bfad->pci_bar0_kva = pci_iomap(pdev, 0, pci_resource_len(pdev, 0));
 743	bfad->pci_bar2_kva = pci_iomap(pdev, 2, pci_resource_len(pdev, 2));
 744
 745	if (bfad->pci_bar0_kva == NULL) {
 746		printk(KERN_ERR "Fail to map bar0\n");
 747		rc = -ENODEV;
 748		goto out_release_region;
 749	}
 750
 751	bfad->hal_pcidev.pci_slot = PCI_SLOT(pdev->devfn);
 752	bfad->hal_pcidev.pci_func = PCI_FUNC(pdev->devfn);
 753	bfad->hal_pcidev.pci_bar_kva = bfad->pci_bar0_kva;
 754	bfad->hal_pcidev.device_id = pdev->device;
 755	bfad->hal_pcidev.ssid = pdev->subsystem_device;
 756	bfad->pci_name = pci_name(pdev);
 757
 758	bfad->pci_attr.vendor_id = pdev->vendor;
 759	bfad->pci_attr.device_id = pdev->device;
 760	bfad->pci_attr.ssid = pdev->subsystem_device;
 761	bfad->pci_attr.ssvid = pdev->subsystem_vendor;
 762	bfad->pci_attr.pcifn = PCI_FUNC(pdev->devfn);
 763
 764	bfad->pcidev = pdev;
 765
 766	/* Adjust PCIe Maximum Read Request Size */
 767	if (pci_is_pcie(pdev) && pcie_max_read_reqsz) {
 768		if (pcie_max_read_reqsz >= 128 &&
 769		    pcie_max_read_reqsz <= 4096 &&
 770		    is_power_of_2(pcie_max_read_reqsz)) {
 771			int max_rq = pcie_get_readrq(pdev);
 772			printk(KERN_WARNING "BFA[%s]: "
 773				"pcie_max_read_request_size is %d, "
 774				"reset to %d\n", bfad->pci_name, max_rq,
 775				pcie_max_read_reqsz);
 776			pcie_set_readrq(pdev, pcie_max_read_reqsz);
 777		} else {
 778			printk(KERN_WARNING "BFA[%s]: invalid "
 779			       "pcie_max_read_request_size %d ignored\n",
 780			       bfad->pci_name, pcie_max_read_reqsz);
 781		}
 782	}
 783
 784	pci_save_state(pdev);
 785
 786	return 0;
 787
 788out_release_region:
 789	pci_release_regions(pdev);
 790out_disable_device:
 791	pci_disable_device(pdev);
 792out:
 793	return rc;
 794}
 795
 796void
 797bfad_pci_uninit(struct pci_dev *pdev, struct bfad_s *bfad)
 798{
 799	pci_iounmap(pdev, bfad->pci_bar0_kva);
 800	pci_iounmap(pdev, bfad->pci_bar2_kva);
 801	pci_release_regions(pdev);
 802	pci_disable_device(pdev);
 803}
 804
 805bfa_status_t
 806bfad_drv_init(struct bfad_s *bfad)
 807{
 808	bfa_status_t	rc;
 809	unsigned long	flags;
 810
 811	bfad->cfg_data.rport_del_timeout = rport_del_timeout;
 812	bfad->cfg_data.lun_queue_depth = bfa_lun_queue_depth;
 813	bfad->cfg_data.io_max_sge = bfa_io_max_sge;
 814	bfad->cfg_data.binding_method = FCP_PWWN_BINDING;
 815
 816	rc = bfad_hal_mem_alloc(bfad);
 817	if (rc != BFA_STATUS_OK) {
 818		printk(KERN_WARNING "bfad%d bfad_hal_mem_alloc failure\n",
 819		       bfad->inst_no);
 820		printk(KERN_WARNING
 821			"Not enough memory to attach all QLogic BR-series HBA ports. System may need more memory.\n");
 822		return BFA_STATUS_FAILED;
 823	}
 824
 825	bfad->bfa.trcmod = bfad->trcmod;
 826	bfad->bfa.plog = &bfad->plog_buf;
 827	bfa_plog_init(&bfad->plog_buf);
 828	bfa_plog_str(&bfad->plog_buf, BFA_PL_MID_DRVR, BFA_PL_EID_DRIVER_START,
 829		     0, "Driver Attach");
 830
 831	bfa_attach(&bfad->bfa, bfad, &bfad->ioc_cfg, &bfad->meminfo,
 832		   &bfad->hal_pcidev);
 833
 834	/* FCS INIT */
 835	spin_lock_irqsave(&bfad->bfad_lock, flags);
 836	bfad->bfa_fcs.trcmod = bfad->trcmod;
 837	bfa_fcs_attach(&bfad->bfa_fcs, &bfad->bfa, bfad, BFA_FALSE);
 838	bfad->bfa_fcs.fdmi_enabled = fdmi_enable;
 839	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 840
 841	bfad->bfad_flags |= BFAD_DRV_INIT_DONE;
 842
 843	return BFA_STATUS_OK;
 844}
 845
 846void
 847bfad_drv_start(struct bfad_s *bfad)
 848{
 849	unsigned long	flags;
 850
 851	spin_lock_irqsave(&bfad->bfad_lock, flags);
 852	bfa_iocfc_start(&bfad->bfa);
 853	bfa_fcs_pbc_vport_init(&bfad->bfa_fcs);
 854	bfa_fcs_fabric_modstart(&bfad->bfa_fcs);
 855	bfad->bfad_flags |= BFAD_HAL_START_DONE;
 856	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 857
 858	if (bfad->im)
 859		flush_workqueue(bfad->im->drv_workq);
 860}
 861
 862void
 863bfad_fcs_stop(struct bfad_s *bfad)
 864{
 865	unsigned long	flags;
 866
 867	spin_lock_irqsave(&bfad->bfad_lock, flags);
 868	init_completion(&bfad->comp);
 869	bfad->pport.flags |= BFAD_PORT_DELETE;
 870	bfa_fcs_exit(&bfad->bfa_fcs);
 871	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 872	wait_for_completion(&bfad->comp);
 873
 874	bfa_sm_send_event(bfad, BFAD_E_FCS_EXIT_COMP);
 875}
 876
 877void
 878bfad_stop(struct bfad_s *bfad)
 879{
 880	unsigned long	flags;
 881
 882	spin_lock_irqsave(&bfad->bfad_lock, flags);
 883	init_completion(&bfad->comp);
 884	bfa_iocfc_stop(&bfad->bfa);
 885	bfad->bfad_flags &= ~BFAD_HAL_START_DONE;
 886	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 887	wait_for_completion(&bfad->comp);
 888
 889	bfa_sm_send_event(bfad, BFAD_E_EXIT_COMP);
 890}
 891
 892bfa_status_t
 893bfad_cfg_pport(struct bfad_s *bfad, enum bfa_lport_role role)
 894{
 895	int		rc = BFA_STATUS_OK;
 896
 897	/* Allocate scsi_host for the physical port */
 898	if ((supported_fc4s & BFA_LPORT_ROLE_FCP_IM) &&
 899	    (role & BFA_LPORT_ROLE_FCP_IM)) {
 900		if (bfad->pport.im_port == NULL) {
 901			rc = BFA_STATUS_FAILED;
 902			goto out;
 903		}
 904
 905		rc = bfad_im_scsi_host_alloc(bfad, bfad->pport.im_port,
 906						&bfad->pcidev->dev);
 907		if (rc != BFA_STATUS_OK)
 908			goto out;
 909
 910		bfad->pport.roles |= BFA_LPORT_ROLE_FCP_IM;
 911	}
 912
 913	bfad->bfad_flags |= BFAD_CFG_PPORT_DONE;
 914
 915out:
 916	return rc;
 917}
 918
 919void
 920bfad_uncfg_pport(struct bfad_s *bfad)
 921{
 922	if ((supported_fc4s & BFA_LPORT_ROLE_FCP_IM) &&
 923	    (bfad->pport.roles & BFA_LPORT_ROLE_FCP_IM)) {
 924		bfad_im_scsi_host_free(bfad, bfad->pport.im_port);
 925		bfad_im_port_clean(bfad->pport.im_port);
 926		kfree(bfad->pport.im_port);
 927		bfad->pport.roles &= ~BFA_LPORT_ROLE_FCP_IM;
 928	}
 929
 930	bfad->bfad_flags &= ~BFAD_CFG_PPORT_DONE;
 931}
 932
 933bfa_status_t
 934bfad_start_ops(struct bfad_s *bfad) {
 935
 936	int	retval;
 937	unsigned long	flags;
 938	struct bfad_vport_s *vport, *vport_new;
 939	struct bfa_fcs_driver_info_s driver_info;
 940
 941	/* Limit min/max. xfer size to [64k-32MB] */
 942	if (max_xfer_size < BFAD_MIN_SECTORS >> 1)
 943		max_xfer_size = BFAD_MIN_SECTORS >> 1;
 944	if (max_xfer_size > BFAD_MAX_SECTORS >> 1)
 945		max_xfer_size = BFAD_MAX_SECTORS >> 1;
 946
 947	/* Fill the driver_info info to fcs*/
 948	memset(&driver_info, 0, sizeof(driver_info));
 949	strscpy(driver_info.version, BFAD_DRIVER_VERSION,
 950		sizeof(driver_info.version));
 951	if (host_name)
 952		strscpy(driver_info.host_machine_name, host_name,
 953			sizeof(driver_info.host_machine_name));
 954	if (os_name)
 955		strscpy(driver_info.host_os_name, os_name,
 956			sizeof(driver_info.host_os_name));
 957	if (os_patch)
 958		strscpy(driver_info.host_os_patch, os_patch,
 959			sizeof(driver_info.host_os_patch));
 960
 961	strscpy(driver_info.os_device_name, bfad->pci_name,
 962		sizeof(driver_info.os_device_name));
 963
 964	/* FCS driver info init */
 965	spin_lock_irqsave(&bfad->bfad_lock, flags);
 966	bfa_fcs_driver_info_init(&bfad->bfa_fcs, &driver_info);
 967
 968	if (bfad->bfad_flags & BFAD_CFG_PPORT_DONE)
 969		bfa_fcs_update_cfg(&bfad->bfa_fcs);
 970	else
 971		bfa_fcs_init(&bfad->bfa_fcs);
 972
 973	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 974
 975	if (!(bfad->bfad_flags & BFAD_CFG_PPORT_DONE)) {
 976		retval = bfad_cfg_pport(bfad, BFA_LPORT_ROLE_FCP_IM);
 977		if (retval != BFA_STATUS_OK)
 978			return BFA_STATUS_FAILED;
 979	}
 980
 981	/* Setup fc host fixed attribute if the lk supports */
 982	bfad_fc_host_init(bfad->pport.im_port);
 983
 984	/* BFAD level FC4 IM specific resource allocation */
 985	retval = bfad_im_probe(bfad);
 986	if (retval != BFA_STATUS_OK) {
 987		printk(KERN_WARNING "bfad_im_probe failed\n");
 988		if (bfa_sm_cmp_state(bfad, bfad_sm_initializing))
 989			bfa_sm_set_state(bfad, bfad_sm_failed);
 990		return BFA_STATUS_FAILED;
 991	} else
 992		bfad->bfad_flags |= BFAD_FC4_PROBE_DONE;
 993
 994	bfad_drv_start(bfad);
 995
 996	/* Complete pbc vport create */
 997	list_for_each_entry_safe(vport, vport_new, &bfad->pbc_vport_list,
 998				list_entry) {
 999		struct fc_vport_identifiers vid;
1000		struct fc_vport *fc_vport;
1001		char pwwn_buf[BFA_STRING_32];
1002
1003		memset(&vid, 0, sizeof(vid));
1004		vid.roles = FC_PORT_ROLE_FCP_INITIATOR;
1005		vid.vport_type = FC_PORTTYPE_NPIV;
1006		vid.disable = false;
1007		vid.node_name = wwn_to_u64((u8 *)
1008				(&((vport->fcs_vport).lport.port_cfg.nwwn)));
1009		vid.port_name = wwn_to_u64((u8 *)
1010				(&((vport->fcs_vport).lport.port_cfg.pwwn)));
1011		fc_vport = fc_vport_create(bfad->pport.im_port->shost, 0, &vid);
1012		if (!fc_vport) {
1013			wwn2str(pwwn_buf, vid.port_name);
1014			printk(KERN_WARNING "bfad%d: failed to create pbc vport"
1015				" %s\n", bfad->inst_no, pwwn_buf);
1016		}
1017		list_del(&vport->list_entry);
1018		kfree(vport);
1019	}
1020
1021	/*
1022	 * If bfa_linkup_delay is set to -1 default; try to retrive the
1023	 * value using the bfad_get_linkup_delay(); else use the
1024	 * passed in module param value as the bfa_linkup_delay.
1025	 */
1026	if (bfa_linkup_delay < 0) {
1027		bfa_linkup_delay = bfad_get_linkup_delay(bfad);
1028		bfad_rport_online_wait(bfad);
1029		bfa_linkup_delay = -1;
1030	} else
1031		bfad_rport_online_wait(bfad);
1032
1033	BFA_LOG(KERN_INFO, bfad, bfa_log_level, "bfa device claimed\n");
1034
1035	return BFA_STATUS_OK;
1036}
1037
1038int
1039bfad_worker(void *ptr)
1040{
1041	struct bfad_s *bfad = ptr;
1042	unsigned long flags;
1043
1044	if (kthread_should_stop())
1045		return 0;
1046
1047	/* Send event BFAD_E_INIT_SUCCESS */
1048	bfa_sm_send_event(bfad, BFAD_E_INIT_SUCCESS);
1049
1050	spin_lock_irqsave(&bfad->bfad_lock, flags);
1051	bfad->bfad_tsk = NULL;
1052	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1053
1054	return 0;
1055}
1056
1057/*
1058 *  BFA driver interrupt functions
1059 */
1060irqreturn_t
1061bfad_intx(int irq, void *dev_id)
1062{
1063	struct bfad_s	*bfad = dev_id;
1064	struct list_head	doneq;
1065	unsigned long	flags;
1066	bfa_boolean_t rc;
1067
1068	spin_lock_irqsave(&bfad->bfad_lock, flags);
1069	rc = bfa_intx(&bfad->bfa);
1070	if (!rc) {
1071		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1072		return IRQ_NONE;
1073	}
1074
1075	bfa_comp_deq(&bfad->bfa, &doneq);
1076	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1077
1078	if (!list_empty(&doneq)) {
1079		bfa_comp_process(&bfad->bfa, &doneq);
1080
1081		spin_lock_irqsave(&bfad->bfad_lock, flags);
1082		bfa_comp_free(&bfad->bfa, &doneq);
1083		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1084	}
1085
1086	return IRQ_HANDLED;
1087
1088}
1089
1090static irqreturn_t
1091bfad_msix(int irq, void *dev_id)
1092{
1093	struct bfad_msix_s *vec = dev_id;
1094	struct bfad_s *bfad = vec->bfad;
1095	struct list_head doneq;
1096	unsigned long   flags;
1097
1098	spin_lock_irqsave(&bfad->bfad_lock, flags);
1099
1100	bfa_msix(&bfad->bfa, vec->msix.entry);
1101	bfa_comp_deq(&bfad->bfa, &doneq);
1102	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1103
1104	if (!list_empty(&doneq)) {
1105		bfa_comp_process(&bfad->bfa, &doneq);
1106
1107		spin_lock_irqsave(&bfad->bfad_lock, flags);
1108		bfa_comp_free(&bfad->bfa, &doneq);
1109		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1110	}
1111
1112	return IRQ_HANDLED;
1113}
1114
1115/*
1116 * Initialize the MSIX entry table.
1117 */
1118static void
1119bfad_init_msix_entry(struct bfad_s *bfad, struct msix_entry *msix_entries,
1120			 int mask, int max_bit)
1121{
1122	int	i;
1123	int	match = 0x00000001;
1124
1125	for (i = 0, bfad->nvec = 0; i < MAX_MSIX_ENTRY; i++) {
1126		if (mask & match) {
1127			bfad->msix_tab[bfad->nvec].msix.entry = i;
1128			bfad->msix_tab[bfad->nvec].bfad = bfad;
1129			msix_entries[bfad->nvec].entry = i;
1130			bfad->nvec++;
1131		}
1132
1133		match <<= 1;
1134	}
1135
1136}
1137
1138int
1139bfad_install_msix_handler(struct bfad_s *bfad)
1140{
1141	int i, error = 0;
1142
1143	for (i = 0; i < bfad->nvec; i++) {
1144		sprintf(bfad->msix_tab[i].name, "bfa-%s-%s",
1145				bfad->pci_name,
1146				((bfa_asic_id_cb(bfad->hal_pcidev.device_id)) ?
1147				msix_name_cb[i] : msix_name_ct[i]));
1148
1149		error = request_irq(bfad->msix_tab[i].msix.vector,
1150				    (irq_handler_t) bfad_msix, 0,
1151				    bfad->msix_tab[i].name, &bfad->msix_tab[i]);
1152		bfa_trc(bfad, i);
1153		bfa_trc(bfad, bfad->msix_tab[i].msix.vector);
1154		if (error) {
1155			int	j;
1156
1157			for (j = 0; j < i; j++)
1158				free_irq(bfad->msix_tab[j].msix.vector,
1159						&bfad->msix_tab[j]);
1160
1161			bfad->bfad_flags &= ~BFAD_MSIX_ON;
1162			pci_disable_msix(bfad->pcidev);
1163
1164			return 1;
1165		}
1166	}
1167
1168	return 0;
1169}
1170
1171/*
1172 * Setup MSIX based interrupt.
1173 */
1174int
1175bfad_setup_intr(struct bfad_s *bfad)
1176{
1177	int error;
1178	u32 mask = 0, i, num_bit = 0, max_bit = 0;
1179	struct msix_entry msix_entries[MAX_MSIX_ENTRY];
1180	struct pci_dev *pdev = bfad->pcidev;
1181	u16	reg;
1182
1183	/* Call BFA to get the msix map for this PCI function.  */
1184	bfa_msix_getvecs(&bfad->bfa, &mask, &num_bit, &max_bit);
1185
1186	/* Set up the msix entry table */
1187	bfad_init_msix_entry(bfad, msix_entries, mask, max_bit);
1188
1189	if ((bfa_asic_id_ctc(pdev->device) && !msix_disable_ct) ||
1190	   (bfa_asic_id_cb(pdev->device) && !msix_disable_cb)) {
1191
1192		error = pci_enable_msix_exact(bfad->pcidev,
1193					      msix_entries, bfad->nvec);
1194		/* In CT1 & CT2, try to allocate just one vector */
1195		if (error == -ENOSPC && bfa_asic_id_ctc(pdev->device)) {
1196			printk(KERN_WARNING "bfa %s: trying one msix "
1197			       "vector failed to allocate %d[%d]\n",
1198			       bfad->pci_name, bfad->nvec, error);
1199			bfad->nvec = 1;
1200			error = pci_enable_msix_exact(bfad->pcidev,
1201						      msix_entries, 1);
1202		}
1203
1204		if (error) {
1205			printk(KERN_WARNING "bfad%d: "
1206			       "pci_enable_msix_exact failed (%d), "
1207			       "use line based.\n",
1208				bfad->inst_no, error);
1209			goto line_based;
1210		}
1211
1212		/* Disable INTX in MSI-X mode */
1213		pci_read_config_word(pdev, PCI_COMMAND, &reg);
1214
1215		if (!(reg & PCI_COMMAND_INTX_DISABLE))
1216			pci_write_config_word(pdev, PCI_COMMAND,
1217				reg | PCI_COMMAND_INTX_DISABLE);
1218
1219		/* Save the vectors */
1220		for (i = 0; i < bfad->nvec; i++) {
1221			bfa_trc(bfad, msix_entries[i].vector);
1222			bfad->msix_tab[i].msix.vector = msix_entries[i].vector;
1223		}
1224
1225		bfa_msix_init(&bfad->bfa, bfad->nvec);
1226
1227		bfad->bfad_flags |= BFAD_MSIX_ON;
1228
1229		return 0;
1230	}
1231
1232line_based:
1233	error = request_irq(bfad->pcidev->irq, (irq_handler_t)bfad_intx,
1234			    BFAD_IRQ_FLAGS, BFAD_DRIVER_NAME, bfad);
1235	if (error)
1236		return error;
1237
1238	bfad->bfad_flags |= BFAD_INTX_ON;
1239
1240	return 0;
1241}
1242
1243void
1244bfad_remove_intr(struct bfad_s *bfad)
1245{
1246	int	i;
1247
1248	if (bfad->bfad_flags & BFAD_MSIX_ON) {
1249		for (i = 0; i < bfad->nvec; i++)
1250			free_irq(bfad->msix_tab[i].msix.vector,
1251					&bfad->msix_tab[i]);
1252
1253		pci_disable_msix(bfad->pcidev);
1254		bfad->bfad_flags &= ~BFAD_MSIX_ON;
1255	} else if (bfad->bfad_flags & BFAD_INTX_ON) {
1256		free_irq(bfad->pcidev->irq, bfad);
1257	}
1258}
1259
1260/*
1261 * PCI probe entry.
1262 */
1263int
1264bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
1265{
1266	struct bfad_s	*bfad;
1267	int		error = -ENODEV, retval, i;
1268
1269	/* For single port cards - only claim function 0 */
1270	if ((pdev->device == BFA_PCI_DEVICE_ID_FC_8G1P) &&
1271		(PCI_FUNC(pdev->devfn) != 0))
1272		return -ENODEV;
1273
1274	bfad = kzalloc(sizeof(struct bfad_s), GFP_KERNEL);
1275	if (!bfad) {
1276		error = -ENOMEM;
1277		goto out;
1278	}
1279
1280	bfad->trcmod = kzalloc(sizeof(struct bfa_trc_mod_s), GFP_KERNEL);
1281	if (!bfad->trcmod) {
1282		printk(KERN_WARNING "Error alloc trace buffer!\n");
1283		error = -ENOMEM;
1284		goto out_alloc_trace_failure;
1285	}
1286
1287	/* TRACE INIT */
1288	bfa_trc_init(bfad->trcmod);
1289	bfa_trc(bfad, bfad_inst);
1290
1291	/* AEN INIT */
1292	INIT_LIST_HEAD(&bfad->free_aen_q);
1293	INIT_LIST_HEAD(&bfad->active_aen_q);
1294	for (i = 0; i < BFA_AEN_MAX_ENTRY; i++)
1295		list_add_tail(&bfad->aen_list[i].qe, &bfad->free_aen_q);
1296
1297	if (!(bfad_load_fwimg(pdev))) {
1298		kfree(bfad->trcmod);
1299		goto out_alloc_trace_failure;
1300	}
1301
1302	retval = bfad_pci_init(pdev, bfad);
1303	if (retval) {
1304		printk(KERN_WARNING "bfad_pci_init failure!\n");
1305		error = retval;
1306		goto out_pci_init_failure;
1307	}
1308
1309	mutex_lock(&bfad_mutex);
1310	bfad->inst_no = bfad_inst++;
1311	list_add_tail(&bfad->list_entry, &bfad_list);
1312	mutex_unlock(&bfad_mutex);
1313
1314	/* Initializing the state machine: State set to uninit */
1315	bfa_sm_set_state(bfad, bfad_sm_uninit);
1316
1317	spin_lock_init(&bfad->bfad_lock);
1318	spin_lock_init(&bfad->bfad_aen_spinlock);
1319
1320	pci_set_drvdata(pdev, bfad);
1321
1322	bfad->ref_count = 0;
1323	bfad->pport.bfad = bfad;
1324	INIT_LIST_HEAD(&bfad->pbc_vport_list);
1325	INIT_LIST_HEAD(&bfad->vport_list);
1326
1327	/* Setup the debugfs node for this bfad */
1328	if (bfa_debugfs_enable)
1329		bfad_debugfs_init(&bfad->pport);
1330
1331	retval = bfad_drv_init(bfad);
1332	if (retval != BFA_STATUS_OK)
1333		goto out_drv_init_failure;
1334
1335	bfa_sm_send_event(bfad, BFAD_E_CREATE);
1336
1337	if (bfa_sm_cmp_state(bfad, bfad_sm_uninit))
1338		goto out_bfad_sm_failure;
1339
1340	return 0;
1341
1342out_bfad_sm_failure:
1343	bfad_hal_mem_release(bfad);
1344out_drv_init_failure:
1345	/* Remove the debugfs node for this bfad */
1346	kfree(bfad->regdata);
1347	bfad_debugfs_exit(&bfad->pport);
1348	mutex_lock(&bfad_mutex);
1349	bfad_inst--;
1350	list_del(&bfad->list_entry);
1351	mutex_unlock(&bfad_mutex);
1352	bfad_pci_uninit(pdev, bfad);
1353out_pci_init_failure:
1354	kfree(bfad->trcmod);
1355out_alloc_trace_failure:
1356	kfree(bfad);
1357out:
1358	return error;
1359}
1360
1361/*
1362 * PCI remove entry.
1363 */
1364void
1365bfad_pci_remove(struct pci_dev *pdev)
1366{
1367	struct bfad_s	      *bfad = pci_get_drvdata(pdev);
1368	unsigned long	flags;
1369
1370	bfa_trc(bfad, bfad->inst_no);
1371
1372	spin_lock_irqsave(&bfad->bfad_lock, flags);
1373	if (bfad->bfad_tsk != NULL) {
1374		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1375		kthread_stop(bfad->bfad_tsk);
1376	} else {
1377		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1378	}
1379
1380	/* Send Event BFAD_E_STOP */
1381	bfa_sm_send_event(bfad, BFAD_E_STOP);
1382
1383	/* Driver detach and dealloc mem */
1384	spin_lock_irqsave(&bfad->bfad_lock, flags);
1385	bfa_detach(&bfad->bfa);
1386	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1387	bfad_hal_mem_release(bfad);
1388
1389	/* Remove the debugfs node for this bfad */
1390	kfree(bfad->regdata);
1391	bfad_debugfs_exit(&bfad->pport);
1392
1393	/* Cleaning the BFAD instance */
1394	mutex_lock(&bfad_mutex);
1395	bfad_inst--;
1396	list_del(&bfad->list_entry);
1397	mutex_unlock(&bfad_mutex);
1398	bfad_pci_uninit(pdev, bfad);
1399
1400	kfree(bfad->trcmod);
1401	kfree(bfad);
1402}
1403
1404/*
1405 * PCI Error Recovery entry, error detected.
1406 */
1407static pci_ers_result_t
1408bfad_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
1409{
1410	struct bfad_s *bfad = pci_get_drvdata(pdev);
1411	unsigned long	flags;
1412	pci_ers_result_t ret = PCI_ERS_RESULT_NONE;
1413
1414	dev_printk(KERN_ERR, &pdev->dev,
1415		   "error detected state: %d - flags: 0x%x\n",
1416		   state, bfad->bfad_flags);
1417
1418	switch (state) {
1419	case pci_channel_io_normal: /* non-fatal error */
1420		spin_lock_irqsave(&bfad->bfad_lock, flags);
1421		bfad->bfad_flags &= ~BFAD_EEH_BUSY;
1422		/* Suspend/fail all bfa operations */
1423		bfa_ioc_suspend(&bfad->bfa.ioc);
1424		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1425		timer_delete_sync(&bfad->hal_tmo);
1426		ret = PCI_ERS_RESULT_CAN_RECOVER;
1427		break;
1428	case pci_channel_io_frozen: /* fatal error */
1429		init_completion(&bfad->comp);
1430		spin_lock_irqsave(&bfad->bfad_lock, flags);
1431		bfad->bfad_flags |= BFAD_EEH_BUSY;
1432		/* Suspend/fail all bfa operations */
1433		bfa_ioc_suspend(&bfad->bfa.ioc);
1434		bfa_fcs_stop(&bfad->bfa_fcs);
1435		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1436		wait_for_completion(&bfad->comp);
1437
1438		bfad_remove_intr(bfad);
1439		timer_delete_sync(&bfad->hal_tmo);
1440		pci_disable_device(pdev);
1441		ret = PCI_ERS_RESULT_NEED_RESET;
1442		break;
1443	case pci_channel_io_perm_failure: /* PCI Card is DEAD */
1444		spin_lock_irqsave(&bfad->bfad_lock, flags);
1445		bfad->bfad_flags |= BFAD_EEH_BUSY |
1446				    BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE;
1447		spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1448
1449		/* If the error_detected handler is called with the reason
1450		 * pci_channel_io_perm_failure - it will subsequently call
1451		 * pci_remove() entry point to remove the pci device from the
1452		 * system - So defer the cleanup to pci_remove(); cleaning up
1453		 * here causes inconsistent state during pci_remove().
1454		 */
1455		ret = PCI_ERS_RESULT_DISCONNECT;
1456		break;
1457	default:
1458		WARN_ON(1);
1459	}
1460
1461	return ret;
1462}
1463
1464static int restart_bfa(struct bfad_s *bfad)
1465{
1466	unsigned long flags;
1467	struct pci_dev *pdev = bfad->pcidev;
1468
1469	bfa_attach(&bfad->bfa, bfad, &bfad->ioc_cfg,
1470		   &bfad->meminfo, &bfad->hal_pcidev);
1471
1472	/* Enable Interrupt and wait bfa_init completion */
1473	if (bfad_setup_intr(bfad)) {
1474		dev_printk(KERN_WARNING, &pdev->dev,
1475			   "%s: bfad_setup_intr failed\n", bfad->pci_name);
1476		bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED);
1477		return -1;
1478	}
1479
1480	init_completion(&bfad->comp);
1481	spin_lock_irqsave(&bfad->bfad_lock, flags);
1482	bfa_iocfc_init(&bfad->bfa);
1483	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1484
1485	/* Set up interrupt handler for each vectors */
1486	if ((bfad->bfad_flags & BFAD_MSIX_ON) &&
1487	    bfad_install_msix_handler(bfad))
1488		dev_printk(KERN_WARNING, &pdev->dev,
1489			   "%s: install_msix failed.\n", bfad->pci_name);
1490
1491	bfad_init_timer(bfad);
1492	wait_for_completion(&bfad->comp);
1493	bfad_drv_start(bfad);
1494
1495	return 0;
1496}
1497
1498/*
1499 * PCI Error Recovery entry, re-initialize the chip.
1500 */
1501static pci_ers_result_t
1502bfad_pci_slot_reset(struct pci_dev *pdev)
1503{
1504	struct bfad_s *bfad = pci_get_drvdata(pdev);
1505	u8 byte;
1506	int rc;
1507
1508	dev_printk(KERN_ERR, &pdev->dev,
1509		   "bfad_pci_slot_reset flags: 0x%x\n", bfad->bfad_flags);
1510
1511	if (pci_enable_device(pdev)) {
1512		dev_printk(KERN_ERR, &pdev->dev, "Cannot re-enable "
1513			   "PCI device after reset.\n");
1514		return PCI_ERS_RESULT_DISCONNECT;
1515	}
1516
1517	pci_restore_state(pdev);
1518
1519	/*
1520	 * Read some byte (e.g. DMA max. payload size which can't
1521	 * be 0xff any time) to make sure - we did not hit another PCI error
1522	 * in the middle of recovery. If we did, then declare permanent failure.
1523	 */
1524	pci_read_config_byte(pdev, 0x68, &byte);
1525	if (byte == 0xff) {
1526		dev_printk(KERN_ERR, &pdev->dev,
1527			   "slot_reset failed ... got another PCI error !\n");
1528		goto out_disable_device;
1529	}
1530
1531	pci_set_master(pdev);
1532
1533	rc = dma_set_mask_and_coherent(&bfad->pcidev->dev, DMA_BIT_MASK(64));
1534	if (rc)
1535		goto out_disable_device;
1536
1537	if (restart_bfa(bfad) == -1)
1538		goto out_disable_device;
1539
1540	dev_printk(KERN_WARNING, &pdev->dev,
1541		   "slot_reset completed  flags: 0x%x!\n", bfad->bfad_flags);
1542
1543	return PCI_ERS_RESULT_RECOVERED;
1544
1545out_disable_device:
1546	pci_disable_device(pdev);
1547	return PCI_ERS_RESULT_DISCONNECT;
1548}
1549
1550static pci_ers_result_t
1551bfad_pci_mmio_enabled(struct pci_dev *pdev)
1552{
1553	unsigned long	flags;
1554	struct bfad_s *bfad = pci_get_drvdata(pdev);
1555
1556	dev_printk(KERN_INFO, &pdev->dev, "mmio_enabled\n");
1557
1558	/* Fetch FW diagnostic information */
1559	bfa_ioc_debug_save_ftrc(&bfad->bfa.ioc);
1560
1561	/* Cancel all pending IOs */
1562	spin_lock_irqsave(&bfad->bfad_lock, flags);
1563	init_completion(&bfad->comp);
1564	bfa_fcs_stop(&bfad->bfa_fcs);
1565	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1566	wait_for_completion(&bfad->comp);
1567
1568	bfad_remove_intr(bfad);
1569	timer_delete_sync(&bfad->hal_tmo);
1570	pci_disable_device(pdev);
1571
1572	return PCI_ERS_RESULT_NEED_RESET;
1573}
1574
1575static void
1576bfad_pci_resume(struct pci_dev *pdev)
1577{
1578	unsigned long	flags;
1579	struct bfad_s *bfad = pci_get_drvdata(pdev);
1580
1581	dev_printk(KERN_WARNING, &pdev->dev, "resume\n");
1582
1583	/* wait until the link is online */
1584	bfad_rport_online_wait(bfad);
1585
1586	spin_lock_irqsave(&bfad->bfad_lock, flags);
1587	bfad->bfad_flags &= ~BFAD_EEH_BUSY;
1588	spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1589}
1590
1591struct pci_device_id bfad_id_table[] = {
1592	{
1593		.vendor = BFA_PCI_VENDOR_ID_BROCADE,
1594		.device = BFA_PCI_DEVICE_ID_FC_8G2P,
1595		.subvendor = PCI_ANY_ID,
1596		.subdevice = PCI_ANY_ID,
1597	},
1598	{
1599		.vendor = BFA_PCI_VENDOR_ID_BROCADE,
1600		.device = BFA_PCI_DEVICE_ID_FC_8G1P,
1601		.subvendor = PCI_ANY_ID,
1602		.subdevice = PCI_ANY_ID,
1603	},
1604	{
1605		.vendor = BFA_PCI_VENDOR_ID_BROCADE,
1606		.device = BFA_PCI_DEVICE_ID_CT,
1607		.subvendor = PCI_ANY_ID,
1608		.subdevice = PCI_ANY_ID,
1609		.class = (PCI_CLASS_SERIAL_FIBER << 8),
1610		.class_mask = ~0,
1611	},
1612	{
1613		.vendor = BFA_PCI_VENDOR_ID_BROCADE,
1614		.device = BFA_PCI_DEVICE_ID_CT_FC,
1615		.subvendor = PCI_ANY_ID,
1616		.subdevice = PCI_ANY_ID,
1617		.class = (PCI_CLASS_SERIAL_FIBER << 8),
1618		.class_mask = ~0,
1619	},
1620	{
1621		.vendor = BFA_PCI_VENDOR_ID_BROCADE,
1622		.device = BFA_PCI_DEVICE_ID_CT2,
1623		.subvendor = PCI_ANY_ID,
1624		.subdevice = PCI_ANY_ID,
1625		.class = (PCI_CLASS_SERIAL_FIBER << 8),
1626		.class_mask = ~0,
1627	},
1628
1629	{
1630		.vendor = BFA_PCI_VENDOR_ID_BROCADE,
1631		.device = BFA_PCI_DEVICE_ID_CT2_QUAD,
1632		.subvendor = PCI_ANY_ID,
1633		.subdevice = PCI_ANY_ID,
1634		.class = (PCI_CLASS_SERIAL_FIBER << 8),
1635		.class_mask = ~0,
1636	},
1637	{0, 0},
1638};
1639
1640MODULE_DEVICE_TABLE(pci, bfad_id_table);
1641
1642/*
1643 * PCI error recovery handlers.
1644 */
1645static const struct pci_error_handlers bfad_err_handler = {
1646	.error_detected = bfad_pci_error_detected,
1647	.slot_reset = bfad_pci_slot_reset,
1648	.mmio_enabled = bfad_pci_mmio_enabled,
1649	.resume = bfad_pci_resume,
1650};
1651
1652static struct pci_driver bfad_pci_driver = {
1653	.name = BFAD_DRIVER_NAME,
1654	.id_table = bfad_id_table,
1655	.probe = bfad_pci_probe,
1656	.remove = bfad_pci_remove,
1657	.err_handler = &bfad_err_handler,
1658};
1659
1660/*
1661 * Driver module init.
1662 */
1663static int __init
1664bfad_init(void)
1665{
1666	int		error = 0;
1667
1668	pr_info("QLogic BR-series BFA FC/FCOE SCSI driver - version: %s\n",
1669			BFAD_DRIVER_VERSION);
1670
1671	if (num_sgpgs > 0)
1672		num_sgpgs_parm = num_sgpgs;
1673
1674	error = bfad_im_module_init();
1675	if (error) {
1676		printk(KERN_WARNING "bfad_im_module_init failure\n");
1677		return -ENOMEM;
1678	}
1679
1680	if (strcmp(FCPI_NAME, " fcpim") == 0)
1681		supported_fc4s |= BFA_LPORT_ROLE_FCP_IM;
1682
1683	bfa_auto_recover = ioc_auto_recover;
1684	bfa_fcs_rport_set_del_timeout(rport_del_timeout);
1685	bfa_fcs_rport_set_max_logins(max_rport_logins);
1686
1687	error = pci_register_driver(&bfad_pci_driver);
1688	if (error) {
1689		printk(KERN_WARNING "pci_register_driver failure\n");
1690		goto ext;
1691	}
1692
1693	return 0;
1694
1695ext:
1696	bfad_im_module_exit();
1697	return error;
1698}
1699
1700/*
1701 * Driver module exit.
1702 */
1703static void __exit
1704bfad_exit(void)
1705{
1706	pci_unregister_driver(&bfad_pci_driver);
1707	bfad_im_module_exit();
1708	bfad_free_fwimg();
1709}
1710
1711/* Firmware handling */
1712static void
1713bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
1714		u32 *bfi_image_size, char *fw_name)
1715{
1716	const struct firmware *fw;
1717
1718	if (request_firmware(&fw, fw_name, &pdev->dev)) {
1719		printk(KERN_ALERT "Can't locate firmware %s\n", fw_name);
1720		*bfi_image = NULL;
1721		goto out;
1722	}
1723
1724	*bfi_image = vmalloc(fw->size);
1725	if (NULL == *bfi_image) {
1726		printk(KERN_ALERT "Fail to allocate buffer for fw image "
1727			"size=%x!\n", (u32) fw->size);
1728		goto out;
1729	}
1730
1731	memcpy(*bfi_image, fw->data, fw->size);
1732	*bfi_image_size = fw->size/sizeof(u32);
1733out:
1734	release_firmware(fw);
1735}
1736
1737static u32 *
1738bfad_load_fwimg(struct pci_dev *pdev)
1739{
1740	if (bfa_asic_id_ct2(pdev->device)) {
1741		if (bfi_image_ct2_size == 0)
1742			bfad_read_firmware(pdev, &bfi_image_ct2,
1743				&bfi_image_ct2_size, BFAD_FW_FILE_CT2);
1744		return bfi_image_ct2;
1745	} else if (bfa_asic_id_ct(pdev->device)) {
1746		if (bfi_image_ct_size == 0)
1747			bfad_read_firmware(pdev, &bfi_image_ct,
1748				&bfi_image_ct_size, BFAD_FW_FILE_CT);
1749		return bfi_image_ct;
1750	} else if (bfa_asic_id_cb(pdev->device)) {
1751		if (bfi_image_cb_size == 0)
1752			bfad_read_firmware(pdev, &bfi_image_cb,
1753				&bfi_image_cb_size, BFAD_FW_FILE_CB);
1754		return bfi_image_cb;
1755	}
1756
1757	return NULL;
1758}
1759
1760static void
1761bfad_free_fwimg(void)
1762{
1763	if (bfi_image_ct2_size && bfi_image_ct2)
1764		vfree(bfi_image_ct2);
1765	if (bfi_image_ct_size && bfi_image_ct)
1766		vfree(bfi_image_ct);
1767	if (bfi_image_cb_size && bfi_image_cb)
1768		vfree(bfi_image_cb);
1769}
1770
1771module_init(bfad_init);
1772module_exit(bfad_exit);
1773MODULE_LICENSE("GPL");
1774MODULE_DESCRIPTION("QLogic BR-series Fibre Channel HBA Driver" BFAD_PROTO_NAME);
1775MODULE_AUTHOR("QLogic Corporation");
1776MODULE_VERSION(BFAD_DRIVER_VERSION);