Commit 8f1115b4 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'csiostor' 



Praveen Madhavan says:

====================
csiostor: Remove T4 FCoE support

We found a subtle issue with FCoE on T4 very late in the game
and decided not to productize FCoE on T4 and therefore there
are no customers that will be impacted by this change. FCoE is
supported on T5 cards.

Please apply on net-next since depends on previous commits.

Changes in v2:
  - Make the commit message more clearer.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents b66a4eaa d3944315

drivers/scsi/csiostor/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -8,5 +8,5 @@ ccflags-y += -I$(srctree)/drivers/net/ethernet/chelsio/cxgb4 
obj-$(CONFIG_SCSI_CHELSIO_FCOE) += csiostor.o



csiostor-objs := csio_attr.o csio_init.o csio_lnode.o csio_scsi.o \

		csio_hw.o csio_hw_t4.o csio_hw_t5.o csio_isr.o \

		csio_hw.o csio_hw_t5.o csio_isr.o \

		csio_mb.o csio_rnode.o csio_wr.o

drivers/scsi/csiostor/csio_hw.c

+15 −46
Original line number Diff line number Diff line
@@ -60,37 +60,10 @@ int csio_msi = 2; 
static int dev_num;



/* FCoE Adapter types & its description */

static const struct csio_adap_desc csio_t4_fcoe_adapters[] = {

	{"T440-Dbg 10G", "Chelsio T440-Dbg 10G [FCoE]"},

	{"T420-CR 10G", "Chelsio T420-CR 10G [FCoE]"},

	{"T422-CR 10G/1G", "Chelsio T422-CR 10G/1G [FCoE]"},

	{"T440-CR 10G", "Chelsio T440-CR 10G [FCoE]"},

	{"T420-BCH 10G", "Chelsio T420-BCH 10G [FCoE]"},

	{"T440-BCH 10G", "Chelsio T440-BCH 10G [FCoE]"},

	{"T440-CH 10G", "Chelsio T440-CH 10G [FCoE]"},

	{"T420-SO 10G", "Chelsio T420-SO 10G [FCoE]"},

	{"T420-CX4 10G", "Chelsio T420-CX4 10G [FCoE]"},

	{"T420-BT 10G", "Chelsio T420-BT 10G [FCoE]"},

	{"T404-BT 1G", "Chelsio T404-BT 1G [FCoE]"},

	{"B420-SR 10G", "Chelsio B420-SR 10G [FCoE]"},

	{"B404-BT 1G", "Chelsio B404-BT 1G [FCoE]"},

	{"T480-CR 10G", "Chelsio T480-CR 10G [FCoE]"},

	{"T440-LP-CR 10G", "Chelsio T440-LP-CR 10G [FCoE]"},

	{"AMSTERDAM 10G", "Chelsio AMSTERDAM 10G [FCoE]"},

	{"HUAWEI T480 10G", "Chelsio HUAWEI T480 10G [FCoE]"},

	{"HUAWEI T440 10G", "Chelsio HUAWEI T440 10G [FCoE]"},

	{"HUAWEI STG 10G", "Chelsio HUAWEI STG 10G [FCoE]"},

	{"ACROMAG XAUI 10G", "Chelsio ACROMAG XAUI 10G [FCoE]"},

	{"ACROMAG SFP+ 10G", "Chelsio ACROMAG SFP+ 10G [FCoE]"},

	{"QUANTA SFP+ 10G", "Chelsio QUANTA SFP+ 10G [FCoE]"},

	{"HUAWEI 10Gbase-T", "Chelsio HUAWEI 10Gbase-T [FCoE]"},

	{"HUAWEI T4TOE 10G", "Chelsio HUAWEI T4TOE 10G [FCoE]"}

};



static const struct csio_adap_desc csio_t5_fcoe_adapters[] = {

	{"T580-Dbg 10G", "Chelsio T580-Dbg 10G [FCoE]"},

	{"T520-CR 10G", "Chelsio T520-CR 10G [FCoE]"},

	{"T522-CR 10G/1G", "Chelsio T452-CR 10G/1G [FCoE]"},

	{"T522-CR 10G/1G", "Chelsio T522-CR 10G/1G [FCoE]"},

	{"T540-CR 10G", "Chelsio T540-CR 10G [FCoE]"},

	{"T520-BCH 10G", "Chelsio T520-BCH 10G [FCoE]"},

	{"T540-BCH 10G", "Chelsio T540-BCH 10G [FCoE]"},
@@ -107,7 +80,9 @@ static const struct csio_adap_desc csio_t5_fcoe_adapters[] = { 
	{"T580-LP-CR 40G", "Chelsio T580-LP-CR 40G [FCoE]"},

	{"T520-LL-CR 10G", "Chelsio T520-LL-CR 10G [FCoE]"},

	{"T560-CR 40G", "Chelsio T560-CR 40G [FCoE]"},

	{"T580-CR 40G", "Chelsio T580-CR 40G [FCoE]"}

	{"T580-CR 40G", "Chelsio T580-CR 40G [FCoE]"},

	{"T580-SO 40G", "Chelsio T580-SO 40G [FCoE]"},

	{"T502-BT 1G", "Chelsio T502-BT 1G [FCoE]"}

};



static void csio_mgmtm_cleanup(struct csio_mgmtm *);
@@ -1716,9 +1691,9 @@ csio_hw_flash_config(struct csio_hw *hw, u32 *fw_cfg_param, char *path) 
	uint32_t *cfg_data;

	int value_to_add = 0;



	if (request_firmware(&cf, CSIO_CF_FNAME(hw), dev) < 0) {

	if (request_firmware(&cf, FW_CFG_NAME_T5, dev) < 0) {

		csio_err(hw, "could not find config file %s, err: %d\n",

			 CSIO_CF_FNAME(hw), ret);

			 FW_CFG_NAME_T5, ret);

		return -ENOENT;

	}
@@ -1758,8 +1733,8 @@ csio_hw_flash_config(struct csio_hw *hw, u32 *fw_cfg_param, char *path) 
	}

	if (ret == 0) {

		csio_info(hw, "config file upgraded to %s\n",

			  CSIO_CF_FNAME(hw));

		snprintf(path, 64, "%s%s", "/lib/firmware/", CSIO_CF_FNAME(hw));

			  FW_CFG_NAME_T5);

		snprintf(path, 64, "%s%s", "/lib/firmware/", FW_CFG_NAME_T5);

	}



leave:
@@ -2123,9 +2098,9 @@ csio_hw_flash_fw(struct csio_hw *hw, int *reset) 
		return -EINVAL;

	}



	if (request_firmware(&fw, CSIO_FW_FNAME(hw), dev) < 0) {

	if (request_firmware(&fw, FW_FNAME_T5, dev) < 0) {

		csio_err(hw, "could not find firmware image %s, err: %d\n",

			 CSIO_FW_FNAME(hw), ret);

			 FW_FNAME_T5, ret);

		return -EINVAL;

	}
@@ -3207,7 +3182,7 @@ static void csio_ncsi_intr_handler(struct csio_hw *hw) 
 */

static void csio_xgmac_intr_handler(struct csio_hw *hw, int port)

{

	uint32_t v = csio_rd_reg32(hw, CSIO_MAC_INT_CAUSE_REG(hw, port));

	uint32_t v = csio_rd_reg32(hw, T5_PORT_REG(port, MAC_PORT_INT_CAUSE_A));



	v &= TXFIFO_PRTY_ERR_F | RXFIFO_PRTY_ERR_F;

	if (!v)
@@ -3217,7 +3192,7 @@ static void csio_xgmac_intr_handler(struct csio_hw *hw, int port) 
		csio_fatal(hw, "XGMAC %d Tx FIFO parity error\n", port);

	if (v & RXFIFO_PRTY_ERR_F)

		csio_fatal(hw, "XGMAC %d Rx FIFO parity error\n", port);

	csio_wr_reg32(hw, v, CSIO_MAC_INT_CAUSE_REG(hw, port));

	csio_wr_reg32(hw, v, T5_PORT_REG(port, MAC_PORT_INT_CAUSE_A));

	csio_hw_fatal_err(hw);

}
@@ -3966,13 +3941,7 @@ csio_hw_set_description(struct csio_hw *hw, uint16_t ven_id, uint16_t dev_id) 
		prot_type = (dev_id & CSIO_ASIC_DEVID_PROTO_MASK);

		adap_type = (dev_id & CSIO_ASIC_DEVID_TYPE_MASK);



		if (prot_type == CSIO_T4_FCOE_ASIC) {

			memcpy(hw->hw_ver,

			       csio_t4_fcoe_adapters[adap_type].model_no, 16);

			memcpy(hw->model_desc,

			       csio_t4_fcoe_adapters[adap_type].description,

			       32);

		} else if (prot_type == CSIO_T5_FCOE_ASIC) {

		if (prot_type == CSIO_T5_FCOE_ASIC) {

			memcpy(hw->hw_ver,

			       csio_t5_fcoe_adapters[adap_type].model_no, 16);

			memcpy(hw->model_desc,
@@ -4009,8 +3978,8 @@ csio_hw_init(struct csio_hw *hw) 


	strcpy(hw->name, CSIO_HW_NAME);



	/* Initialize the HW chip ops with T4/T5 specific ops */

	hw->chip_ops = csio_is_t4(hw->chip_id) ? &t4_ops : &t5_ops;

	/* Initialize the HW chip ops T5 specific ops */

	hw->chip_ops = &t5_ops;



	/* Set the model & its description */

drivers/scsi/csiostor/csio_hw_chip.h

+0 −43
Original line number Diff line number Diff line
@@ -37,24 +37,14 @@ 
#include "csio_defs.h"



/* Define MACRO values */

#define CSIO_HW_T4				0x4000

#define CSIO_T4_FCOE_ASIC			0x4600

#define CSIO_HW_T5				0x5000

#define CSIO_T5_FCOE_ASIC			0x5600

#define CSIO_HW_CHIP_MASK			0xF000



#define T4_REGMAP_SIZE				(160 * 1024)

#define T5_REGMAP_SIZE				(332 * 1024)

#define FW_FNAME_T4				"cxgb4/t4fw.bin"

#define FW_FNAME_T5				"cxgb4/t5fw.bin"

#define FW_CFG_NAME_T4				"cxgb4/t4-config.txt"

#define FW_CFG_NAME_T5				"cxgb4/t5-config.txt"



#define T4FW_VERSION_MAJOR 0x01

#define T4FW_VERSION_MINOR 0x0B

#define T4FW_VERSION_MICRO 0x1B

#define T4FW_VERSION_BUILD 0x00



#define T5FW_VERSION_MAJOR 0x01

#define T5FW_VERSION_MINOR 0x0B

#define T5FW_VERSION_MICRO 0x1B
@@ -65,27 +55,15 @@ 
#define CHELSIO_CHIP_VERSION(code) (((code) >> 12) & 0xf)

#define CHELSIO_CHIP_RELEASE(code) ((code) & 0xf)



#define CHELSIO_T4		0x4

#define CHELSIO_T5		0x5



enum chip_type {

	T4_A1 = CHELSIO_CHIP_CODE(CHELSIO_T4, 1),

	T4_A2 = CHELSIO_CHIP_CODE(CHELSIO_T4, 2),

	T4_FIRST_REV	= T4_A1,

	T4_LAST_REV	= T4_A2,



	T5_A0 = CHELSIO_CHIP_CODE(CHELSIO_T5, 0),

	T5_A1 = CHELSIO_CHIP_CODE(CHELSIO_T5, 1),

	T5_FIRST_REV	= T5_A0,

	T5_LAST_REV	= T5_A1,

};



/* Define static functions */

static inline int csio_is_t4(uint16_t chip)

{

	return (chip == CSIO_HW_T4);

}



static inline int csio_is_t5(uint16_t chip)

{

	return (chip == CSIO_HW_T5);
@@ -95,21 +73,6 @@ static inline int csio_is_t5(uint16_t chip) 
#define CSIO_DEVICE(devid, idx)						\

	{ PCI_VENDOR_ID_CHELSIO, (devid), PCI_ANY_ID, PCI_ANY_ID, 0, 0, (idx) }



#define CSIO_HW_PIDX(hw, index)						\

	(csio_is_t4(hw->chip_id) ? (PIDX_V(index)) :			\

					(PIDX_T5_G(index) | DBTYPE_F))



#define CSIO_HW_LP_INT_THRESH(hw, val)					\

	(csio_is_t4(hw->chip_id) ? (LP_INT_THRESH_V(val)) :		\

					(LP_INT_THRESH_T5_V(val)))



#define CSIO_HW_M_LP_INT_THRESH(hw)					\

	(csio_is_t4(hw->chip_id) ? (LP_INT_THRESH_M) : (LP_INT_THRESH_T5_M))



#define CSIO_MAC_INT_CAUSE_REG(hw, port)				\

	(csio_is_t4(hw->chip_id) ? (PORT_REG(port, XGMAC_PORT_INT_CAUSE_A)) : \

				(T5_PORT_REG(port, MAC_PORT_INT_CAUSE_A)))



#include "t4fw_api.h"



#define FW_VERSION(chip) ( \
@@ -125,11 +88,6 @@ struct fw_info { 
	char *fw_mod_name;

	struct fw_hdr fw_hdr;

};

#define CSIO_FW_FNAME(hw)						\

	(csio_is_t4(hw->chip_id) ? FW_FNAME_T4 : FW_FNAME_T5)



#define CSIO_CF_FNAME(hw)						\

	(csio_is_t4(hw->chip_id) ? FW_CFG_NAME_T4 : FW_CFG_NAME_T5)



/* Declare ENUMS */

enum { MEM_EDC0, MEM_EDC1, MEM_MC, MEM_MC0 = MEM_MC, MEM_MC1 };
@@ -163,7 +121,6 @@ struct csio_hw_chip_ops { 
	void (*chip_dfs_create_ext_mem)(struct csio_hw *);

};



extern struct csio_hw_chip_ops t4_ops;

extern struct csio_hw_chip_ops t5_ops;



#endif /* #ifndef __CSIO_HW_CHIP_H__ */

drivers/scsi/csiostor/csio_hw_t4.c

deleted100644 → 0
+0 −404
Original line number Diff line number Diff line 
/*

 * This file is part of the Chelsio FCoE driver for Linux.

 *

 * Copyright (c) 2008-2013 Chelsio Communications, Inc. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * OpenIB.org BSD license below:

 *

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

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *      - 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.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

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

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */



#include "csio_hw.h"

#include "csio_init.h"



/*

 * Return the specified PCI-E Configuration Space register from our Physical

 * Function.  We try first via a Firmware LDST Command since we prefer to let

 * the firmware own all of these registers, but if that fails we go for it

 * directly ourselves.

 */

static uint32_t

csio_t4_read_pcie_cfg4(struct csio_hw *hw, int reg)

{

	u32 val = 0;

	struct csio_mb *mbp;

	int rv;

	struct fw_ldst_cmd *ldst_cmd;



	mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);

	if (!mbp) {

		CSIO_INC_STATS(hw, n_err_nomem);

		pci_read_config_dword(hw->pdev, reg, &val);

		return val;

	}



	csio_mb_ldst(hw, mbp, CSIO_MB_DEFAULT_TMO, reg);

	rv = csio_mb_issue(hw, mbp);



	/*

	 * If the LDST Command suucceeded, exctract the returned register

	 * value.  Otherwise read it directly ourself.

	 */

	if (rv == 0) {

		ldst_cmd = (struct fw_ldst_cmd *)(mbp->mb);

		val = ntohl(ldst_cmd->u.pcie.data[0]);

	} else

		pci_read_config_dword(hw->pdev, reg, &val);



	mempool_free(mbp, hw->mb_mempool);



	return val;

}



static int

csio_t4_set_mem_win(struct csio_hw *hw, uint32_t win)

{

	u32 bar0;

	u32 mem_win_base;



	/*

	 * Truncation intentional: we only read the bottom 32-bits of the

	 * 64-bit BAR0/BAR1 ...  We use the hardware backdoor mechanism to

	 * read BAR0 instead of using pci_resource_start() because we could be

	 * operating from within a Virtual Machine which is trapping our

	 * accesses to our Configuration Space and we need to set up the PCI-E

	 * Memory Window decoders with the actual addresses which will be

	 * coming across the PCI-E link.

	 */

	bar0 = csio_t4_read_pcie_cfg4(hw, PCI_BASE_ADDRESS_0);

	bar0 &= PCI_BASE_ADDRESS_MEM_MASK;



	mem_win_base = bar0 + MEMWIN_BASE;



	/*

	 * Set up memory window for accessing adapter memory ranges.  (Read

	 * back MA register to ensure that changes propagate before we attempt

	 * to use the new values.)

	 */

	csio_wr_reg32(hw, mem_win_base | BIR_V(0) |

			  WINDOW_V(ilog2(MEMWIN_APERTURE) - 10),

			  PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, win));

	csio_rd_reg32(hw,

		      PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, win));

	return 0;

}



/*

 * Interrupt handler for the PCIE module.

 */

static void

csio_t4_pcie_intr_handler(struct csio_hw *hw)

{

	static struct intr_info sysbus_intr_info[] = {

		{ RNPP_F, "RXNP array parity error", -1, 1 },

		{ RPCP_F, "RXPC array parity error", -1, 1 },

		{ RCIP_F, "RXCIF array parity error", -1, 1 },

		{ RCCP_F, "Rx completions control array parity error", -1, 1 },

		{ RFTP_F, "RXFT array parity error", -1, 1 },

		{ 0, NULL, 0, 0 }

	};

	static struct intr_info pcie_port_intr_info[] = {

		{ TPCP_F, "TXPC array parity error", -1, 1 },

		{ TNPP_F, "TXNP array parity error", -1, 1 },

		{ TFTP_F, "TXFT array parity error", -1, 1 },

		{ TCAP_F, "TXCA array parity error", -1, 1 },

		{ TCIP_F, "TXCIF array parity error", -1, 1 },

		{ RCAP_F, "RXCA array parity error", -1, 1 },

		{ OTDD_F, "outbound request TLP discarded", -1, 1 },

		{ RDPE_F, "Rx data parity error", -1, 1 },

		{ TDUE_F, "Tx uncorrectable data error", -1, 1 },

		{ 0, NULL, 0, 0 }

	};



	static struct intr_info pcie_intr_info[] = {

		{ MSIADDRLPERR_F, "MSI AddrL parity error", -1, 1 },

		{ MSIADDRHPERR_F, "MSI AddrH parity error", -1, 1 },

		{ MSIDATAPERR_F, "MSI data parity error", -1, 1 },

		{ MSIXADDRLPERR_F, "MSI-X AddrL parity error", -1, 1 },

		{ MSIXADDRHPERR_F, "MSI-X AddrH parity error", -1, 1 },

		{ MSIXDATAPERR_F, "MSI-X data parity error", -1, 1 },

		{ MSIXDIPERR_F, "MSI-X DI parity error", -1, 1 },

		{ PIOCPLPERR_F, "PCI PIO completion FIFO parity error", -1, 1 },

		{ PIOREQPERR_F, "PCI PIO request FIFO parity error", -1, 1 },

		{ TARTAGPERR_F, "PCI PCI target tag FIFO parity error", -1, 1 },

		{ CCNTPERR_F, "PCI CMD channel count parity error", -1, 1 },

		{ CREQPERR_F, "PCI CMD channel request parity error", -1, 1 },

		{ CRSPPERR_F, "PCI CMD channel response parity error", -1, 1 },

		{ DCNTPERR_F, "PCI DMA channel count parity error", -1, 1 },

		{ DREQPERR_F, "PCI DMA channel request parity error", -1, 1 },

		{ DRSPPERR_F, "PCI DMA channel response parity error", -1, 1 },

		{ HCNTPERR_F, "PCI HMA channel count parity error", -1, 1 },

		{ HREQPERR_F, "PCI HMA channel request parity error", -1, 1 },

		{ HRSPPERR_F, "PCI HMA channel response parity error", -1, 1 },

		{ CFGSNPPERR_F, "PCI config snoop FIFO parity error", -1, 1 },

		{ FIDPERR_F, "PCI FID parity error", -1, 1 },

		{ INTXCLRPERR_F, "PCI INTx clear parity error", -1, 1 },

		{ MATAGPERR_F, "PCI MA tag parity error", -1, 1 },

		{ PIOTAGPERR_F, "PCI PIO tag parity error", -1, 1 },

		{ RXCPLPERR_F, "PCI Rx completion parity error", -1, 1 },

		{ RXWRPERR_F, "PCI Rx write parity error", -1, 1 },

		{ RPLPERR_F, "PCI replay buffer parity error", -1, 1 },

		{ PCIESINT_F, "PCI core secondary fault", -1, 1 },

		{ PCIEPINT_F, "PCI core primary fault", -1, 1 },

		{ UNXSPLCPLERR_F, "PCI unexpected split completion error", -1,

		  0 },

		{ 0, NULL, 0, 0 }

	};



	int fat;

	fat = csio_handle_intr_status(hw,

				      PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS_A,

				      sysbus_intr_info) +

	      csio_handle_intr_status(hw,

				      PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS_A,

				      pcie_port_intr_info) +

	      csio_handle_intr_status(hw, PCIE_INT_CAUSE_A, pcie_intr_info);

	if (fat)

		csio_hw_fatal_err(hw);

}



/*

 * csio_t4_flash_cfg_addr - return the address of the flash configuration file

 * @hw: the HW module

 *

 * Return the address within the flash where the Firmware Configuration

 * File is stored.

 */

static unsigned int

csio_t4_flash_cfg_addr(struct csio_hw *hw)

{

	return FLASH_CFG_OFFSET;

}



/*

 *      csio_t4_mc_read - read from MC through backdoor accesses

 *      @hw: the hw module

 *      @idx: not used for T4 adapter

 *      @addr: address of first byte requested

 *      @data: 64 bytes of data containing the requested address

 *      @ecc: where to store the corresponding 64-bit ECC word

 *

 *      Read 64 bytes of data from MC starting at a 64-byte-aligned address

 *      that covers the requested address @addr.  If @parity is not %NULL it

 *      is assigned the 64-bit ECC word for the read data.

 */

static int

csio_t4_mc_read(struct csio_hw *hw, int idx, uint32_t addr, __be32 *data,

		uint64_t *ecc)

{

	int i;



	if (csio_rd_reg32(hw, MC_BIST_CMD_A) & START_BIST_F)

		return -EBUSY;

	csio_wr_reg32(hw, addr & ~0x3fU, MC_BIST_CMD_ADDR_A);

	csio_wr_reg32(hw, 64, MC_BIST_CMD_LEN_A);

	csio_wr_reg32(hw, 0xc, MC_BIST_DATA_PATTERN_A);

	csio_wr_reg32(hw, BIST_OPCODE_V(1) | START_BIST_F | BIST_CMD_GAP_V(1),

		      MC_BIST_CMD_A);

	i = csio_hw_wait_op_done_val(hw, MC_BIST_CMD_A, START_BIST_F,

				     0, 10, 1, NULL);

	if (i)

		return i;



#define MC_DATA(i) MC_BIST_STATUS_REG(MC_BIST_STATUS_RDATA_A, i)



	for (i = 15; i >= 0; i--)

		*data++ = htonl(csio_rd_reg32(hw, MC_DATA(i)));

	if (ecc)

		*ecc = csio_rd_reg64(hw, MC_DATA(16));

#undef MC_DATA

	return 0;

}



/*

 *      csio_t4_edc_read - read from EDC through backdoor accesses

 *      @hw: the hw module

 *      @idx: which EDC to access

 *      @addr: address of first byte requested

 *      @data: 64 bytes of data containing the requested address

 *      @ecc: where to store the corresponding 64-bit ECC word

 *

 *      Read 64 bytes of data from EDC starting at a 64-byte-aligned address

 *      that covers the requested address @addr.  If @parity is not %NULL it

 *      is assigned the 64-bit ECC word for the read data.

 */

static int

csio_t4_edc_read(struct csio_hw *hw, int idx, uint32_t addr, __be32 *data,

		uint64_t *ecc)

{

	int i;



	idx *= EDC_STRIDE;

	if (csio_rd_reg32(hw, EDC_BIST_CMD_A + idx) & START_BIST_F)

		return -EBUSY;

	csio_wr_reg32(hw, addr & ~0x3fU, EDC_BIST_CMD_ADDR_A + idx);

	csio_wr_reg32(hw, 64, EDC_BIST_CMD_LEN_A + idx);

	csio_wr_reg32(hw, 0xc, EDC_BIST_DATA_PATTERN_A + idx);

	csio_wr_reg32(hw, BIST_OPCODE_V(1) | BIST_CMD_GAP_V(1) | START_BIST_F,

		      EDC_BIST_CMD_A + idx);

	i = csio_hw_wait_op_done_val(hw, EDC_BIST_CMD_A + idx, START_BIST_F,

				     0, 10, 1, NULL);

	if (i)

		return i;



#define EDC_DATA(i) (EDC_BIST_STATUS_REG(EDC_BIST_STATUS_RDATA_A, i) + idx)



	for (i = 15; i >= 0; i--)

		*data++ = htonl(csio_rd_reg32(hw, EDC_DATA(i)));

	if (ecc)

		*ecc = csio_rd_reg64(hw, EDC_DATA(16));

#undef EDC_DATA

	return 0;

}



/*

 * csio_t4_memory_rw - read/write EDC 0, EDC 1 or MC via PCIE memory window

 * @hw: the csio_hw

 * @win: PCI-E memory Window to use

 * @mtype: memory type: MEM_EDC0, MEM_EDC1, MEM_MC0 (or MEM_MC) or MEM_MC1

 * @addr: address within indicated memory type

 * @len: amount of memory to transfer

 * @buf: host memory buffer

 * @dir: direction of transfer 1 => read, 0 => write

 *

 * Reads/writes an [almost] arbitrary memory region in the firmware: the

 * firmware memory address, length and host buffer must be aligned on

 * 32-bit boudaries.  The memory is transferred as a raw byte sequence

 * from/to the firmware's memory.  If this memory contains data

 * structures which contain multi-byte integers, it's the callers

 * responsibility to perform appropriate byte order conversions.

 */

static int

csio_t4_memory_rw(struct csio_hw *hw, u32 win, int mtype, u32 addr,

		u32 len, uint32_t *buf, int dir)

{

	u32 pos, start, offset, memoffset, bar0;

	u32 edc_size, mc_size, mem_reg, mem_aperture, mem_base;



	/*

	 * Argument sanity checks ...

	 */

	if ((addr & 0x3) || (len & 0x3))

		return -EINVAL;



	/* Offset into the region of memory which is being accessed

	 * MEM_EDC0 = 0

	 * MEM_EDC1 = 1

	 * MEM_MC   = 2 -- T4

	 */

	edc_size  = EDRAM0_SIZE_G(csio_rd_reg32(hw, MA_EDRAM0_BAR_A));

	if (mtype != MEM_MC1)

		memoffset = (mtype * (edc_size * 1024 * 1024));

	else {

		mc_size = EXT_MEM_SIZE_G(csio_rd_reg32(hw,

						       MA_EXT_MEMORY_BAR_A));

		memoffset = (MEM_MC0 * edc_size + mc_size) * 1024 * 1024;

	}



	/* Determine the PCIE_MEM_ACCESS_OFFSET */

	addr = addr + memoffset;



	/*

	 * Each PCI-E Memory Window is programmed with a window size -- or

	 * "aperture" -- which controls the granularity of its mapping onto

	 * adapter memory.  We need to grab that aperture in order to know

	 * how to use the specified window.  The window is also programmed

	 * with the base address of the Memory Window in BAR0's address

	 * space.  For T4 this is an absolute PCI-E Bus Address.  For T5

	 * the address is relative to BAR0.

	 */

	mem_reg = csio_rd_reg32(hw,

			PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, win));

	mem_aperture = 1 << (WINDOW_V(mem_reg) + 10);

	mem_base = PCIEOFST_G(mem_reg) << 10;



	bar0 = csio_t4_read_pcie_cfg4(hw, PCI_BASE_ADDRESS_0);

	bar0 &= PCI_BASE_ADDRESS_MEM_MASK;

	mem_base -= bar0;



	start = addr & ~(mem_aperture-1);

	offset = addr - start;



	csio_dbg(hw, "csio_t4_memory_rw: mem_reg: 0x%x, mem_aperture: 0x%x\n",

		 mem_reg, mem_aperture);

	csio_dbg(hw, "csio_t4_memory_rw: mem_base: 0x%x, mem_offset: 0x%x\n",

		 mem_base, memoffset);

	csio_dbg(hw, "csio_t4_memory_rw: bar0: 0x%x, start:0x%x, offset:0x%x\n",

		 bar0, start, offset);

	csio_dbg(hw, "csio_t4_memory_rw: mtype: %d, addr: 0x%x, len: %d\n",

		 mtype, addr, len);



	for (pos = start; len > 0; pos += mem_aperture, offset = 0) {

		/*

		 * Move PCI-E Memory Window to our current transfer

		 * position.  Read it back to ensure that changes propagate

		 * before we attempt to use the new value.

		 */

		csio_wr_reg32(hw, pos,

			PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A, win));

		csio_rd_reg32(hw,

			PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A, win));



		while (offset < mem_aperture && len > 0) {

			if (dir)

				*buf++ = csio_rd_reg32(hw, mem_base + offset);

			else

				csio_wr_reg32(hw, *buf++, mem_base + offset);



			offset += sizeof(__be32);

			len -= sizeof(__be32);

		}

	}

	return 0;

}



/*

 * csio_t4_dfs_create_ext_mem - setup debugfs for MC to read the values

 * @hw: the csio_hw

 *

 * This function creates files in the debugfs with external memory region MC.

 */

static void

csio_t4_dfs_create_ext_mem(struct csio_hw *hw)

{

	u32 size;

	int i = csio_rd_reg32(hw, MA_TARGET_MEM_ENABLE_A);



	if (i & EXT_MEM_ENABLE_F) {

		size = csio_rd_reg32(hw, MA_EXT_MEMORY_BAR_A);

		csio_add_debugfs_mem(hw, "mc", MEM_MC,

				     EXT_MEM_SIZE_G(size));

	}

}



/* T4 adapter specific function */

struct csio_hw_chip_ops t4_ops = {

	.chip_set_mem_win		= csio_t4_set_mem_win,

	.chip_pcie_intr_handler		= csio_t4_pcie_intr_handler,

	.chip_flash_cfg_addr		= csio_t4_flash_cfg_addr,

	.chip_mc_read			= csio_t4_mc_read,

	.chip_edc_read			= csio_t4_edc_read,

	.chip_memory_rw			= csio_t4_memory_rw,

	.chip_dfs_create_ext_mem	= csio_t4_dfs_create_ext_mem,

};

drivers/scsi/csiostor/csio_init.c

+2 −4
Original line number Diff line number Diff line
@@ -1176,9 +1176,8 @@ static struct pci_error_handlers csio_err_handler = { 
 */

#define CH_PCI_DEVICE_ID_TABLE_DEFINE_BEGIN \

	static struct pci_device_id csio_pci_tbl[] = {

/* Define for iSCSI uses PF5, FCoE uses PF6 */

#define CH_PCI_DEVICE_ID_FUNCTION	0x5

#define CH_PCI_DEVICE_ID_FUNCTION2	0x6

/* Define for FCoE uses PF6 */

#define CH_PCI_DEVICE_ID_FUNCTION	0x6



#define CH_PCI_ID_TABLE_ENTRY(devid) \

		{ PCI_VDEVICE(CHELSIO, (devid)), 0 }
@@ -1256,5 +1255,4 @@ MODULE_DESCRIPTION(CSIO_DRV_DESC); 
MODULE_LICENSE(CSIO_DRV_LICENSE);

MODULE_DEVICE_TABLE(pci, csio_pci_tbl);

MODULE_VERSION(CSIO_DRV_VERSION);

MODULE_FIRMWARE(FW_FNAME_T4);

MODULE_FIRMWARE(FW_FNAME_T5);

CRA Git | Maintained and supported by SUSTech CRA and CCSE