staging/rdma/hfi1: Fix code alignment (17fb4f29) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/staging/rdma/hfi1/chip.c

+449 −472

Original line number	Original line	Diff line number	Diff line
	@@ -1147,11 +1147,8 @@ struct cntr_entry {
	/*		/*
	* accessor for stat element, context either dd or ppd		* accessor for stat element, context either dd or ppd
	*/		*/
	u64 (rw_cntr)(const struct cntr_entry ,		u64 (rw_cntr)(const struct cntr_entry , void *context, int vl,
	void *context,		int mode, u64 data);
	int vl,
	int mode,
	u64 data);
	};		};

	#define C_RCV_HDR_OVF_FIRST C_RCV_HDR_OVF_0		#define C_RCV_HDR_OVF_FIRST C_RCV_HDR_OVF_0
	@@ -1501,7 +1498,8 @@ static u64 access_sw_xmit_discards(const struct cntr_entry *entry,
	}		}

	static u64 access_xmit_constraint_errs(const struct cntr_entry *entry,		static u64 access_xmit_constraint_errs(const struct cntr_entry *entry,
	void *context, int vl, int mode, u64 data)		void *context, int vl, int mode,
			u64 data)
	{		{
	struct hfi1_pportdata *ppd = context;		struct hfi1_pportdata *ppd = context;

	@@ -5214,9 +5212,7 @@ static char is_misc_err_name(char buf, size_t bsize, unsigned int source)
	if (source < ARRAY_SIZE(cce_misc_names))		if (source < ARRAY_SIZE(cce_misc_names))
	strncpy(buf, cce_misc_names[source], bsize);		strncpy(buf, cce_misc_names[source], bsize);
	else		else
	snprintf(buf,		snprintf(buf, bsize, "Reserved%u",
	bsize,
	"Reserved%u",
	source + IS_GENERAL_ERR_START);		source + IS_GENERAL_ERR_START);

	return buf;		return buf;
	@@ -5341,13 +5337,15 @@ static char is_reserved_name(char buf, size_t bsize, unsigned int source)
	static char cce_err_status_string(char buf, int buf_len, u64 flags)		static char cce_err_status_string(char buf, int buf_len, u64 flags)
	{		{
	return flag_string(buf, buf_len, flags,		return flag_string(buf, buf_len, flags,
	cce_err_status_flags, ARRAY_SIZE(cce_err_status_flags));		cce_err_status_flags,
			ARRAY_SIZE(cce_err_status_flags));
	}		}

	static char rxe_err_status_string(char buf, int buf_len, u64 flags)		static char rxe_err_status_string(char buf, int buf_len, u64 flags)
	{		{
	return flag_string(buf, buf_len, flags,		return flag_string(buf, buf_len, flags,
	rxe_err_status_flags, ARRAY_SIZE(rxe_err_status_flags));		rxe_err_status_flags,
			ARRAY_SIZE(rxe_err_status_flags));
	}		}

	static char misc_err_status_string(char buf, int buf_len, u64 flags)		static char misc_err_status_string(char buf, int buf_len, u64 flags)
	@@ -5359,7 +5357,8 @@ static char misc_err_status_string(char buf, int buf_len, u64 flags)
	static char pio_err_status_string(char buf, int buf_len, u64 flags)		static char pio_err_status_string(char buf, int buf_len, u64 flags)
	{		{
	return flag_string(buf, buf_len, flags,		return flag_string(buf, buf_len, flags,
	pio_err_status_flags, ARRAY_SIZE(pio_err_status_flags));		pio_err_status_flags,
			ARRAY_SIZE(pio_err_status_flags));
	}		}

	static char sdma_err_status_string(char buf, int buf_len, u64 flags)		static char sdma_err_status_string(char buf, int buf_len, u64 flags)
	@@ -5372,13 +5371,15 @@ static char sdma_err_status_string(char buf, int buf_len, u64 flags)
	static char egress_err_status_string(char buf, int buf_len, u64 flags)		static char egress_err_status_string(char buf, int buf_len, u64 flags)
	{		{
	return flag_string(buf, buf_len, flags,		return flag_string(buf, buf_len, flags,
	egress_err_status_flags, ARRAY_SIZE(egress_err_status_flags));		egress_err_status_flags,
			ARRAY_SIZE(egress_err_status_flags));
	}		}

	static char egress_err_info_string(char buf, int buf_len, u64 flags)		static char egress_err_info_string(char buf, int buf_len, u64 flags)
	{		{
	return flag_string(buf, buf_len, flags,		return flag_string(buf, buf_len, flags,
	egress_err_info_flags, ARRAY_SIZE(egress_err_info_flags));		egress_err_info_flags,
			ARRAY_SIZE(egress_err_info_flags));
	}		}

	static char send_err_status_string(char buf, int buf_len, u64 flags)		static char send_err_status_string(char buf, int buf_len, u64 flags)
	@@ -5430,8 +5431,8 @@ static void update_rcverr_timer(unsigned long opaque)
	if (dd->rcv_ovfl_cnt < cur_ovfl_cnt &&		if (dd->rcv_ovfl_cnt < cur_ovfl_cnt &&
	ppd->port_error_action & OPA_PI_MASK_EX_BUFFER_OVERRUN) {		ppd->port_error_action & OPA_PI_MASK_EX_BUFFER_OVERRUN) {
	dd_dev_info(dd, "%s: PortErrorAction bounce\n", __func__);		dd_dev_info(dd, "%s: PortErrorAction bounce\n", __func__);
	set_link_down_reason(ppd,		set_link_down_reason(
	OPA_LINKDOWN_REASON_EXCESSIVE_BUFFER_OVERRUN, 0,		ppd, OPA_LINKDOWN_REASON_EXCESSIVE_BUFFER_OVERRUN, 0,
	OPA_LINKDOWN_REASON_EXCESSIVE_BUFFER_OVERRUN);		OPA_LINKDOWN_REASON_EXCESSIVE_BUFFER_OVERRUN);
	queue_work(ppd->hfi1_wq, &ppd->link_bounce_work);		queue_work(ppd->hfi1_wq, &ppd->link_bounce_work);
	}		}
	@@ -5790,7 +5791,8 @@ static void is_misc_err_int(struct hfi1_devdata *dd, unsigned int source)
	static char send_context_err_status_string(char buf, int buf_len, u64 flags)		static char send_context_err_status_string(char buf, int buf_len, u64 flags)
	{		{
	return flag_string(buf, buf_len, flags,		return flag_string(buf, buf_len, flags,
	sc_err_status_flags, ARRAY_SIZE(sc_err_status_flags));		sc_err_status_flags,
			ARRAY_SIZE(sc_err_status_flags));
	}		}

	/*		/*
	@@ -5833,7 +5835,8 @@ static void is_sendctxt_err_int(struct hfi1_devdata *dd,
	status = read_kctxt_csr(dd, hw_context, SEND_CTXT_ERR_STATUS);		status = read_kctxt_csr(dd, hw_context, SEND_CTXT_ERR_STATUS);

	dd_dev_info(dd, "Send Context %u(%u) Error: %s\n", sw_index, hw_context,		dd_dev_info(dd, "Send Context %u(%u) Error: %s\n", sw_index, hw_context,
	send_context_err_status_string(flags, sizeof(flags), status));		send_context_err_status_string(flags, sizeof(flags),
			status));

	if (status & SEND_CTXT_ERR_STATUS_PIO_DISALLOWED_PACKET_ERR_SMASK)		if (status & SEND_CTXT_ERR_STATUS_PIO_DISALLOWED_PACKET_ERR_SMASK)
	handle_send_egress_err_info(dd, sc_to_vl(dd, sw_index));		handle_send_egress_err_info(dd, sc_to_vl(dd, sw_index));
	@@ -6010,8 +6013,8 @@ static int request_host_lcb_access(struct hfi1_devdata *dd)
	int ret;		int ret;

	ret = do_8051_command(dd, HCMD_MISC,		ret = do_8051_command(dd, HCMD_MISC,
	(u64)HCMD_MISC_REQUEST_LCB_ACCESS << LOAD_DATA_FIELD_ID_SHIFT,		(u64)HCMD_MISC_REQUEST_LCB_ACCESS <<
	NULL);		LOAD_DATA_FIELD_ID_SHIFT, NULL);
	if (ret != HCMD_SUCCESS) {		if (ret != HCMD_SUCCESS) {
	dd_dev_err(dd, "%s: command failed with error %d\n",		dd_dev_err(dd, "%s: command failed with error %d\n",
	__func__, ret);		__func__, ret);
	@@ -6024,8 +6027,8 @@ static int request_8051_lcb_access(struct hfi1_devdata *dd)
	int ret;		int ret;

	ret = do_8051_command(dd, HCMD_MISC,		ret = do_8051_command(dd, HCMD_MISC,
	(u64)HCMD_MISC_GRANT_LCB_ACCESS << LOAD_DATA_FIELD_ID_SHIFT,		(u64)HCMD_MISC_GRANT_LCB_ACCESS <<
	NULL);		LOAD_DATA_FIELD_ID_SHIFT, NULL);
	if (ret != HCMD_SUCCESS) {		if (ret != HCMD_SUCCESS) {
	dd_dev_err(dd, "%s: command failed with error %d\n",		dd_dev_err(dd, "%s: command failed with error %d\n",
	__func__, ret);		__func__, ret);
	@@ -6040,8 +6043,8 @@ static int request_8051_lcb_access(struct hfi1_devdata *dd)
	static inline void set_host_lcb_access(struct hfi1_devdata *dd)		static inline void set_host_lcb_access(struct hfi1_devdata *dd)
	{		{
	write_csr(dd, DC_DC8051_CFG_CSR_ACCESS_SEL,		write_csr(dd, DC_DC8051_CFG_CSR_ACCESS_SEL,
	DC_DC8051_CFG_CSR_ACCESS_SEL_DCC_SMASK		DC_DC8051_CFG_CSR_ACCESS_SEL_DCC_SMASK \|
	\| DC_DC8051_CFG_CSR_ACCESS_SEL_LCB_SMASK);		DC_DC8051_CFG_CSR_ACCESS_SEL_LCB_SMASK);
	}		}

	/*		/*
	@@ -6174,9 +6177,10 @@ static void init_lcb_access(struct hfi1_devdata *dd)
	static void hreq_response(struct hfi1_devdata *dd, u8 return_code, u16 rsp_data)		static void hreq_response(struct hfi1_devdata *dd, u8 return_code, u16 rsp_data)
	{		{
	write_csr(dd, DC_DC8051_CFG_EXT_DEV_0,		write_csr(dd, DC_DC8051_CFG_EXT_DEV_0,
	DC_DC8051_CFG_EXT_DEV_0_COMPLETED_SMASK		DC_DC8051_CFG_EXT_DEV_0_COMPLETED_SMASK \|
	\| (u64)return_code << DC_DC8051_CFG_EXT_DEV_0_RETURN_CODE_SHIFT		(u64)return_code <<
	\| (u64)rsp_data << DC_DC8051_CFG_EXT_DEV_0_RSP_DATA_SHIFT);		DC_DC8051_CFG_EXT_DEV_0_RETURN_CODE_SHIFT \|
			(u64)rsp_data << DC_DC8051_CFG_EXT_DEV_0_RSP_DATA_SHIFT);
	}		}

	/*		/*
	@@ -6272,11 +6276,11 @@ static void write_global_credit(struct hfi1_devdata *dd,
	u8 vau, u16 total, u16 shared)		u8 vau, u16 total, u16 shared)
	{		{
	write_csr(dd, SEND_CM_GLOBAL_CREDIT,		write_csr(dd, SEND_CM_GLOBAL_CREDIT,
	((u64)total		((u64)total <<
	<< SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_SHIFT)		SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_SHIFT) \|
	\| ((u64)shared		((u64)shared <<
	<< SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_SHIFT)		SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_SHIFT) \|
	\| ((u64)vau << SEND_CM_GLOBAL_CREDIT_AU_SHIFT));		((u64)vau << SEND_CM_GLOBAL_CREDIT_AU_SHIFT));
	}		}

	/*		/*
	@@ -6359,10 +6363,9 @@ static void lcb_shutdown(struct hfi1_devdata *dd, int abort)
	/* set dcc reset csr: DCC_CFG_RESET.{reset_lcb,reset_rx_fpe} = 1 */		/* set dcc reset csr: DCC_CFG_RESET.{reset_lcb,reset_rx_fpe} = 1 */
	dd->lcb_err_en = read_csr(dd, DC_LCB_ERR_EN);		dd->lcb_err_en = read_csr(dd, DC_LCB_ERR_EN);
	reg = read_csr(dd, DCC_CFG_RESET);		reg = read_csr(dd, DCC_CFG_RESET);
	write_csr(dd, DCC_CFG_RESET,		write_csr(dd, DCC_CFG_RESET, reg \|
	reg		(1ull << DCC_CFG_RESET_RESET_LCB_SHIFT) \|
	\| (1ull << DCC_CFG_RESET_RESET_LCB_SHIFT)		(1ull << DCC_CFG_RESET_RESET_RX_FPE_SHIFT));
	\| (1ull << DCC_CFG_RESET_RESET_RX_FPE_SHIFT));
	(void)read_csr(dd, DCC_CFG_RESET); /* make sure the write completed */		(void)read_csr(dd, DCC_CFG_RESET); /* make sure the write completed */
	if (!abort) {		if (!abort) {
	udelay(1); /* must hold for the longer of 16cclks or 20ns */		udelay(1); /* must hold for the longer of 16cclks or 20ns */
	@@ -6665,8 +6668,7 @@ static void wait_for_freeze_status(struct hfi1_devdata *dd, int freeze)
	if (time_after(jiffies, timeout)) {		if (time_after(jiffies, timeout)) {
	dd_dev_err(dd,		dd_dev_err(dd,
	"Time out waiting for SPC %sfreeze, bits 0x%llx, expecting 0x%llx, continuing",		"Time out waiting for SPC %sfreeze, bits 0x%llx, expecting 0x%llx, continuing",
	freeze ? "" : "un",		freeze ? "" : "un", reg & ALL_FROZE,
	reg & ALL_FROZE,
	freeze ? ALL_FROZE : 0ull);		freeze ? ALL_FROZE : 0ull);
	return;		return;
	}		}
	@@ -7166,12 +7168,7 @@ void handle_verify_cap(struct work_struct *work)
	*/		*/

	read_vc_remote_phy(dd, &power_management, &continious);		read_vc_remote_phy(dd, &power_management, &continious);
	read_vc_remote_fabric(		read_vc_remote_fabric(dd, &vau, &z, &vcu, &vl15buf,
	dd,
	&vau,
	&z,
	&vcu,
	&vl15buf,
	&partner_supported_crc);		&partner_supported_crc);
	read_vc_remote_link_width(dd, &remote_tx_rate, &link_widths);		read_vc_remote_link_width(dd, &remote_tx_rate, &link_widths);
	read_remote_device_id(dd, &device_id, &device_rev);		read_remote_device_id(dd, &device_id, &device_rev);
	@@ -7187,10 +7184,7 @@ void handle_verify_cap(struct work_struct *work)
	(int)power_management, (int)continious);		(int)power_management, (int)continious);
	dd_dev_info(dd,		dd_dev_info(dd,
	"Peer Fabric: vAU %d, Z %d, vCU %d, vl15 credits 0x%x, CRC sizes 0x%x\n",		"Peer Fabric: vAU %d, Z %d, vCU %d, vl15 credits 0x%x, CRC sizes 0x%x\n",
	(int)vau,		(int)vau, (int)z, (int)vcu, (int)vl15buf,
	(int)z,
	(int)vcu,
	(int)vl15buf,
	(int)partner_supported_crc);		(int)partner_supported_crc);
	dd_dev_info(dd, "Peer Link Width: tx rate 0x%x, widths 0x%x\n",		dd_dev_info(dd, "Peer Link Width: tx rate 0x%x, widths 0x%x\n",
	(u32)remote_tx_rate, (u32)link_widths);		(u32)remote_tx_rate, (u32)link_widths);
	@@ -7369,8 +7363,10 @@ void apply_link_downgrade_policy(struct hfi1_pportdata *ppd, int refresh_widths)
	/* downgrade is disabled */		/* downgrade is disabled */

	/* bounce if not at starting active width */		/* bounce if not at starting active width */
	if ((ppd->link_width_active != ppd->link_width_downgrade_tx_active) \|\|		if ((ppd->link_width_active !=
	(ppd->link_width_active != ppd->link_width_downgrade_rx_active)) {		ppd->link_width_downgrade_tx_active) \|\|
			(ppd->link_width_active !=
			ppd->link_width_downgrade_rx_active)) {
	dd_dev_err(ppd->dd,		dd_dev_err(ppd->dd,
	"Link downgrade is disabled and link has downgraded, downing link\n");		"Link downgrade is disabled and link has downgraded, downing link\n");
	dd_dev_err(ppd->dd,		dd_dev_err(ppd->dd,
	@@ -7387,8 +7383,7 @@ void apply_link_downgrade_policy(struct hfi1_pportdata *ppd, int refresh_widths)
	"Link is outside of downgrade allowed, downing link\n");		"Link is outside of downgrade allowed, downing link\n");
	dd_dev_err(ppd->dd,		dd_dev_err(ppd->dd,
	" enabled 0x%x, tx active 0x%x, rx active 0x%x\n",		" enabled 0x%x, tx active 0x%x, rx active 0x%x\n",
	lwde,		lwde, ppd->link_width_downgrade_tx_active,
	ppd->link_width_downgrade_tx_active,
	ppd->link_width_downgrade_rx_active);		ppd->link_width_downgrade_rx_active);
	do_bounce = 1;		do_bounce = 1;
	}		}
	@@ -7483,7 +7478,8 @@ static void handle_8051_interrupt(struct hfi1_devdata *dd, u32 unused, u64 reg)
	dd_dev_info(dd, "Link error: %s\n",		dd_dev_info(dd, "Link error: %s\n",
	dc8051_info_err_string(buf,		dc8051_info_err_string(buf,
	sizeof(buf),		sizeof(buf),
	err & FAILED_LNI));		err &
			FAILED_LNI));
	}		}
	err &= ~(u64)FAILED_LNI;		err &= ~(u64)FAILED_LNI;
	}		}
	@@ -7495,7 +7491,8 @@ static void handle_8051_interrupt(struct hfi1_devdata *dd, u32 unused, u64 reg)
	if (err) {		if (err) {
	/* report remaining errors, but do not do anything */		/* report remaining errors, but do not do anything */
	dd_dev_err(dd, "8051 info error: %s\n",		dd_dev_err(dd, "8051 info error: %s\n",
	dc8051_info_err_string(buf, sizeof(buf), err));		dc8051_info_err_string(buf, sizeof(buf),
			err));
	}		}

	/*		/*
	@@ -7548,7 +7545,8 @@ static void handle_8051_interrupt(struct hfi1_devdata *dd, u32 unused, u64 reg)
	if (host_msg) {		if (host_msg) {
	/* report remaining messages, but do not do anything */		/* report remaining messages, but do not do anything */
	dd_dev_info(dd, "8051 info host message: %s\n",		dd_dev_info(dd, "8051 info host message: %s\n",
	dc8051_info_host_msg_string(buf, sizeof(buf),		dc8051_info_host_msg_string(buf,
			sizeof(buf),
	host_msg));		host_msg));
	}		}

	@@ -7562,8 +7560,8 @@ static void handle_8051_interrupt(struct hfi1_devdata *dd, u32 unused, u64 reg)
	*/		*/
	dd_dev_err(dd, "Lost 8051 heartbeat\n");		dd_dev_err(dd, "Lost 8051 heartbeat\n");
	write_csr(dd, DC_DC8051_ERR_EN,		write_csr(dd, DC_DC8051_ERR_EN,
	read_csr(dd, DC_DC8051_ERR_EN)		read_csr(dd, DC_DC8051_ERR_EN) &
	& ~DC_DC8051_ERR_EN_LOST_8051_HEART_BEAT_SMASK);		~DC_DC8051_ERR_EN_LOST_8051_HEART_BEAT_SMASK);

	reg &= ~DC_DC8051_ERR_FLG_LOST_8051_HEART_BEAT_SMASK;		reg &= ~DC_DC8051_ERR_FLG_LOST_8051_HEART_BEAT_SMASK;
	}		}
	@@ -8693,8 +8691,7 @@ static void check_fabric_firmware_versions(struct hfi1_devdata *dd)
	for (lane = 0; lane < 4; lane++) {		for (lane = 0; lane < 4; lane++) {
	ret = read_8051_config(dd, SPICO_FW_VERSION, lane, &frame);		ret = read_8051_config(dd, SPICO_FW_VERSION, lane, &frame);
	if (ret) {		if (ret) {
	dd_dev_err(		dd_dev_err(dd,
	dd,
	"Unable to read lane %d firmware details\n",		"Unable to read lane %d firmware details\n",
	lane);		lane);
	continue;		continue;
	@@ -8718,8 +8715,7 @@ static int read_idle_message(struct hfi1_devdata dd, u64 type, u64 data_out)
	{		{
	int ret;		int ret;

	ret = do_8051_command(dd, HCMD_READ_LCB_IDLE_MSG,		ret = do_8051_command(dd, HCMD_READ_LCB_IDLE_MSG, type, data_out);
	type, data_out);
	if (ret != HCMD_SUCCESS) {		if (ret != HCMD_SUCCESS) {
	dd_dev_err(dd, "read idle message: type %d, err %d\n",		dd_dev_err(dd, "read idle message: type %d, err %d\n",
	(u32)type, ret);		(u32)type, ret);
	@@ -8739,8 +8735,8 @@ static int read_idle_message(struct hfi1_devdata dd, u64 type, u64 data_out)
	*/		*/
	static int read_idle_sma(struct hfi1_devdata dd, u64 data)		static int read_idle_sma(struct hfi1_devdata dd, u64 data)
	{		{
	return read_idle_message(dd,		return read_idle_message(dd, (u64)IDLE_SMA << IDLE_MSG_TYPE_SHIFT,
	(u64)IDLE_SMA << IDLE_MSG_TYPE_SHIFT, data);		data);
	}		}

	/*		/*
	@@ -8771,8 +8767,8 @@ int send_idle_sma(struct hfi1_devdata *dd, u64 message)
	{		{
	u64 data;		u64 data;

	data = ((message & IDLE_PAYLOAD_MASK) << IDLE_PAYLOAD_SHIFT)		data = ((message & IDLE_PAYLOAD_MASK) << IDLE_PAYLOAD_SHIFT) \|
	\| ((u64)IDLE_SMA << IDLE_MSG_TYPE_SHIFT);		((u64)IDLE_SMA << IDLE_MSG_TYPE_SHIFT);
	return send_idle_message(dd, data);		return send_idle_message(dd, data);
	}		}

	@@ -8811,8 +8807,7 @@ static int do_quick_linkup(struct hfi1_devdata *dd)
	/* watch LCB_STS_LINK_TRANSFER_ACTIVE */		/* watch LCB_STS_LINK_TRANSFER_ACTIVE */
	timeout = jiffies + msecs_to_jiffies(10);		timeout = jiffies + msecs_to_jiffies(10);
	while (1) {		while (1) {
	reg = read_csr(dd,		reg = read_csr(dd, DC_LCB_STS_LINK_TRANSFER_ACTIVE);
	DC_LCB_STS_LINK_TRANSFER_ACTIVE);
	if (reg)		if (reg)
	break;		break;
	if (time_after(jiffies, timeout)) {		if (time_after(jiffies, timeout)) {
	@@ -8838,8 +8833,7 @@ static int do_quick_linkup(struct hfi1_devdata *dd)
	dd_dev_err(dd,		dd_dev_err(dd,
	"Pausing for peer to be finished with LCB set up\n");		"Pausing for peer to be finished with LCB set up\n");
	msleep(5000);		msleep(5000);
	dd_dev_err(dd,		dd_dev_err(dd, "Continuing with quick linkup\n");
	"Continuing with quick linkup\n");
	}		}

	write_csr(dd, DC_LCB_ERR_EN, 0); /* mask LCB errors */		write_csr(dd, DC_LCB_ERR_EN, 0); /* mask LCB errors */
	@@ -9010,7 +9004,8 @@ static int set_local_link_attributes(struct hfi1_pportdata *ppd)
	/*		/*
	* DC supports continuous updates.		* DC supports continuous updates.
	*/		*/
	ret = write_vc_local_phy(dd, 0 /* no power management */,		ret = write_vc_local_phy(dd,
			0 /* no power management */,
	1 /* continuous updates */);		1 /* continuous updates */);
	if (ret != HCMD_SUCCESS)		if (ret != HCMD_SUCCESS)
	goto set_local_link_attributes_fail;		goto set_local_link_attributes_fail;
	@@ -9022,7 +9017,8 @@ static int set_local_link_attributes(struct hfi1_pportdata *ppd)
	goto set_local_link_attributes_fail;		goto set_local_link_attributes_fail;

	ret = write_vc_local_link_width(dd, 0, 0,		ret = write_vc_local_link_width(dd, 0, 0,
	opa_to_vc_link_widths(ppd->link_width_enabled));		opa_to_vc_link_widths(
			ppd->link_width_enabled));
	if (ret != HCMD_SUCCESS)		if (ret != HCMD_SUCCESS)
	goto set_local_link_attributes_fail;		goto set_local_link_attributes_fail;

	@@ -9121,11 +9117,10 @@ void reset_qsfp(struct hfi1_pportdata *ppd)
	mask = (u64)QSFP_HFI0_RESET_N;		mask = (u64)QSFP_HFI0_RESET_N;
	qsfp_mask = read_csr(dd, dd->hfi1_id ? ASIC_QSFP2_OE : ASIC_QSFP1_OE);		qsfp_mask = read_csr(dd, dd->hfi1_id ? ASIC_QSFP2_OE : ASIC_QSFP1_OE);
	qsfp_mask \|= mask;		qsfp_mask \|= mask;
	write_csr(dd,		write_csr(dd, dd->hfi1_id ? ASIC_QSFP2_OE : ASIC_QSFP1_OE, qsfp_mask);
	dd->hfi1_id ? ASIC_QSFP2_OE : ASIC_QSFP1_OE, qsfp_mask);

	qsfp_mask = read_csr(dd, dd->hfi1_id ?		qsfp_mask = read_csr(dd,
	ASIC_QSFP2_OUT : ASIC_QSFP1_OUT);		dd->hfi1_id ? ASIC_QSFP2_OUT : ASIC_QSFP1_OUT);
	qsfp_mask &= ~mask;		qsfp_mask &= ~mask;
	write_csr(dd,		write_csr(dd,
	dd->hfi1_id ? ASIC_QSFP2_OUT : ASIC_QSFP1_OUT, qsfp_mask);		dd->hfi1_id ? ASIC_QSFP2_OUT : ASIC_QSFP1_OUT, qsfp_mask);
	@@ -9152,100 +9147,84 @@ static int handle_qsfp_error_conditions(struct hfi1_pportdata *ppd,

	if ((qsfp_interrupt_status[0] & QSFP_HIGH_TEMP_ALARM) \|\|		if ((qsfp_interrupt_status[0] & QSFP_HIGH_TEMP_ALARM) \|\|
	(qsfp_interrupt_status[0] & QSFP_HIGH_TEMP_WARNING))		(qsfp_interrupt_status[0] & QSFP_HIGH_TEMP_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: QSFP cable on fire\n",
	"%s: QSFP cable on fire\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[0] & QSFP_LOW_TEMP_ALARM) \|\|		if ((qsfp_interrupt_status[0] & QSFP_LOW_TEMP_ALARM) \|\|
	(qsfp_interrupt_status[0] & QSFP_LOW_TEMP_WARNING))		(qsfp_interrupt_status[0] & QSFP_LOW_TEMP_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: QSFP cable temperature too low\n",
	"%s: QSFP cable temperature too low\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[1] & QSFP_HIGH_VCC_ALARM) \|\|		if ((qsfp_interrupt_status[1] & QSFP_HIGH_VCC_ALARM) \|\|
	(qsfp_interrupt_status[1] & QSFP_HIGH_VCC_WARNING))		(qsfp_interrupt_status[1] & QSFP_HIGH_VCC_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: QSFP supply voltage too high\n",
	"%s: QSFP supply voltage too high\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[1] & QSFP_LOW_VCC_ALARM) \|\|		if ((qsfp_interrupt_status[1] & QSFP_LOW_VCC_ALARM) \|\|
	(qsfp_interrupt_status[1] & QSFP_LOW_VCC_WARNING))		(qsfp_interrupt_status[1] & QSFP_LOW_VCC_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: QSFP supply voltage too low\n",
	"%s: QSFP supply voltage too low\n",
	__func__);		__func__);

	/* Byte 2 is vendor specific */		/* Byte 2 is vendor specific */

	if ((qsfp_interrupt_status[3] & QSFP_HIGH_POWER_ALARM) \|\|		if ((qsfp_interrupt_status[3] & QSFP_HIGH_POWER_ALARM) \|\|
	(qsfp_interrupt_status[3] & QSFP_HIGH_POWER_WARNING))		(qsfp_interrupt_status[3] & QSFP_HIGH_POWER_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable RX channel 1/2 power too high\n",
	"%s: Cable RX channel 1/2 power too high\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[3] & QSFP_LOW_POWER_ALARM) \|\|		if ((qsfp_interrupt_status[3] & QSFP_LOW_POWER_ALARM) \|\|
	(qsfp_interrupt_status[3] & QSFP_LOW_POWER_WARNING))		(qsfp_interrupt_status[3] & QSFP_LOW_POWER_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable RX channel 1/2 power too low\n",
	"%s: Cable RX channel 1/2 power too low\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[4] & QSFP_HIGH_POWER_ALARM) \|\|		if ((qsfp_interrupt_status[4] & QSFP_HIGH_POWER_ALARM) \|\|
	(qsfp_interrupt_status[4] & QSFP_HIGH_POWER_WARNING))		(qsfp_interrupt_status[4] & QSFP_HIGH_POWER_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable RX channel 3/4 power too high\n",
	"%s: Cable RX channel 3/4 power too high\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[4] & QSFP_LOW_POWER_ALARM) \|\|		if ((qsfp_interrupt_status[4] & QSFP_LOW_POWER_ALARM) \|\|
	(qsfp_interrupt_status[4] & QSFP_LOW_POWER_WARNING))		(qsfp_interrupt_status[4] & QSFP_LOW_POWER_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable RX channel 3/4 power too low\n",
	"%s: Cable RX channel 3/4 power too low\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[5] & QSFP_HIGH_BIAS_ALARM) \|\|		if ((qsfp_interrupt_status[5] & QSFP_HIGH_BIAS_ALARM) \|\|
	(qsfp_interrupt_status[5] & QSFP_HIGH_BIAS_WARNING))		(qsfp_interrupt_status[5] & QSFP_HIGH_BIAS_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable TX channel 1/2 bias too high\n",
	"%s: Cable TX channel 1/2 bias too high\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[5] & QSFP_LOW_BIAS_ALARM) \|\|		if ((qsfp_interrupt_status[5] & QSFP_LOW_BIAS_ALARM) \|\|
	(qsfp_interrupt_status[5] & QSFP_LOW_BIAS_WARNING))		(qsfp_interrupt_status[5] & QSFP_LOW_BIAS_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable TX channel 1/2 bias too low\n",
	"%s: Cable TX channel 1/2 bias too low\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[6] & QSFP_HIGH_BIAS_ALARM) \|\|		if ((qsfp_interrupt_status[6] & QSFP_HIGH_BIAS_ALARM) \|\|
	(qsfp_interrupt_status[6] & QSFP_HIGH_BIAS_WARNING))		(qsfp_interrupt_status[6] & QSFP_HIGH_BIAS_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable TX channel 3/4 bias too high\n",
	"%s: Cable TX channel 3/4 bias too high\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[6] & QSFP_LOW_BIAS_ALARM) \|\|		if ((qsfp_interrupt_status[6] & QSFP_LOW_BIAS_ALARM) \|\|
	(qsfp_interrupt_status[6] & QSFP_LOW_BIAS_WARNING))		(qsfp_interrupt_status[6] & QSFP_LOW_BIAS_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable TX channel 3/4 bias too low\n",
	"%s: Cable TX channel 3/4 bias too low\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[7] & QSFP_HIGH_POWER_ALARM) \|\|		if ((qsfp_interrupt_status[7] & QSFP_HIGH_POWER_ALARM) \|\|
	(qsfp_interrupt_status[7] & QSFP_HIGH_POWER_WARNING))		(qsfp_interrupt_status[7] & QSFP_HIGH_POWER_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable TX channel 1/2 power too high\n",
	"%s: Cable TX channel 1/2 power too high\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[7] & QSFP_LOW_POWER_ALARM) \|\|		if ((qsfp_interrupt_status[7] & QSFP_LOW_POWER_ALARM) \|\|
	(qsfp_interrupt_status[7] & QSFP_LOW_POWER_WARNING))		(qsfp_interrupt_status[7] & QSFP_LOW_POWER_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable TX channel 1/2 power too low\n",
	"%s: Cable TX channel 1/2 power too low\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[8] & QSFP_HIGH_POWER_ALARM) \|\|		if ((qsfp_interrupt_status[8] & QSFP_HIGH_POWER_ALARM) \|\|
	(qsfp_interrupt_status[8] & QSFP_HIGH_POWER_WARNING))		(qsfp_interrupt_status[8] & QSFP_HIGH_POWER_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable TX channel 3/4 power too high\n",
	"%s: Cable TX channel 3/4 power too high\n",
	__func__);		__func__);

	if ((qsfp_interrupt_status[8] & QSFP_LOW_POWER_ALARM) \|\|		if ((qsfp_interrupt_status[8] & QSFP_LOW_POWER_ALARM) \|\|
	(qsfp_interrupt_status[8] & QSFP_LOW_POWER_WARNING))		(qsfp_interrupt_status[8] & QSFP_LOW_POWER_WARNING))
	dd_dev_info(dd,		dd_dev_info(dd, "%s: Cable TX channel 3/4 power too low\n",
	"%s: Cable TX channel 3/4 power too low\n",
	__func__);		__func__);

	/* Bytes 9-10 and 11-12 are reserved */		/* Bytes 9-10 and 11-12 are reserved */
	@@ -9702,11 +9681,14 @@ static void set_send_length(struct hfi1_pportdata *ppd)
	/* all kernel receive contexts have the same hdrqentsize */		/* all kernel receive contexts have the same hdrqentsize */
	for (i = 0; i < ppd->vls_supported; i++) {		for (i = 0; i < ppd->vls_supported; i++) {
	sc_set_cr_threshold(dd->vld[i].sc,		sc_set_cr_threshold(dd->vld[i].sc,
	sc_mtu_to_threshold(dd->vld[i].sc, dd->vld[i].mtu,		sc_mtu_to_threshold(dd->vld[i].sc,
	dd->rcd[0]->rcvhdrqentsize));		dd->vld[i].mtu,
			dd->rcd[0]->
			rcvhdrqentsize));
	}		}
	sc_set_cr_threshold(dd->vld[15].sc,		sc_set_cr_threshold(dd->vld[15].sc,
	sc_mtu_to_threshold(dd->vld[15].sc, dd->vld[15].mtu,		sc_mtu_to_threshold(dd->vld[15].sc,
			dd->vld[15].mtu,
	dd->rcd[0]->rcvhdrqentsize));		dd->rcd[0]->rcvhdrqentsize));

	/* Adjust maximum MTU for the port in DC */		/* Adjust maximum MTU for the port in DC */
	@@ -10071,7 +10053,7 @@ int set_link_state(struct hfi1_pportdata *ppd, u32 state)
	* simulator jumps from polling to link up.		* simulator jumps from polling to link up.
	* Accept that here.		* Accept that here.
	*/		*/
	/* OK */;		/* OK */
	} else if (ppd->host_link_state != HLS_GOING_UP) {		} else if (ppd->host_link_state != HLS_GOING_UP) {
	goto unexpected;		goto unexpected;
	}		}
	@@ -10845,7 +10827,8 @@ int set_buffer_control(struct hfi1_pportdata *ppd,

	if (lowering_dedicated[i]) {		if (lowering_dedicated[i]) {
	set_vl_dedicated(dd, i,		set_vl_dedicated(dd, i,
	be16_to_cpu(new_bc->vl[i].dedicated));		be16_to_cpu(new_bc->
			vl[i].dedicated));
	cur_bc.vl[i].dedicated =		cur_bc.vl[i].dedicated =
	new_bc->vl[i].dedicated;		new_bc->vl[i].dedicated;
	}		}
	@@ -10861,7 +10844,8 @@ int set_buffer_control(struct hfi1_pportdata *ppd,
	if (be16_to_cpu(new_bc->vl[i].dedicated) >		if (be16_to_cpu(new_bc->vl[i].dedicated) >
	be16_to_cpu(cur_bc.vl[i].dedicated))		be16_to_cpu(cur_bc.vl[i].dedicated))
	set_vl_dedicated(dd, i,		set_vl_dedicated(dd, i,
	be16_to_cpu(new_bc->vl[i].dedicated));		be16_to_cpu(new_bc->
			vl[i].dedicated));
	}		}
	}		}

	@@ -11152,7 +11136,8 @@ static void adjust_rcv_timeout(struct hfi1_ctxtdata *rcd, u32 npkts)
	* been verified to be in range		* been verified to be in range
	*/		*/
	write_kctxt_csr(dd, rcd->ctxt, RCV_AVAIL_TIME_OUT,		write_kctxt_csr(dd, rcd->ctxt, RCV_AVAIL_TIME_OUT,
	(u64)timeout << RCV_AVAIL_TIME_OUT_TIME_OUT_RELOAD_SHIFT);		(u64)timeout <<
			RCV_AVAIL_TIME_OUT_TIME_OUT_RELOAD_SHIFT);
	}		}

	void update_usrhead(struct hfi1_ctxtdata *rcd, u32 hd, u32 updegr, u32 egrhd,		void update_usrhead(struct hfi1_ctxtdata *rcd, u32 hd, u32 updegr, u32 egrhd,
	@@ -11863,8 +11848,7 @@ static int init_cntrs(struct hfi1_devdata *dd)
	dev_cntrs[i].offset = dd->ndevcntrs;		dev_cntrs[i].offset = dd->ndevcntrs;
	for (j = 0; j < C_VL_COUNT; j++) {		for (j = 0; j < C_VL_COUNT; j++) {
	snprintf(name, C_MAX_NAME, "%s%d",		snprintf(name, C_MAX_NAME, "%s%d",
	dev_cntrs[i].name,		dev_cntrs[i].name, vl_from_idx(j));
	vl_from_idx(j));
	sz += strlen(name);		sz += strlen(name);
	/* Add ",32" for 32-bit counters */		/* Add ",32" for 32-bit counters */
	if (dev_cntrs[i].flags & CNTR_32BIT)		if (dev_cntrs[i].flags & CNTR_32BIT)
	@@ -11987,8 +11971,7 @@ static int init_cntrs(struct hfi1_devdata *dd)
	port_cntrs[i].offset = dd->nportcntrs;		port_cntrs[i].offset = dd->nportcntrs;
	for (j = 0; j < C_VL_COUNT; j++) {		for (j = 0; j < C_VL_COUNT; j++) {
	snprintf(name, C_MAX_NAME, "%s%d",		snprintf(name, C_MAX_NAME, "%s%d",
	port_cntrs[i].name,		port_cntrs[i].name, vl_from_idx(j));
	vl_from_idx(j));
	sz += strlen(name);		sz += strlen(name);
	/* Add ",32" for 32-bit counters */		/* Add ",32" for 32-bit counters */
	if (port_cntrs[i].flags & CNTR_32BIT)		if (port_cntrs[i].flags & CNTR_32BIT)
	@@ -12021,8 +12004,7 @@ static int init_cntrs(struct hfi1_devdata *dd)
	if (port_cntrs[i].flags & CNTR_VL) {		if (port_cntrs[i].flags & CNTR_VL) {
	for (j = 0; j < C_VL_COUNT; j++) {		for (j = 0; j < C_VL_COUNT; j++) {
	snprintf(name, C_MAX_NAME, "%s%d",		snprintf(name, C_MAX_NAME, "%s%d",
	port_cntrs[i].name,		port_cntrs[i].name, vl_from_idx(j));
	vl_from_idx(j));
	memcpy(p, name, strlen(name));		memcpy(p, name, strlen(name));
	p += strlen(name);		p += strlen(name);

	@@ -13120,8 +13102,7 @@ static void reset_txe_csrs(struct hfi1_devdata *dd)
	for (i = 0; i < TXE_NUM_64_BIT_COUNTER; i++)		for (i = 0; i < TXE_NUM_64_BIT_COUNTER; i++)
	write_csr(dd, SEND_COUNTER_ARRAY64 + (8 * i), 0);		write_csr(dd, SEND_COUNTER_ARRAY64 + (8 * i), 0);
	write_csr(dd, SEND_CM_CTRL, SEND_CM_CTRL_RESETCSR);		write_csr(dd, SEND_CM_CTRL, SEND_CM_CTRL_RESETCSR);
	write_csr(dd, SEND_CM_GLOBAL_CREDIT,		write_csr(dd, SEND_CM_GLOBAL_CREDIT, SEND_CM_GLOBAL_CREDIT_RESETCSR);
	SEND_CM_GLOBAL_CREDIT_RESETCSR);
	/* SEND_CM_CREDIT_USED_STATUS read-only */		/* SEND_CM_CREDIT_USED_STATUS read-only */
	write_csr(dd, SEND_CM_TIMER_CTRL, 0);		write_csr(dd, SEND_CM_TIMER_CTRL, 0);
	write_csr(dd, SEND_CM_LOCAL_AU_TABLE0_TO3, 0);		write_csr(dd, SEND_CM_LOCAL_AU_TABLE0_TO3, 0);
	@@ -13318,8 +13299,8 @@ static void reset_rxe_csrs(struct hfi1_devdata *dd)
	write_uctxt_csr(dd, i, RCV_EGR_INDEX_HEAD, 0);		write_uctxt_csr(dd, i, RCV_EGR_INDEX_HEAD, 0);
	/* RCV_EGR_OFFSET_TAIL read-only */		/* RCV_EGR_OFFSET_TAIL read-only */
	for (j = 0; j < RXE_NUM_TID_FLOWS; j++) {		for (j = 0; j < RXE_NUM_TID_FLOWS; j++) {
	write_uctxt_csr(dd, i, RCV_TID_FLOW_TABLE + (8 * j),		write_uctxt_csr(dd, i,
	0);		RCV_TID_FLOW_TABLE + (8 * j), 0);
	}		}
	}		}
	}		}
	@@ -13519,12 +13500,12 @@ static void init_kdeth_qp(struct hfi1_devdata *dd)
	kdeth_qp = DEFAULT_KDETH_QP;		kdeth_qp = DEFAULT_KDETH_QP;

	write_csr(dd, SEND_BTH_QP,		write_csr(dd, SEND_BTH_QP,
	(kdeth_qp & SEND_BTH_QP_KDETH_QP_MASK)		(kdeth_qp & SEND_BTH_QP_KDETH_QP_MASK) <<
	<< SEND_BTH_QP_KDETH_QP_SHIFT);		SEND_BTH_QP_KDETH_QP_SHIFT);

	write_csr(dd, RCV_BTH_QP,		write_csr(dd, RCV_BTH_QP,
	(kdeth_qp & RCV_BTH_QP_KDETH_QP_MASK)		(kdeth_qp & RCV_BTH_QP_KDETH_QP_MASK) <<
	<< RCV_BTH_QP_KDETH_QP_SHIFT);		RCV_BTH_QP_KDETH_QP_SHIFT);
	}		}

	/**		/**
	@@ -13649,12 +13630,11 @@ static void init_qos(struct hfi1_devdata *dd, u32 first_ctxt)
	write_csr(dd, RCV_RSM_MAP_TABLE + (8 * i), rsmmap[i]);		write_csr(dd, RCV_RSM_MAP_TABLE + (8 * i), rsmmap[i]);
	/* add rule0 */		/* add rule0 */
	write_csr(dd, RCV_RSM_CFG /* + (8 * 0) */,		write_csr(dd, RCV_RSM_CFG /* + (8 * 0) */,
	RCV_RSM_CFG_ENABLE_OR_CHAIN_RSM0_MASK		RCV_RSM_CFG_ENABLE_OR_CHAIN_RSM0_MASK <<
	<< RCV_RSM_CFG_ENABLE_OR_CHAIN_RSM0_SHIFT \|		RCV_RSM_CFG_ENABLE_OR_CHAIN_RSM0_SHIFT \|
	2ull << RCV_RSM_CFG_PACKET_TYPE_SHIFT);		2ull << RCV_RSM_CFG_PACKET_TYPE_SHIFT);
	write_csr(dd, RCV_RSM_SELECT /* + (8 * 0) */,		write_csr(dd, RCV_RSM_SELECT /* + (8 * 0) */,
	LRH_BTH_MATCH_OFFSET		LRH_BTH_MATCH_OFFSET << RCV_RSM_SELECT_FIELD1_OFFSET_SHIFT \|
	<< RCV_RSM_SELECT_FIELD1_OFFSET_SHIFT \|
	LRH_SC_MATCH_OFFSET << RCV_RSM_SELECT_FIELD2_OFFSET_SHIFT \|		LRH_SC_MATCH_OFFSET << RCV_RSM_SELECT_FIELD2_OFFSET_SHIFT \|
	LRH_SC_SELECT_OFFSET << RCV_RSM_SELECT_INDEX1_OFFSET_SHIFT \|		LRH_SC_SELECT_OFFSET << RCV_RSM_SELECT_INDEX1_OFFSET_SHIFT \|
	((u64)n) << RCV_RSM_SELECT_INDEX1_WIDTH_SHIFT \|		((u64)n) << RCV_RSM_SELECT_INDEX1_WIDTH_SHIFT \|
	@@ -13682,9 +13662,8 @@ static void init_rxe(struct hfi1_devdata *dd)
	/* enable all receive errors */		/* enable all receive errors */
	write_csr(dd, RCV_ERR_MASK, ~0ull);		write_csr(dd, RCV_ERR_MASK, ~0ull);
	/* setup QPN map table - start where VL15 context leaves off */		/* setup QPN map table - start where VL15 context leaves off */
	init_qos(		init_qos(dd, dd->n_krcv_queues > MIN_KERNEL_KCTXTS ?
	dd,		MIN_KERNEL_KCTXTS : 0);
	dd->n_krcv_queues > MIN_KERNEL_KCTXTS ? MIN_KERNEL_KCTXTS : 0);
	/*		/*
	* make sure RcvCtrl.RcvWcb <= PCIe Device Control		* make sure RcvCtrl.RcvWcb <= PCIe Device Control
	* Register Max_Payload_Size (PCI_EXP_DEVCTL in Linux PCIe config		* Register Max_Payload_Size (PCI_EXP_DEVCTL in Linux PCIe config
	@@ -13721,22 +13700,20 @@ static void assign_cm_au_table(struct hfi1_devdata *dd, u32 cu,
	u32 csr0to3, u32 csr4to7)		u32 csr0to3, u32 csr4to7)
	{		{
	write_csr(dd, csr0to3,		write_csr(dd, csr0to3,
	0ull <<		0ull << SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE0_SHIFT \|
	SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE0_SHIFT		1ull << SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE1_SHIFT \|
	\| 1ull <<		2ull * cu <<
	SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE1_SHIFT		SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE2_SHIFT \|
	\| 2ull * cu <<		4ull * cu <<
	SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE2_SHIFT
	\| 4ull * cu <<
	SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE3_SHIFT);		SEND_CM_LOCAL_AU_TABLE0_TO3_LOCAL_AU_TABLE3_SHIFT);
	write_csr(dd, csr4to7,		write_csr(dd, csr4to7,
	8ull * cu <<		8ull * cu <<
	SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE4_SHIFT		SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE4_SHIFT \|
	\| 16ull * cu <<		16ull * cu <<
	SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE5_SHIFT		SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE5_SHIFT \|
	\| 32ull * cu <<		32ull * cu <<
	SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE6_SHIFT		SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE6_SHIFT \|
	\| 64ull * cu <<		64ull * cu <<
	SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE7_SHIFT);		SEND_CM_LOCAL_AU_TABLE4_TO7_LOCAL_AU_TABLE7_SHIFT);
	}		}

	@@ -13995,8 +13972,8 @@ struct hfi1_devdata hfi1_init_dd(struct pci_dev pdev,
	"Functional simulator"		"Functional simulator"
	};		};

	dd = hfi1_alloc_devdata(pdev,		dd = hfi1_alloc_devdata(pdev, NUM_IB_PORTS *
	NUM_IB_PORTS * sizeof(struct hfi1_pportdata));		sizeof(struct hfi1_pportdata));
	if (IS_ERR(dd))		if (IS_ERR(dd))
	goto bail;		goto bail;
	ppd = dd->pport;		ppd = dd->pport;
	@@ -14083,8 +14060,8 @@ struct hfi1_devdata hfi1_init_dd(struct pci_dev pdev,
	dd->icode = reg >> CCE_REVISION2_IMPL_CODE_SHIFT;		dd->icode = reg >> CCE_REVISION2_IMPL_CODE_SHIFT;
	dd->irev = reg >> CCE_REVISION2_IMPL_REVISION_SHIFT;		dd->irev = reg >> CCE_REVISION2_IMPL_REVISION_SHIFT;
	dd_dev_info(dd, "Implementation: %s, revision 0x%x\n",		dd_dev_info(dd, "Implementation: %s, revision 0x%x\n",
	dd->icode < ARRAY_SIZE(inames) ? inames[dd->icode] : "unknown",		dd->icode < ARRAY_SIZE(inames) ?
	(int)dd->irev);		inames[dd->icode] : "unknown", (int)dd->irev);

	/* speeds the hardware can support */		/* speeds the hardware can support */
	dd->pport->link_speed_supported = OPA_LINK_SPEED_25G;		dd->pport->link_speed_supported = OPA_LINK_SPEED_25G;

drivers/staging/rdma/hfi1/driver.c

+16 −16

Original line number	Original line	Diff line number	Diff line
	@@ -701,7 +701,8 @@ static inline int process_rcv_packet(struct hfi1_packet *packet, int thread)
	*/		*/
	prefetch_range(packet->ebuf,		prefetch_range(packet->ebuf,
	packet->tlen - ((packet->rcd->rcvhdrqentsize -		packet->tlen - ((packet->rcd->rcvhdrqentsize -
	(rhf_hdrq_offset(packet->rhf) + 2)) * 4));		(rhf_hdrq_offset(packet->rhf)
			+ 2)) * 4));
	}		}

	/*		/*
	@@ -958,9 +959,9 @@ int handle_receive_interrupt(struct hfi1_ctxtdata *rcd, int thread)
	prescan_rxq(rcd, &packet);		prescan_rxq(rcd, &packet);

	while (last == RCV_PKT_OK) {		while (last == RCV_PKT_OK) {
			if (unlikely(dd->do_drop &&
	if (unlikely(dd->do_drop && atomic_xchg(&dd->drop_packet,		atomic_xchg(&dd->drop_packet, DROP_PACKET_OFF) ==
	DROP_PACKET_OFF) == DROP_PACKET_ON)) {		DROP_PACKET_ON)) {
	dd->do_drop = 0;		dd->do_drop = 0;

	/* On to the next packet */		/* On to the next packet */
	@@ -990,8 +991,7 @@ int handle_receive_interrupt(struct hfi1_ctxtdata *rcd, int thread)
	if (seq != rcd->seq_cnt)		if (seq != rcd->seq_cnt)
	last = RCV_PKT_DONE;		last = RCV_PKT_DONE;
	if (needset) {		if (needset) {
	dd_dev_info(dd,		dd_dev_info(dd, "Switching to NO_DMA_RTAIL\n");
	"Switching to NO_DMA_RTAIL\n");
	set_all_nodma_rtail(dd);		set_all_nodma_rtail(dd);
	needset = 0;		needset = 0;
	}		}

drivers/staging/rdma/hfi1/eprom.c

+17 −22

Original line number	Original line	Diff line number	Diff line
	@@ -115,11 +115,9 @@ static DEFINE_MUTEX(eprom_mutex);
	static void write_enable(struct hfi1_devdata *dd)		static void write_enable(struct hfi1_devdata *dd)
	{		{
	/* raise signal */		/* raise signal */
	write_csr(dd, ASIC_GPIO_OUT,		write_csr(dd, ASIC_GPIO_OUT, read_csr(dd, ASIC_GPIO_OUT) \| EPROM_WP_N);
	read_csr(dd, ASIC_GPIO_OUT) \| EPROM_WP_N);
	/* raise enable */		/* raise enable */
	write_csr(dd, ASIC_GPIO_OE,		write_csr(dd, ASIC_GPIO_OE, read_csr(dd, ASIC_GPIO_OE) \| EPROM_WP_N);
	read_csr(dd, ASIC_GPIO_OE) \| EPROM_WP_N);
	}		}

	/*		/*
	@@ -128,11 +126,9 @@ static void write_enable(struct hfi1_devdata *dd)
	static void write_disable(struct hfi1_devdata *dd)		static void write_disable(struct hfi1_devdata *dd)
	{		{
	/* lower signal */		/* lower signal */
	write_csr(dd, ASIC_GPIO_OUT,		write_csr(dd, ASIC_GPIO_OUT, read_csr(dd, ASIC_GPIO_OUT) & ~EPROM_WP_N);
	read_csr(dd, ASIC_GPIO_OUT) & ~EPROM_WP_N);
	/* lower enable */		/* lower enable */
	write_csr(dd, ASIC_GPIO_OE,		write_csr(dd, ASIC_GPIO_OE, read_csr(dd, ASIC_GPIO_OE) & ~EPROM_WP_N);
	read_csr(dd, ASIC_GPIO_OE) & ~EPROM_WP_N);
	}		}

	/*		/*
	@@ -472,8 +468,7 @@ int eprom_init(struct hfi1_devdata *dd)
	/* reset EPROM to be sure it is in a good state */		/* reset EPROM to be sure it is in a good state */

	/* set reset */		/* set reset */
	write_csr(dd, ASIC_EEP_CTL_STAT,		write_csr(dd, ASIC_EEP_CTL_STAT, ASIC_EEP_CTL_STAT_EP_RESET_SMASK);
	ASIC_EEP_CTL_STAT_EP_RESET_SMASK);
	/* clear reset, set speed */		/* clear reset, set speed */
	write_csr(dd, ASIC_EEP_CTL_STAT,		write_csr(dd, ASIC_EEP_CTL_STAT,
	EP_SPEED_FULL << ASIC_EEP_CTL_STAT_RATE_SPI_SHIFT);		EP_SPEED_FULL << ASIC_EEP_CTL_STAT_RATE_SPI_SHIFT);

drivers/staging/rdma/hfi1/file_ops.c

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -1145,8 +1145,8 @@ static int user_init(struct file *fp)
	* has done it.		* has done it.
	*/		*/
	if (fd->subctxt) {		if (fd->subctxt) {
	ret = wait_event_interruptible(uctxt->wait,		ret = wait_event_interruptible(uctxt->wait, !test_bit(
	!test_bit(HFI1_CTXT_MASTER_UNINIT,		HFI1_CTXT_MASTER_UNINIT,
	&uctxt->event_flags));		&uctxt->event_flags));
	goto expected;		goto expected;
	}		}

drivers/staging/rdma/hfi1/firmware.c

+68 −56

File changed.

Preview size limit exceeded, changes collapsed.