AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2025-01-18 22:06:12 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

staging/rdma/hfi1: Fix logical continuations

Browse Source 
Move logical continuations to previous line to fix checkpatch check:
CHECK: Logical continuations should be on the previous line

Reviewed-by: Dennis Dalessandro <dennis.dalessandro@intel.com>
Reviewed-by: Ira Weiny <ira.weiny@intel.com>
Reviewed-by: Mike Marciniszyn <mike.marciniszyn@intel.com>
Signed-off-by: Jubin John <jubin.john@intel.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
This commit is contained in:
Jubin John 2016-02-14 20:20:15 -08:00 committed by Doug Ledford
parent 5161fc3ef6
commit d0d236ea34
7 changed files with 51 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
drivers/staging/rdma/hfi1/chip.c
View File

@ -6552,8 +6552,8 @@ void handle_sma_message(struct work_struct *work)
* *
* Can activate the node. Discard otherwise. * Can activate the node. Discard otherwise.
*/ */
if (ppd->host_link_state == HLS_UP_ARMED if (ppd->host_link_state == HLS_UP_ARMED &&
&& ppd->is_active_optimize_enabled) { ppd->is_active_optimize_enabled) {
ppd->neighbor_normal = 1; ppd->neighbor_normal = 1;
ret = set_link_state(ppd, HLS_UP_ACTIVE); ret = set_link_state(ppd, HLS_UP_ACTIVE);
if (ret) if (ret)
@ -7032,8 +7032,8 @@ static void get_link_widths(struct hfi1_devdata *dd, u16 *tx_width,
* handle_verify_cap(). The ASIC 8051 firmware does not correctly * handle_verify_cap(). The ASIC 8051 firmware does not correctly
* set the max_rate field in handle_verify_cap until v0.19. * set the max_rate field in handle_verify_cap until v0.19.
*/ */
if ((dd->icode == ICODE_RTL_SILICON) if ((dd->icode == ICODE_RTL_SILICON) &&
&& (dd->dc8051_ver < dc8051_ver(0, 19))) { (dd->dc8051_ver < dc8051_ver(0, 19))) {
/* max_rate: 0 = 12.5G, 1 = 25G */ /* max_rate: 0 = 12.5G, 1 = 25G */
switch (max_rate) { switch (max_rate) {
case 0: case 0:
@ -7358,10 +7358,8 @@ 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 != if ((ppd->link_width_active != ppd->link_width_downgrade_tx_active) ||
ppd->link_width_downgrade_tx_active) (ppd->link_width_active != ppd->link_width_downgrade_rx_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,
@ -7371,8 +7369,8 @@ void apply_link_downgrade_policy(struct hfi1_pportdata *ppd, int refresh_widths)
ppd->link_width_downgrade_rx_active); ppd->link_width_downgrade_rx_active);
do_bounce = 1; do_bounce = 1;
} }
} else if ((lwde & ppd->link_width_downgrade_tx_active) == 0 } else if ((lwde & ppd->link_width_downgrade_tx_active) == 0 ||
|| (lwde & ppd->link_width_downgrade_rx_active) == 0) { (lwde & ppd->link_width_downgrade_rx_active) == 0) {
/* Tx or Rx is outside the enabled policy */ /* Tx or Rx is outside the enabled policy */
dd_dev_err(ppd->dd, dd_dev_err(ppd->dd,
"Link is outside of downgrade allowed, downing link\n"); "Link is outside of downgrade allowed, downing link\n");
@ -7567,9 +7565,9 @@ static void handle_8051_interrupt(struct hfi1_devdata *dd, u32 unused, u64 reg)
if (queue_link_down) { if (queue_link_down) {
/* if the link is already going down or disabled, do not /* if the link is already going down or disabled, do not
* queue another */ * queue another */
if ((ppd->host_link_state if ((ppd->host_link_state &
& (HLS_GOING_OFFLINE | HLS_LINK_COOLDOWN)) (HLS_GOING_OFFLINE | HLS_LINK_COOLDOWN)) ||
|| ppd->link_enabled == 0) { ppd->link_enabled == 0) {
dd_dev_info(dd, "%s: not queuing link down\n", dd_dev_info(dd, "%s: not queuing link down\n",
__func__); __func__);
} else { } else {
@ -8888,10 +8886,9 @@ static int init_loopback(struct hfi1_devdata *dd)
* *
* Accept all valid loopback values. * Accept all valid loopback values.
*/ */
if ((dd->icode == ICODE_FUNCTIONAL_SIMULATOR) if ((dd->icode == ICODE_FUNCTIONAL_SIMULATOR) &&
&& (loopback == LOOPBACK_SERDES (loopback == LOOPBACK_SERDES || loopback == LOOPBACK_LCB ||
|| loopback == LOOPBACK_LCB loopback == LOOPBACK_CABLE)) {
|| loopback == LOOPBACK_CABLE)) {
loopback = LOOPBACK_LCB; loopback = LOOPBACK_LCB;
quick_linkup = 1; quick_linkup = 1;
return 0; return 0;
@ -10020,8 +10017,8 @@ int set_link_state(struct hfi1_pportdata *ppd, u32 state)
state = dd->link_default; state = dd->link_default;
/* interpret poll -> poll as a link bounce */ /* interpret poll -> poll as a link bounce */
poll_bounce = ppd->host_link_state == HLS_DN_POLL poll_bounce = ppd->host_link_state == HLS_DN_POLL &&
&& state == HLS_DN_POLL; state == HLS_DN_POLL;
dd_dev_info(dd, "%s: current %s, new %s %s%s\n", __func__, dd_dev_info(dd, "%s: current %s, new %s %s%s\n", __func__,
link_state_name(ppd->host_link_state), link_state_name(ppd->host_link_state),
@ -10048,8 +10045,8 @@ int set_link_state(struct hfi1_pportdata *ppd, u32 state)
switch (state) { switch (state) {
case HLS_UP_INIT: case HLS_UP_INIT:
if (ppd->host_link_state == HLS_DN_POLL && (quick_linkup if (ppd->host_link_state == HLS_DN_POLL &&
|| dd->icode == ICODE_FUNCTIONAL_SIMULATOR)) { (quick_linkup || dd->icode == ICODE_FUNCTIONAL_SIMULATOR)) {
/* /*
* Quick link up jumps from polling to here. * Quick link up jumps from polling to here.
* *
@ -10779,8 +10776,8 @@ int set_buffer_control(struct hfi1_pportdata *ppd,
!= cur_bc.vl[i].shared; != cur_bc.vl[i].shared;
if (this_shared_changing) if (this_shared_changing)
any_shared_limit_changing = 1; any_shared_limit_changing = 1;
if (new_bc->vl[i].dedicated != cur_bc.vl[i].dedicated if (new_bc->vl[i].dedicated != cur_bc.vl[i].dedicated ||
|| this_shared_changing) { this_shared_changing) {
changing[i] = 1; changing[i] = 1;
changing_mask |= stat_mask; changing_mask |= stat_mask;
change_count++; change_count++;
@ -11227,8 +11224,8 @@ void hfi1_rcvctrl(struct hfi1_devdata *dd, unsigned int op, int ctxt)
rcvctrl = read_kctxt_csr(dd, ctxt, RCV_CTXT_CTRL); rcvctrl = read_kctxt_csr(dd, ctxt, RCV_CTXT_CTRL);
/* if the context already enabled, don't do the extra steps */ /* if the context already enabled, don't do the extra steps */
if ((op & HFI1_RCVCTRL_CTXT_ENB) if ((op & HFI1_RCVCTRL_CTXT_ENB) &&
&& !(rcvctrl & RCV_CTXT_CTRL_ENABLE_SMASK)) { !(rcvctrl & RCV_CTXT_CTRL_ENABLE_SMASK)) {
/* reset the tail and hdr addresses, and sequence count */ /* reset the tail and hdr addresses, and sequence count */
write_kctxt_csr(dd, ctxt, RCV_HDR_ADDR, write_kctxt_csr(dd, ctxt, RCV_HDR_ADDR,
rcd->rcvhdrq_phys); rcd->rcvhdrq_phys);
@ -11344,8 +11341,8 @@ void hfi1_rcvctrl(struct hfi1_devdata *dd, unsigned int op, int ctxt)
write_kctxt_csr(dd, ctxt, RCV_CTXT_CTRL, rcd->rcvctrl); write_kctxt_csr(dd, ctxt, RCV_CTXT_CTRL, rcd->rcvctrl);
/* work around sticky RcvCtxtStatus.BlockedRHQFull */ /* work around sticky RcvCtxtStatus.BlockedRHQFull */
if (did_enable if (did_enable &&
&& (rcvctrl & RCV_CTXT_CTRL_DONT_DROP_RHQ_FULL_SMASK)) { (rcvctrl & RCV_CTXT_CTRL_DONT_DROP_RHQ_FULL_SMASK)) {
reg = read_kctxt_csr(dd, ctxt, RCV_CTXT_STATUS); reg = read_kctxt_csr(dd, ctxt, RCV_CTXT_STATUS);
if (reg != 0) { if (reg != 0) {
dd_dev_info(dd, "ctxt %d status %lld (blocked)\n", dd_dev_info(dd, "ctxt %d status %lld (blocked)\n",
@ -13989,8 +13986,8 @@ struct hfi1_devdata *hfi1_init_dd(struct pci_dev *pdev,
/* link width active is 0 when link is down */ /* link width active is 0 when link is down */
/* link width downgrade active is 0 when link is down */ /* link width downgrade active is 0 when link is down */
if (num_vls < HFI1_MIN_VLS_SUPPORTED if (num_vls < HFI1_MIN_VLS_SUPPORTED ||
|| num_vls > HFI1_MAX_VLS_SUPPORTED) { num_vls > HFI1_MAX_VLS_SUPPORTED) {
hfi1_early_err(&pdev->dev, hfi1_early_err(&pdev->dev,
"Invalid num_vls %u, using %u VLs\n", "Invalid num_vls %u, using %u VLs\n",
num_vls, HFI1_MAX_VLS_SUPPORTED); num_vls, HFI1_MAX_VLS_SUPPORTED);

6
drivers/staging/rdma/hfi1/driver.c
View File

@ -1123,9 +1123,9 @@ int set_mtu(struct hfi1_pportdata *ppd)
ppd->ibmaxlen = ppd->ibmtu + lrh_max_header_bytes(ppd->dd); ppd->ibmaxlen = ppd->ibmtu + lrh_max_header_bytes(ppd->dd);
mutex_lock(&ppd->hls_lock); mutex_lock(&ppd->hls_lock);
if (ppd->host_link_state == HLS_UP_INIT if (ppd->host_link_state == HLS_UP_INIT ||
|| ppd->host_link_state == HLS_UP_ARMED ppd->host_link_state == HLS_UP_ARMED ||
|| ppd->host_link_state == HLS_UP_ACTIVE) ppd->host_link_state == HLS_UP_ACTIVE)
is_up = 1; is_up = 1;
drain = !is_ax(dd) && is_up; drain = !is_ax(dd) && is_up;

12
drivers/staging/rdma/hfi1/file_ops.c
View File

@ -1626,12 +1626,12 @@ static ssize_t ui_read(struct file *filp, char __user *buf, size_t count,
* them. These registers are defined as having a read value * them. These registers are defined as having a read value
* of 0. * of 0.
*/ */
else if (csr_off == ASIC_GPIO_CLEAR else if (csr_off == ASIC_GPIO_CLEAR ||
|| csr_off == ASIC_GPIO_FORCE csr_off == ASIC_GPIO_FORCE ||
|| csr_off == ASIC_QSFP1_CLEAR csr_off == ASIC_QSFP1_CLEAR ||
|| csr_off == ASIC_QSFP1_FORCE csr_off == ASIC_QSFP1_FORCE ||
|| csr_off == ASIC_QSFP2_CLEAR csr_off == ASIC_QSFP2_CLEAR ||
|| csr_off == ASIC_QSFP2_FORCE) csr_off == ASIC_QSFP2_FORCE)
data = 0; data = 0;
else if (csr_off >= barlen) { else if (csr_off >= barlen) {
/* /*

20
drivers/staging/rdma/hfi1/firmware.c
View File

@ -391,19 +391,13 @@ static int invalid_header(struct hfi1_devdata *dd, const char *what,
static int verify_css_header(struct hfi1_devdata *dd, struct css_header *css) static int verify_css_header(struct hfi1_devdata *dd, struct css_header *css)
{ {
/* verify CSS header fields (most sizes are in DW, so add /4) */ /* verify CSS header fields (most sizes are in DW, so add /4) */
if (invalid_header(dd, "module_type", css->module_type, CSS_MODULE_TYPE) if (invalid_header(dd, "module_type", css->module_type, CSS_MODULE_TYPE) ||
|| invalid_header(dd, "header_len", css->header_len, invalid_header(dd, "header_len", css->header_len, (sizeof(struct firmware_file) / 4)) ||
(sizeof(struct firmware_file) / 4)) invalid_header(dd, "header_version", css->header_version, CSS_HEADER_VERSION) ||
|| invalid_header(dd, "header_version", invalid_header(dd, "module_vendor", css->module_vendor, CSS_MODULE_VENDOR) ||
css->header_version, CSS_HEADER_VERSION) invalid_header(dd, "key_size", css->key_size, KEY_SIZE / 4) ||
|| invalid_header(dd, "module_vendor", invalid_header(dd, "modulus_size", css->modulus_size, KEY_SIZE / 4) ||
css->module_vendor, CSS_MODULE_VENDOR) invalid_header(dd, "exponent_size", css->exponent_size, EXPONENT_SIZE / 4)) {
|| invalid_header(dd, "key_size",
css->key_size, KEY_SIZE / 4)
|| invalid_header(dd, "modulus_size",
css->modulus_size, KEY_SIZE / 4)
|| invalid_header(dd, "exponent_size",
css->exponent_size, EXPONENT_SIZE / 4)) {
return -EINVAL; return -EINVAL;
} }
return 0; return 0;

3
drivers/staging/rdma/hfi1/intr.c
View File

@ -131,8 +131,7 @@ void handle_linkup_change(struct hfi1_devdata *dd, u32 linkup)
* NOTE: This uses this device's vAU, vCU, and vl15_init for * NOTE: This uses this device's vAU, vCU, and vl15_init for
* the remote values. Both sides must be using the values. * the remote values. Both sides must be using the values.
*/ */
if (quick_linkup if (quick_linkup || dd->icode == ICODE_FUNCTIONAL_SIMULATOR) {
|| dd->icode == ICODE_FUNCTIONAL_SIMULATOR) {
set_up_vl15(dd, dd->vau, dd->vl15_init); set_up_vl15(dd, dd->vau, dd->vl15_init);
assign_remote_cm_au_table(dd, dd->vcu); assign_remote_cm_au_table(dd, dd->vcu);
ppd->neighbor_guid = ppd->neighbor_guid =

12
drivers/staging/rdma/hfi1/mad.c
View File

@ -1170,8 +1170,8 @@ static int __subn_set_opa_portinfo(struct opa_smp *smp, u32 am, u8 *data,
ppd->port_error_action = be32_to_cpu(pi->port_error_action); ppd->port_error_action = be32_to_cpu(pi->port_error_action);
lwe = be16_to_cpu(pi->link_width.enabled); lwe = be16_to_cpu(pi->link_width.enabled);
if (lwe) { if (lwe) {
if (lwe == OPA_LINK_WIDTH_RESET if (lwe == OPA_LINK_WIDTH_RESET ||
|| lwe == OPA_LINK_WIDTH_RESET_OLD) lwe == OPA_LINK_WIDTH_RESET_OLD)
set_link_width_enabled(ppd, ppd->link_width_supported); set_link_width_enabled(ppd, ppd->link_width_supported);
else if ((lwe & ~ppd->link_width_supported) == 0) else if ((lwe & ~ppd->link_width_supported) == 0)
set_link_width_enabled(ppd, lwe); set_link_width_enabled(ppd, lwe);
@ -1180,8 +1180,8 @@ static int __subn_set_opa_portinfo(struct opa_smp *smp, u32 am, u8 *data,
} }
lwe = be16_to_cpu(pi->link_width_downgrade.enabled); lwe = be16_to_cpu(pi->link_width_downgrade.enabled);
/* LWD.E is always applied - 0 means "disabled" */ /* LWD.E is always applied - 0 means "disabled" */
if (lwe == OPA_LINK_WIDTH_RESET if (lwe == OPA_LINK_WIDTH_RESET ||
|| lwe == OPA_LINK_WIDTH_RESET_OLD) { lwe == OPA_LINK_WIDTH_RESET_OLD) {
set_link_width_downgrade_enabled(ppd, set_link_width_downgrade_enabled(ppd,
ppd->link_width_downgrade_supported); ppd->link_width_downgrade_supported);
} else if ((lwe & ~ppd->link_width_downgrade_supported) == 0) { } else if ((lwe & ~ppd->link_width_downgrade_supported) == 0) {
@ -2335,8 +2335,8 @@ static int pma_get_opa_portstatus(struct opa_pma_mad *pmp,
return reply((struct ib_mad_hdr *)pmp); return reply((struct ib_mad_hdr *)pmp);
} }
if (nports != 1 || (port_num && port_num != port) if (nports != 1 || (port_num && port_num != port) ||
|| num_vls > OPA_MAX_VLS || (vl_select_mask & ~VL_MASK_ALL)) { num_vls > OPA_MAX_VLS || (vl_select_mask & ~VL_MASK_ALL)) {
pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD; pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
return reply((struct ib_mad_hdr *)pmp); return reply((struct ib_mad_hdr *)pmp);
} }

4
drivers/staging/rdma/hfi1/sdma.c
View File

@ -672,8 +672,8 @@ static void sdma_set_state(struct sdma_engine *sde,
ss->previous_op = ss->current_op; ss->previous_op = ss->current_op;
ss->current_state = next_state; ss->current_state = next_state;
if (ss->previous_state != sdma_state_s99_running if (ss->previous_state != sdma_state_s99_running &&
&& next_state == sdma_state_s99_running) next_state == sdma_state_s99_running)
sdma_flush(sde); sdma_flush(sde);
if (action[next_state].op_enable) if (action[next_state].op_enable)