/*

 * Copyright (c) 2009-2011, Broadcom Corporation

 * Copyright (c) 2014, QLogic Corporation

 *

 * Written by:  Benjamin Li  (benli@broadcom.com)

 *

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *      This product includes software developed by Adam Dunkels.

 * 4. The name of the author may not be used to endorse or promote

 *    products derived from this software without specific prior

 *    written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS

 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE

 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * bnx2x.c - bnx2x user space driver

 *

 */

/* include nic.h before linux/ethtool.h to avoid redefinitions of

 * eth structs

*/

#include "nic.h"

#include <errno.h>

#include <stdio.h>

#include <string.h>

#include <arpa/inet.h>

#include <linux/types.h>	/* Needed for linux/ethtool.h on RHEL 5.x */

#include <linux/sockios.h>

#include <linux/ethtool.h>

#include <sys/mman.h>

#include <sys/ioctl.h>

#include <sys/sysmacros.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/user.h>

#include <fcntl.h>

#include <unistd.h>

#include "config.h"

#include "build_date.h"

#include "bnx2x.h"

#include "cnic.h"

#include "logger.h"

#include "nic_id.h"

#include "nic_utils.h"

#include "options.h"

#define PFX	"bnx2x "

/*  Foward struct declarations */

struct nic_ops bnx2x_op;

/*******************************************************************************

 * NIC Library Strings

 ******************************************************************************/

static const char library_name[] = "bnx2x";

static const char library_version[] = PACKAGE_VERSION;

static const char library_uio_name[] = "bnx2x_cnic";

/*  The name that should be returned from /sys/class/uio/uio0/name */

static const char cnic_uio_sysfs_name_tempate[] = "/sys/class/uio/uio%i/name";

static const char bnx2x_uio_sysfs_name[] = "bnx2x_cnic";

/*******************************************************************************

 * String constants used to display human readable adapter name

 ******************************************************************************/

static const char brcm_57710[] = "QLogic NetXtreme II BCM57710 10-Gigabit";

static const char brcm_57711[] = "QLogic NetXtreme II BCM57711 10-Gigabit";

static const char brcm_57711e[] = "QLogic NetXtreme II BCM57711E 10-Gigabit";

static const char brcm_57712[] = "QLogic NetXtreme II BCM57712 10-Gigabit";

static const char brcm_57712_MF[] = "QLogic NetXtreme II BCM57712 MF "

				    "10-Gigabit";

static const char brcm_57712_VF[] = "QLogic NetXtreme II BCM57712 VF "

				    "10-Gigabit";

static const char brcm_57713[] = "QLogic NetXtreme II BCM57713 10-Gigabit";

static const char brcm_57713e[] = "QLogic NetXtreme II BCM57713E 10-Gigabit";

static const char brcm_57800[] = "QLogic NetXtreme II BCM57800 10-Gigabit";

static const char brcm_57800_MF[] = "QLogic NetXtreme II BCM57800 MF "

				    "10-Gigabit";

static const char brcm_57800_VF[] = "QLogic NetXtreme II BCM57800 VF "

				    "10-Gigabit";

static const char brcm_57810[] = "QLogic NetXtreme II BCM57810 10-Gigabit";

static const char brcm_57810_MF[] = "QLogic NetXtreme II BCM57810 MF "

				    "10-Gigabit";

static const char brcm_57810_VF[] = "QLogic NetXtreme II BCM57810 VF "

				    "10-Gigabit";

static const char brcm_57811[] = "QLogic NetXtreme II BCM57811 10-Gigabit";

static const char brcm_57811_MF[] = "QLogic NetXtreme II BCM57811 MF "

				    "10-Gigabit";

static const char brcm_57811_VF[] = "QLogic NetXtreme II BCM57811 VF "

				    "10-Gigabit";

static const char brcm_57840[] = "QLogic NetXtreme II BCM57840 10-Gigabit";

static const char brcm_57840_MF[] = "QLogic NetXtreme II BCM57840 MF "

				    "10-Gigabit";

static const char brcm_57840_VF[] = "QLogic NetXtreme II BCM57840 VF "

				    "10-Gigabit";

static const char brcm_57840_4_10[] = "QLogic NetXtreme II BCM57840 4x"

				      "10-Gigabit";

static const char brcm_57840_2_20[] = "QLogic NetXtreme II BCM57840 2x"

				      "20-Gigabit";

/*******************************************************************************

 * PCI ID constants

 ******************************************************************************/

#define PCI_VENDOR_ID_BROADCOM			0x14e4

#define PCI_VENDOR_ID_QLOGIC			0x1077

#define PCI_DEVICE_ID_NX2_57710			0x164e

#define PCI_DEVICE_ID_NX2_57711			0x164f

#define PCI_DEVICE_ID_NX2_57711E		0x1650

#define PCI_DEVICE_ID_NX2_57712			0x1662

#define PCI_DEVICE_ID_NX2_57712_MF		0x1663

#define PCI_DEVICE_ID_NX2_57712_VF		0x166f

#define PCI_DEVICE_ID_NX2_57713			0x1651

#define PCI_DEVICE_ID_NX2_57713E		0x1652

#define PCI_DEVICE_ID_NX2_57800			0x168a

#define PCI_DEVICE_ID_NX2_57800_MF		0x16a5

#define PCI_DEVICE_ID_NX2_57800_VF		0x16a9

#define PCI_DEVICE_ID_NX2_57810			0x168e

#define PCI_DEVICE_ID_NX2_57810_MF		0x16ae

#define PCI_DEVICE_ID_NX2_57810_VF		0x16af

#define PCI_DEVICE_ID_NX2_57811			0x163d

#define PCI_DEVICE_ID_NX2_57811_MF		0x163e

#define PCI_DEVICE_ID_NX2_57811_VF		0x163f

#define PCI_DEVICE_ID_NX2_57840_OBSOLETE	0x168d

#define PCI_DEVICE_ID_NX2_57840_MF_OBSOLETE	0x16ab

#define PCI_DEVICE_ID_NX2_57840_4_10		0x16a1

#define PCI_DEVICE_ID_NX2_57840_2_20		0x16a2

#define PCI_DEVICE_ID_NX2_57840_MF		0x16a4

#define PCI_DEVICE_ID_NX2_57840_VF		0x16ad

#define PCI_ANY_ID (~0)

/*  This is the table used to match PCI vendor and device ID's to the

 *  human readable string names of the devices */

static const struct pci_device_id bnx2x_pci_tbl[] = {

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57710,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57710},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57711,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57711},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57711E,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57711e},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57712,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57712},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57712_MF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57712_MF},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57712_VF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57712_VF},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57713,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57713},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57713E,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57713e},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57800,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57800},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57800_MF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57800_MF},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57800_VF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57800_VF},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57810,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57810},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57810_MF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57810_MF},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57810_VF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57810_VF},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57811,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57811},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57811_MF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57811_MF},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57811_VF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57811_VF},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57840_OBSOLETE,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57840},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57840_MF_OBSOLETE,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57840_MF},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57840_4_10,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57840_4_10},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57840_2_20,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57840_2_20},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57840_MF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57840_MF},

	{PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57840_VF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57840_VF},

	{PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_NX2_57840_4_10,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57840_4_10},

	{PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_NX2_57840_2_20,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57840_2_20},

	{PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_NX2_57840_MF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57840_MF},

	{PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_NX2_57840_VF,

	 PCI_ANY_ID, PCI_ANY_ID, brcm_57840_VF},

};

static struct iro e1_iro[2] = {

	{0x45a0, 0x90, 0x8, 0x0, 0x8},	/* T6.0 */

	{0x50c8, 0x90, 0x8, 0x0, 0x8},	/* T6.4 */

};

static struct iro e1h_iro[2] = {

	{0x1c40, 0xe0, 0x8, 0x0, 0x8},	/* T6.0 */

	{0x1e00, 0xe0, 0x8, 0x0, 0x8},	/* T6.4 */

};

static struct iro e2_iro[2] = {

	{0x6000, 0x20, 0x0, 0x0, 0x8},	/* T6.0 */

	{0x6000, 0x20, 0x0, 0x0, 0x8},	/* T6.4 */

};

struct bnx2x_driver_version bnx2x_version = {

	BNX2X_UNKNOWN_MAJOR_VERSION,

	BNX2X_UNKNOWN_MINOR_VERSION,

	BNX2X_UNKNOWN_SUB_MINOR_VERSION,

};

static int bnx2x_clear_tx_intr(nic_t *nic);

/*******************************************************************************

 * BNX2X Library Functions

 ******************************************************************************/

/**

 *  bnx2x_get_library_name() - Used to get the name of this NIC libary

 *  @param name - This function will return the pointer to this NIC

 *                library name

 *  @param name_size

 */

static void bnx2x_get_library_name(char **name, size_t *name_size)

{

	*name = (char *)library_name;

	*name_size = sizeof(library_name);

}

/**

 *  bnx2x_get_library_version() - Used to get the version string of this

 *                                NIC libary

 *  @param version - This function will return the pointer to this NIC

 *                   library version string

 *  @param version_size - This will be set with the version size

 */

static void bnx2x_get_library_version(char **version, size_t *version_size)

{

	*version = (char *)library_version;

	*version_size = sizeof(library_version);

}

/**

 *  bnx2x_get_build_date() - Used to get the build date string of this library

 *  @param version - This function will return the pointer to this NIC

 *                   library build date string

 *  @param version_size - This will be set with the build date string size

 */

static void bnx2x_get_build_date(char **build, size_t *build_size)

{

	*build = (char *)build_date;

	*build_size = sizeof(build_date);

}

/**

 *  bnx2x_get_transport_name() - Used to get the transport name associated

 *                              with this this NIC libary

 *  @param transport_name - This function will return the pointer to this NIC

 *                          library's associated transport string

 *  @param transport_name_size - This will be set with the transport name size

 */

static void bnx2x_get_transport_name(char **transport_name,

				     size_t *transport_name_size)

{

	*transport_name = (char *)bnx2i_library_transport_name;

	*transport_name_size = bnx2i_library_transport_name_size;

}

/**

 *  bnx2x_get_uio_name() - Used to get the uio name associated with this this

 *                        NIC libary

 *  @param uio_name - This function will return the pointer to this NIC

 *                    library's associated uio string

 *  @param transport_name_size - This will be set with the uio name size

 */

static void bnx2x_get_uio_name(char **uio_name, size_t *uio_name_size)

{

	*uio_name = (char *)library_uio_name;

	*uio_name_size = sizeof(library_uio_name);

}

/**

 *  bnx2x_get_pci_table() - Used to get the PCI table for this NIC libary to

 *			    determine which NIC's based off of PCI ID's are

 *			    supported

 *  @param table - This function will return the pointer to the PCI table

 *  @param entries - This function will return the number of entries in the NIC

 *                   library's PCI table

 */

static void bnx2x_get_pci_table(struct pci_device_id **table,

				uint32_t *entries)

{

	*table = (struct pci_device_id *)bnx2x_pci_tbl;

	*entries =

	    (uint32_t) (sizeof(bnx2x_pci_tbl) / sizeof(bnx2x_pci_tbl[0]));

}

/**

 *  bnx2x_get_ops() - Used to get the NIC library op table

 *  @param op - The op table of this NIC library

 */

struct nic_ops *bnx2x_get_ops()

{

	return &bnx2x_op;

}

/*******************************************************************************

 * bnx2x Utility Functions

 ******************************************************************************/

/*******************************************************************************

 * Utility Functions Used to read register from the bnx2x device

 ******************************************************************************/

static void bnx2x_set_drv_version_unknown(bnx2x_t *bp)

{

	bp->version.major = BNX2X_UNKNOWN_MAJOR_VERSION;

	bp->version.minor = BNX2X_UNKNOWN_MINOR_VERSION;

	bp->version.sub_minor = BNX2X_UNKNOWN_SUB_MINOR_VERSION;

}

/* Return: 1 = Unknown, 0 = Known */

static int bnx2x_is_drv_version_unknown(struct bnx2x_driver_version *version)

{

	if ((version->major == (uint16_t)BNX2X_UNKNOWN_MAJOR_VERSION) &&

	    (version->minor == (uint16_t)BNX2X_UNKNOWN_MINOR_VERSION) &&

	    (version->sub_minor == (uint16_t)BNX2X_UNKNOWN_SUB_MINOR_VERSION)) {

		return 1;

	}

	return 0;

}

/**

 * bnx2x_get_drv_version() - Used to determine the driver version

 * @param bp - Device used to determine bnx2x driver version

 */

static int bnx2x_get_drv_version(bnx2x_t *bp)

{

	nic_t *nic = bp->parent;

	int fd, rc;

	struct ifreq ifr;

	struct ethtool_drvinfo drvinfo;

	char *tok, *save_ptr = NULL;

	/* Setup our control structures. */

	memset(&ifr, 0, sizeof(ifr));

	strcpy(ifr.ifr_name, nic->eth_device_name);

	/* Open control socket. */

	fd = socket(AF_INET, SOCK_DGRAM, 0);

	if (fd < 0) {

		LOG_ERR(PFX "%s: Cannot get socket to determine version "

			"[0x%x %s]", nic->log_name, errno, strerror(errno));

		return -EIO;

	}

	memset(&drvinfo, 0, sizeof(drvinfo));

	drvinfo.cmd = ETHTOOL_GDRVINFO;

	ifr.ifr_data = (caddr_t) &drvinfo;

	rc = ioctl(fd, SIOCETHTOOL, &ifr);

	if (rc < 0) {

		LOG_ERR(PFX "%s: call to ethool IOCTL failed [0x%x %s]",

			nic->log_name, errno, strerror(errno));

		goto error;

	}

	tok = strtok_r(drvinfo.version, ".", &save_ptr);

	if (tok == NULL) {

		rc = -EIO;

		goto error;

	}

	bp->version.major = atoi(tok);

	tok = strtok_r(NULL, ".", &save_ptr);

	if (tok == NULL) {

		rc = -EIO;

		goto error;

	}

	bp->version.minor = atoi(tok);

	tok = strtok_r(NULL, ".", &save_ptr);

	if (tok == NULL) {

		rc = -EIO;

		goto error;

	}

	bp->version.sub_minor = atoi(tok);

	LOG_INFO(PFX "%s: bnx2x driver using version %d.%d.%d",

		 nic->log_name,

		 bp->version.major, bp->version.minor, bp->version.sub_minor);

	close(fd);

	return 0;

error:

	close(fd);

	bnx2x_set_drv_version_unknown(bp);

	LOG_ERR(PFX "%s: error parsing driver string: '%s'",

		nic->log_name, drvinfo.version);

	return rc;

}

static inline int bnx2x_is_ver70(bnx2x_t *bp)

{

	return (bp->version.major == 1 && bp->version.minor >= 70);

}

static inline int bnx2x_is_ver60(bnx2x_t *bp)

{

	return (bp->version.major == 1 && (bp->version.minor == 60 ||

					   bp->version.minor == 62 ||

					   bp->version.minor == 64));

}

static inline int bnx2x_is_ver60_plus(bnx2x_t *bp)

{

	return bnx2x_is_ver60(bp) || bnx2x_is_ver70(bp);

}

static inline int bnx2x_is_ver52(bnx2x_t *bp)

{

	return (bp->version.major == 1 && bp->version.minor == 52);

}

static void bnx2x_wr32(bnx2x_t *bp, __u32 off, __u32 val)

{

	*((volatile __u32 *)(bp->reg + off)) = val;

}

static void bnx2x_doorbell(bnx2x_t *bp, __u32 off, __u32 val)

{

	*((volatile __u32 *)(bp->reg2 + off)) = val;

}

static void bnx2x_flush_doorbell(bnx2x_t *bp, __u32 off)

{

	volatile __u32 tmp __attribute__((__unused__));

	barrier();

	tmp = *((volatile __u32 *)(bp->reg2 + off));

}

static __u32 bnx2x_rd32(bnx2x_t *bp, __u32 off)

{

	return *((volatile __u32 *)(bp->reg + off));

}

static int bnx2x_reg_sync(bnx2x_t *bp, __u32 off, __u16 length)

{

	return msync(bp->reg + off, length, MS_SYNC);

}

static void bnx2x_update_rx_prod(bnx2x_t *bp)

{

	struct ustorm_eth_rx_producers rx_prods = { 0 };

	int i;

	rx_prods.bd_prod = bp->rx_bd_prod;

	rx_prods.cqe_prod = bp->rx_prod;

	barrier();

	for (i = 0; i < sizeof(struct ustorm_eth_rx_producers) / 4; i++)

		bnx2x_wr32(bp, bp->rx_prod_io + i * 4,

			   ((__u32 *)&rx_prods)[i]);

	barrier();

	bnx2x_reg_sync(bp, bp->rx_prod_io,

		       sizeof(struct ustorm_eth_rx_producers));

}

/**

 * bnx2x_get_chip_id() - Used to retrive the chip ID from the nic

 * @param dev - Device used to determin NIC type

 * @return Chip ID read from the MISC ID register

 */

static int bnx2x_get_chip_id(bnx2x_t *bp)

{

	int val, id;

	/* Get the chip revision id and number. */

	/* chip num:16-31, rev:12-15, metal:4-11, bond_id:0-3 */

	val = bnx2x_rd32(bp, BNX2X_MISC_REG_CHIP_NUM);

	id = ((val & 0xffff) << 16);

	val = bnx2x_rd32(bp, BNX2X_MISC_REG_CHIP_REV);

	id |= ((val & 0xf) << 12);

	val = bnx2x_rd32(bp, BNX2X_MISC_REG_CHIP_METAL);

	id |= ((val & 0xff) << 4);

	val = bnx2x_rd32(bp, BNX2X_MISC_REG_BOND_ID);

	id |= (val & 0xf);

	return id;

}

/**

 *  bnx2x_uio_verify()

 *

 */

static int bnx2x_uio_verify(nic_t *nic)

{

	char *raw = NULL, *raw_tmp;

	uint32_t raw_size = 0;

	char temp_path[sizeof(cnic_uio_sysfs_name_tempate) + 8];

	int rc = 0;

	/*  Build the path to determine uio name */

	snprintf(temp_path, sizeof(temp_path),

		 cnic_uio_sysfs_name_tempate, nic->uio_minor);

	rc = capture_file(&raw, &raw_size, temp_path);

	if (rc != 0)

		goto error;

	/* sanitize name string by replacing newline with null termination */

	raw_tmp = raw;

	while (*raw_tmp != '\n')

		raw_tmp++;

	*raw_tmp = '\0';

	if (strncmp(raw, bnx2x_uio_sysfs_name,

		    sizeof(bnx2x_uio_sysfs_name)) != 0) {

		LOG_ERR(PFX "%s: uio names not equal: "

			"expecting %s got %s from %s",

			nic->log_name, bnx2x_uio_sysfs_name, raw, temp_path);

		rc = -EIO;

	}

	free(raw);

	LOG_INFO(PFX "%s: Verified is a cnic_uio device", nic->log_name);

error:

	return rc;

}

/*******************************************************************************

 * bnx2x Utility Functions to get to the hardware consumer indexes

 ******************************************************************************/

static __u16 bnx2x_get_rx(bnx2x_t *bp)

{

	struct host_def_status_block *sblk = bp->status_blk.def;

	__u16 rx_comp_cons;

	msync(sblk, sizeof(*sblk), MS_SYNC);

	rx_comp_cons =

	    sblk->u_def_status_block.

	    index_values[HC_INDEX_DEF_U_ETH_ISCSI_RX_CQ_CONS];

	if ((rx_comp_cons & BNX2X_MAX_RCQ_DESC_CNT(bp)) ==

	    BNX2X_MAX_RCQ_DESC_CNT(bp))

		rx_comp_cons++;

	return rx_comp_cons;

}

static __u16 bnx2x_get_rx_60(bnx2x_t *bp)

{

	struct host_sp_status_block *sblk = bp->status_blk.sp;

	__u16 rx_comp_cons;

	msync(sblk, sizeof(*sblk), MS_SYNC);

	rx_comp_cons =

	    sblk->sp_sb.index_values[HC_SP_INDEX_ETH_ISCSI_RX_CQ_CONS];

	if ((rx_comp_cons & BNX2X_MAX_RCQ_DESC_CNT(bp)) ==

	    BNX2X_MAX_RCQ_DESC_CNT(bp))

		rx_comp_cons++;

	return rx_comp_cons;

}

static __u16 bnx2x_get_tx(bnx2x_t *bp)

{

	struct host_def_status_block *sblk = bp->status_blk.def;

	__u16 tx_cons;

	msync(sblk, sizeof(*sblk), MS_SYNC);

	tx_cons =

	    sblk->c_def_status_block.

	    index_values[HC_INDEX_DEF_C_ETH_ISCSI_CQ_CONS];

	return tx_cons;

}

static __u16 bnx2x_get_tx_60(bnx2x_t *bp)

{

	struct host_sp_status_block *sblk = bp->status_blk.sp;

	__u16 tx_cons;

	msync(sblk, sizeof(*sblk), MS_SYNC);

	tx_cons = sblk->sp_sb.index_values[HC_SP_INDEX_ETH_ISCSI_CQ_CONS];

	return tx_cons;

}

typedef enum {

	CNIC_VLAN_STRIPPING_ENABLED = 1,

	CNIC_VLAN_STRIPPING_DISABLED = 2,

} CNIC_VLAN_STRIPPING_MODE;

/**

 *  bnx2x_strip_vlan_enabled() - This will query the device to determine whether

 *                              VLAN tag stripping is enabled or not

 *  @param dev - device to check stripping or not

 *  @ return CNIC_VLAN_STRIPPING_ENABLED stripping is enabled

 *           CNIC_VLAN_STRIPPING_DISABLED stripping is not enabled

 */

static CNIC_VLAN_STRIPPING_MODE bnx2x_strip_vlan_enabled(bnx2x_t *bp)

{

	return CNIC_VLAN_STRIPPING_DISABLED;

}

/**

 *  bnx2x_free() - Used to free a bnx2x structure

 */

static void bnx2x_free(nic_t *nic)

{

	if (nic->priv)

		free(nic->priv);

	nic->priv = NULL;

}

/**

 *  bnx2x_alloc() - Used to allocate a bnx2x structure

 */

static bnx2x_t *bnx2x_alloc(nic_t *nic)

{

	bnx2x_t *bp = malloc(sizeof(*bp));

	if (bp == NULL) {

		LOG_ERR(PFX "%s: Could not allocate BNX2X space",

			nic->log_name);

		return NULL;

	}

	/*  Clear out the CNIC contents */

	memset(bp, 0, sizeof(*bp));

	bp->bar0_fd = INVALID_FD;

	bp->bar2_fd = INVALID_FD;

	bp->parent = nic;

	nic->priv = (void *)bp;

	bnx2x_set_drv_version_unknown(bp);

	return bp;

}

/**

 * bnx2x_open() - This will initialize all the hardware resources underneath

 *               a struct cnic_uio device

 * @param dev - The struct cnic_uio device to attach the hardware with

 * @return 0 on success, on failure a errno will be returned

 */

static int bnx2x_open(nic_t *nic)

{

	bnx2x_t *bp;

	struct stat uio_stat;

	int i, rc;

	__u32 val;

	int count;

	char sysfs_resc_path[80];

	uint32_t bus;

	uint32_t slot;

	uint32_t func;

	uint32_t mode;

	__u32 proto_offset;

	__u32 ovtag_offset;

	/*  Sanity Check: validate the parameters */

	if (nic == NULL) {

		LOG_ERR(PFX "nic == NULL");

		return -EINVAL;

	}

	if ((nic->priv) != NULL &&

	    (((bnx2x_t *) (nic->priv))->flags & BNX2X_OPENED)) {

		return 0;

	}

	bp = bnx2x_alloc(nic);

	if (bp == NULL)

		return -ENOMEM;

	if (bnx2x_is_drv_version_unknown(&bnx2x_version)) {

		/* If version is unknown, go read from ethtool */

		rc = bnx2x_get_drv_version(bp);

		if (rc)

			goto open_error;

	} else {

		/* Version is not unknown, just use it */

		bnx2x_version.major = bp->version.major;

		bnx2x_version.minor = bp->version.minor;

		bnx2x_version.sub_minor = bp->version.sub_minor;

	}

	count = 0;

	while ((nic->fd < 0) && count < 15) {

		/*  udev might not have created the file yet */

		pthread_mutex_unlock(&nic->nic_mutex);

		sleep(1);

		pthread_mutex_lock(&nic->nic_mutex);

		nic->fd = open(nic->uio_device_name, O_RDWR | O_NONBLOCK);

		if (nic->fd != INVALID_FD) {

			LOG_ERR(PFX "%s: uio device has been brought up "

				"via pid: %d on fd: %d",

				nic->uio_device_name, getpid(), nic->fd);

			rc = bnx2x_uio_verify(nic);

			if (rc != 0)

				continue;

			break;

		} else {

			LOG_WARN(PFX "%s: Could not open device: %s, [%s]",

				 nic->log_name, nic->uio_device_name,

				 strerror(errno));

			manually_trigger_uio_event(nic, nic->uio_minor);

			/*  udev might not have created the file yet */

			pthread_mutex_unlock(&nic->nic_mutex);

			sleep(1);

			pthread_mutex_lock(&nic->nic_mutex);

			count++;

		}

	}

	if (fstat(nic->fd, &uio_stat) < 0) {

		LOG_ERR(PFX "%s: Could not fstat device", nic->log_name);

		rc = -ENODEV;

		goto open_error;

	}

	nic->uio_minor = minor(uio_stat.st_rdev);

	cnic_get_sysfs_pci_resource_path(nic, 0, sysfs_resc_path, 80);

	bp->bar0_fd = open(sysfs_resc_path, O_RDWR | O_SYNC);

	if (bp->bar0_fd < 0) {

		LOG_ERR(PFX "%s: Could not open %s", nic->log_name,

			sysfs_resc_path);

		rc = -ENODEV;

		goto open_error;

	}

	bp->reg = mmap(NULL, BNX2X_BAR_SIZE, PROT_READ | PROT_WRITE,

			MAP_SHARED, bp->bar0_fd, (off_t) 0);

	if (bp->reg == MAP_FAILED) {

		LOG_INFO(PFX "%s: Couldn't mmap BAR registers: %s",

			 nic->log_name, strerror(errno));

		bp->reg = NULL;

		rc = errno;

		goto open_error;

	}

	msync(bp->reg, BNX2X_BAR_SIZE, MS_SYNC);

	cnic_get_sysfs_pci_resource_path(nic, 2, sysfs_resc_path, 80);

	bp->bar2_fd = open(sysfs_resc_path, O_RDWR | O_SYNC);

	if (bp->bar2_fd < 0) {

		LOG_ERR(PFX "%s: Could not open %s", nic->log_name,

			sysfs_resc_path);

		rc = -ENODEV;

		goto open_error;

	}

	bp->reg2 = mmap(NULL, BNX2X_BAR2_SIZE, PROT_READ | PROT_WRITE,

			MAP_SHARED, bp->bar2_fd, (off_t) 0);

	if (bp->reg2 == MAP_FAILED) {

		LOG_INFO(PFX "%s: Couldn't mmap BAR2 registers: %s",

			 nic->log_name, strerror(errno));

		bp->reg2 = NULL;

		rc = errno;

		goto open_error;

	}

	/*  TODO: hardcoded with the cnic driver */

	bp->rx_ring_size = 15;

	bp->rx_buffer_size = 0x400;

	LOG_DEBUG(PFX "%s: using rx ring size: %d, rx buffer size: %d",

		  nic->log_name, bp->rx_ring_size, bp->rx_buffer_size);

	/*  Determine the number of UIO events that have already occured */

	rc = detemine_initial_uio_events(nic, &nic->intr_count);

	if (rc != 0) {

		LOG_ERR("Could not determine the number ofinitial UIO events");

		nic->intr_count = 0;

	}

	/*  Allocate space for rx pkt ring */

	bp->rx_pkt_ring = malloc(sizeof(void *) * bp->rx_ring_size);

	if (bp->rx_pkt_ring == NULL) {

		LOG_ERR(PFX "%s: Could not allocate space for rx_pkt_ring",

			nic->log_name);

		rc = errno;

		goto open_error;

	}

	if (bnx2x_is_ver60_plus(bp))

		bp->status_blk_size = sizeof(struct host_sp_status_block);

	else if (bnx2x_is_ver52(bp))

		bp->status_blk_size = sizeof(struct host_def_status_block);

	else {

		LOG_INFO(PFX "%s: Unsupported bnx2x driver [%d.%d]",

			 nic->log_name, bp->version.major, bp->version.minor);

		rc = -ENOTSUP;

		goto open_error;

	}

	bp->status_blk.def = mmap(NULL, bp->status_blk_size,

				  PROT_READ | PROT_WRITE, MAP_SHARED,

				  nic->fd, (off_t) nic->page_size);

	if (bp->status_blk.def == MAP_FAILED) {

		LOG_INFO(PFX "%s: Could not mmap status block: %s",

			 nic->log_name, strerror(errno));

		bp->status_blk.def = NULL;

		rc = errno;

		goto open_error;

	}

	bp->tx_ring = mmap(NULL, 4 * nic->page_size,

			   PROT_READ | PROT_WRITE,

			   MAP_SHARED | MAP_LOCKED,

			   nic->fd, (off_t) 2 * nic->page_size);

	if (bp->tx_ring == MAP_FAILED) {

		LOG_INFO(PFX "%s: Could not mmap tx ring: %s",

			 nic->log_name, strerror(errno));

		bp->tx_ring = NULL;

		rc = errno;

		goto open_error;

	}

	bp->rx_comp_ring.cqe = (union eth_rx_cqe *)

	    (((__u8 *) bp->tx_ring) + 2 * nic->page_size);

	bp->bufs = mmap(NULL, (bp->rx_ring_size + 1) * bp->rx_buffer_size,

			PROT_READ | PROT_WRITE,

			MAP_SHARED | MAP_LOCKED,

			nic->fd, (off_t) 3 * nic->page_size);

	if (bp->bufs == MAP_FAILED) {

		LOG_INFO(PFX "%s: Could not mmap buffers: %s",

			 nic->log_name, strerror(errno));

		bp->bufs = NULL;

		rc = errno;

		goto open_error;

	}

	bp->chip_id = bnx2x_get_chip_id(bp);

	LOG_DEBUG(PFX "Chip ID: %x", bp->chip_id);

	rc = get_bus_slot_func_num(nic, &bus, &slot, &func);