Skip to content

L
linux
Commit f404f80c authored by Hariprasad Shenai's avatar Hariprasad Shenai Committed by David S. Miller
Browse files
Options

cxgb4: replace ntoh{s, l} and hton{s, l} calls with the generic byteorder 

replace ntoh{s,l} and hton{s,l} calls with the generic byteorder in
cxgb4/t4_hw.c file
Signed-off-by: default avatarHariprasad Shenai <hariprasad@chelsio.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 75daacc7
Hide whitespace changes
Inline Side-by-side
Showing with 217 additions and 182 deletions
drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
View file @ f404f80c
...@@ -214,8 +214,8 @@ static void fw_asrt(struct adapter *adap, u32 mbox_addr) ...@@ -214,8 +214,8 @@ static void fw_asrt(struct adapter *adap, u32 mbox_addr)
get_mbox_rpl(adap, (__be64 *)&asrt, sizeof(asrt) / 8, mbox_addr); get_mbox_rpl(adap, (__be64 *)&asrt, sizeof(asrt) / 8, mbox_addr);
dev_alert(adap->pdev_dev, dev_alert(adap->pdev_dev,
"FW assertion at %.16s:%u, val0 %#x, val1 %#x\n", "FW assertion at %.16s:%u, val0 %#x, val1 %#x\n",
asrt.u.assert.filename_0_7, ntohl(asrt.u.assert.line), asrt.u.assert.filename_0_7, be32_to_cpu(asrt.u.assert.line),
ntohl(asrt.u.assert.x), ntohl(asrt.u.assert.y)); be32_to_cpu(asrt.u.assert.x), be32_to_cpu(asrt.u.assert.y));
} }
static void dump_mbox(struct adapter *adap, int mbox, u32 data_reg) static void dump_mbox(struct adapter *adap, int mbox, u32 data_reg)
...@@ -1508,7 +1508,7 @@ int t4_read_flash(struct adapter *adapter, unsigned int addr, ...@@ -1508,7 +1508,7 @@ int t4_read_flash(struct adapter *adapter, unsigned int addr,
if (ret) if (ret)
return ret; return ret;
if (byte_oriented) if (byte_oriented)
*data = (__force __u32) (htonl(*data)); *data = (__force __u32)(cpu_to_be32(*data));
} }
return 0; return 0;
} }
...@@ -1869,7 +1869,7 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size) ...@@ -1869,7 +1869,7 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size)
"FW image size not multiple of 512 bytes\n"); "FW image size not multiple of 512 bytes\n");
return -EINVAL; return -EINVAL;
} }
if (ntohs(hdr->len512) * 512 != size) { if ((unsigned int)be16_to_cpu(hdr->len512) * 512 != size) {
dev_err(adap->pdev_dev, dev_err(adap->pdev_dev,
"FW image size differs from size in FW header\n"); "FW image size differs from size in FW header\n");
return -EINVAL; return -EINVAL;
...@@ -1883,7 +1883,7 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size) ...@@ -1883,7 +1883,7 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size)
return -EINVAL; return -EINVAL;
for (csum = 0, i = 0; i < size / sizeof(csum); i++) for (csum = 0, i = 0; i < size / sizeof(csum); i++)
csum += ntohl(p[i]); csum += be32_to_cpu(p[i]);
if (csum != 0xffffffff) { if (csum != 0xffffffff) {
dev_err(adap->pdev_dev, dev_err(adap->pdev_dev,
...@@ -1902,7 +1902,7 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size) ...@@ -1902,7 +1902,7 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size)
* first page with a bad version. * first page with a bad version.
*/ */
memcpy(first_page, fw_data, SF_PAGE_SIZE); memcpy(first_page, fw_data, SF_PAGE_SIZE);
((struct fw_hdr *)first_page)->fw_ver = htonl(0xffffffff); ((struct fw_hdr *)first_page)->fw_ver = cpu_to_be32(0xffffffff);
ret = t4_write_flash(adap, fw_img_start, SF_PAGE_SIZE, first_page); ret = t4_write_flash(adap, fw_img_start, SF_PAGE_SIZE, first_page);
if (ret) if (ret)
goto out; goto out;
...@@ -1997,19 +1997,22 @@ int t4_link_start(struct adapter *adap, unsigned int mbox, unsigned int port, ...@@ -1997,19 +1997,22 @@ int t4_link_start(struct adapter *adap, unsigned int mbox, unsigned int port,
fc |= FW_PORT_CAP_FC_TX; fc |= FW_PORT_CAP_FC_TX;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_portid = htonl(FW_CMD_OP_V(FW_PORT_CMD) | FW_CMD_REQUEST_F | c.op_to_portid = cpu_to_be32(FW_CMD_OP_V(FW_PORT_CMD) |
FW_CMD_EXEC_F | FW_PORT_CMD_PORTID_V(port)); FW_CMD_REQUEST_F | FW_CMD_EXEC_F |
c.action_to_len16 = htonl(FW_PORT_CMD_ACTION_V(FW_PORT_ACTION_L1_CFG) | FW_PORT_CMD_PORTID_V(port));
FW_LEN16(c)); c.action_to_len16 =
cpu_to_be32(FW_PORT_CMD_ACTION_V(FW_PORT_ACTION_L1_CFG) |
FW_LEN16(c));
if (!(lc->supported & FW_PORT_CAP_ANEG)) { if (!(lc->supported & FW_PORT_CAP_ANEG)) {
c.u.l1cfg.rcap = htonl((lc->supported & ADVERT_MASK) | fc); c.u.l1cfg.rcap = cpu_to_be32((lc->supported & ADVERT_MASK) |
fc);
lc->fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX); lc->fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
} else if (lc->autoneg == AUTONEG_DISABLE) { } else if (lc->autoneg == AUTONEG_DISABLE) {
c.u.l1cfg.rcap = htonl(lc->requested_speed | fc | mdi); c.u.l1cfg.rcap = cpu_to_be32(lc->requested_speed | fc | mdi);
lc->fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX); lc->fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
} else } else
c.u.l1cfg.rcap = htonl(lc->advertising | fc | mdi); c.u.l1cfg.rcap = cpu_to_be32(lc->advertising | fc | mdi);
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -2027,11 +2030,13 @@ int t4_restart_aneg(struct adapter *adap, unsigned int mbox, unsigned int port) ...@@ -2027,11 +2030,13 @@ int t4_restart_aneg(struct adapter *adap, unsigned int mbox, unsigned int port)
struct fw_port_cmd c; struct fw_port_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_portid = htonl(FW_CMD_OP_V(FW_PORT_CMD) | FW_CMD_REQUEST_F | c.op_to_portid = cpu_to_be32(FW_CMD_OP_V(FW_PORT_CMD) |
FW_CMD_EXEC_F | FW_PORT_CMD_PORTID_V(port)); FW_CMD_REQUEST_F | FW_CMD_EXEC_F |
c.action_to_len16 = htonl(FW_PORT_CMD_ACTION_V(FW_PORT_ACTION_L1_CFG) | FW_PORT_CMD_PORTID_V(port));
FW_LEN16(c)); c.action_to_len16 =
c.u.l1cfg.rcap = htonl(FW_PORT_CAP_ANEG); cpu_to_be32(FW_PORT_CMD_ACTION_V(FW_PORT_ACTION_L1_CFG) |
FW_LEN16(c));
c.u.l1cfg.rcap = cpu_to_be32(FW_PORT_CAP_ANEG);
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -2835,18 +2840,18 @@ int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid, ...@@ -2835,18 +2840,18 @@ int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid,
struct fw_rss_ind_tbl_cmd cmd; struct fw_rss_ind_tbl_cmd cmd;
memset(&cmd, 0, sizeof(cmd)); memset(&cmd, 0, sizeof(cmd));
cmd.op_to_viid = htonl(FW_CMD_OP_V(FW_RSS_IND_TBL_CMD) | cmd.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_RSS_IND_TBL_CMD) |
FW_CMD_REQUEST_F | FW_CMD_WRITE_F | FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
FW_RSS_IND_TBL_CMD_VIID_V(viid)); FW_RSS_IND_TBL_CMD_VIID_V(viid));
cmd.retval_len16 = htonl(FW_LEN16(cmd)); cmd.retval_len16 = cpu_to_be32(FW_LEN16(cmd));
/* each fw_rss_ind_tbl_cmd takes up to 32 entries */ /* each fw_rss_ind_tbl_cmd takes up to 32 entries */
while (n > 0) { while (n > 0) {
int nq = min(n, 32); int nq = min(n, 32);
__be32 *qp = &cmd.iq0_to_iq2; __be32 *qp = &cmd.iq0_to_iq2;
cmd.niqid = htons(nq); cmd.niqid = cpu_to_be16(nq);
cmd.startidx = htons(start); cmd.startidx = cpu_to_be16(start);
start += nq; start += nq;
n -= nq; n -= nq;
...@@ -2864,7 +2869,7 @@ int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid, ...@@ -2864,7 +2869,7 @@ int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid,
if (++rsp >= rsp_end) if (++rsp >= rsp_end)
rsp = rspq; rsp = rspq;
*qp++ = htonl(v); *qp++ = cpu_to_be32(v);
nq -= 3; nq -= 3;
} }
...@@ -2890,15 +2895,16 @@ int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode, ...@@ -2890,15 +2895,16 @@ int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode,
struct fw_rss_glb_config_cmd c; struct fw_rss_glb_config_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_write = htonl(FW_CMD_OP_V(FW_RSS_GLB_CONFIG_CMD) | c.op_to_write = cpu_to_be32(FW_CMD_OP_V(FW_RSS_GLB_CONFIG_CMD) |
FW_CMD_REQUEST_F | FW_CMD_WRITE_F); FW_CMD_REQUEST_F | FW_CMD_WRITE_F);
c.retval_len16 = htonl(FW_LEN16(c)); c.retval_len16 = cpu_to_be32(FW_LEN16(c));
if (mode == FW_RSS_GLB_CONFIG_CMD_MODE_MANUAL) { if (mode == FW_RSS_GLB_CONFIG_CMD_MODE_MANUAL) {
c.u.manual.mode_pkd = htonl(FW_RSS_GLB_CONFIG_CMD_MODE_V(mode)); c.u.manual.mode_pkd =
cpu_to_be32(FW_RSS_GLB_CONFIG_CMD_MODE_V(mode));
} else if (mode == FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) { } else if (mode == FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) {
c.u.basicvirtual.mode_pkd = c.u.basicvirtual.mode_pkd =
htonl(FW_RSS_GLB_CONFIG_CMD_MODE_V(mode)); cpu_to_be32(FW_RSS_GLB_CONFIG_CMD_MODE_V(mode));
c.u.basicvirtual.synmapen_to_hashtoeplitz = htonl(flags); c.u.basicvirtual.synmapen_to_hashtoeplitz = cpu_to_be32(flags);
} else } else
return -EINVAL; return -EINVAL;
return t4_wr_mbox(adapter, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adapter, mbox, &c, sizeof(c), NULL);
...@@ -3559,33 +3565,38 @@ int t4_wol_pat_enable(struct adapter *adap, unsigned int port, unsigned int map, ...@@ -3559,33 +3565,38 @@ int t4_wol_pat_enable(struct adapter *adap, unsigned int port, unsigned int map,
void t4_mk_filtdelwr(unsigned int ftid, struct fw_filter_wr *wr, int qid) void t4_mk_filtdelwr(unsigned int ftid, struct fw_filter_wr *wr, int qid)
{ {
memset(wr, 0, sizeof(*wr)); memset(wr, 0, sizeof(*wr));
wr->op_pkd = htonl(FW_WR_OP_V(FW_FILTER_WR)); wr->op_pkd = cpu_to_be32(FW_WR_OP_V(FW_FILTER_WR));
wr->len16_pkd = htonl(FW_WR_LEN16_V(sizeof(*wr) / 16)); wr->len16_pkd = cpu_to_be32(FW_WR_LEN16_V(sizeof(*wr) / 16));
wr->tid_to_iq = htonl(FW_FILTER_WR_TID_V(ftid) | wr->tid_to_iq = cpu_to_be32(FW_FILTER_WR_TID_V(ftid) |
FW_FILTER_WR_NOREPLY_V(qid < 0)); FW_FILTER_WR_NOREPLY_V(qid < 0));
wr->del_filter_to_l2tix = htonl(FW_FILTER_WR_DEL_FILTER_F); wr->del_filter_to_l2tix = cpu_to_be32(FW_FILTER_WR_DEL_FILTER_F);
if (qid >= 0) if (qid >= 0)
wr->rx_chan_rx_rpl_iq = htons(FW_FILTER_WR_RX_RPL_IQ_V(qid)); wr->rx_chan_rx_rpl_iq =
cpu_to_be16(FW_FILTER_WR_RX_RPL_IQ_V(qid));
} }
#define INIT_CMD(var, cmd, rd_wr) do { \ #define INIT_CMD(var, cmd, rd_wr) do { \
(var).op_to_write = htonl(FW_CMD_OP_V(FW_##cmd##_CMD) | \ (var).op_to_write = cpu_to_be32(FW_CMD_OP_V(FW_##cmd##_CMD) | \
FW_CMD_REQUEST_F | FW_CMD_##rd_wr##_F); \ FW_CMD_REQUEST_F | \
(var).retval_len16 = htonl(FW_LEN16(var)); \ FW_CMD_##rd_wr##_F); \
(var).retval_len16 = cpu_to_be32(FW_LEN16(var)); \
} while (0) } while (0)
int t4_fwaddrspace_write(struct adapter *adap, unsigned int mbox, int t4_fwaddrspace_write(struct adapter *adap, unsigned int mbox,
u32 addr, u32 val) u32 addr, u32 val)
{ {
u32 ldst_addrspace;
struct fw_ldst_cmd c; struct fw_ldst_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_addrspace = htonl(FW_CMD_OP_V(FW_LDST_CMD) | FW_CMD_REQUEST_F | ldst_addrspace = FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_FIRMWARE);
FW_CMD_WRITE_F | c.op_to_addrspace = cpu_to_be32(FW_CMD_OP_V(FW_LDST_CMD) |
FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_FIRMWARE)); FW_CMD_REQUEST_F |
c.cycles_to_len16 = htonl(FW_LEN16(c)); FW_CMD_WRITE_F |
c.u.addrval.addr = htonl(addr); ldst_addrspace);
c.u.addrval.val = htonl(val); c.cycles_to_len16 = cpu_to_be32(FW_LEN16(c));
c.u.addrval.addr = cpu_to_be32(addr);
c.u.addrval.val = cpu_to_be32(val);
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -3605,19 +3616,22 @@ int t4_mdio_rd(struct adapter *adap, unsigned int mbox, unsigned int phy_addr, ...@@ -3605,19 +3616,22 @@ int t4_mdio_rd(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
unsigned int mmd, unsigned int reg, u16 *valp) unsigned int mmd, unsigned int reg, u16 *valp)
{ {
int ret; int ret;
u32 ldst_addrspace;
struct fw_ldst_cmd c; struct fw_ldst_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_addrspace = htonl(FW_CMD_OP_V(FW_LDST_CMD) | FW_CMD_REQUEST_F | ldst_addrspace = FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_MDIO);
FW_CMD_READ_F | FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_MDIO)); c.op_to_addrspace = cpu_to_be32(FW_CMD_OP_V(FW_LDST_CMD) |
c.cycles_to_len16 = htonl(FW_LEN16(c)); FW_CMD_REQUEST_F | FW_CMD_READ_F |
c.u.mdio.paddr_mmd = htons(FW_LDST_CMD_PADDR_V(phy_addr) | ldst_addrspace);
FW_LDST_CMD_MMD_V(mmd)); c.cycles_to_len16 = cpu_to_be32(FW_LEN16(c));
c.u.mdio.raddr = htons(reg); c.u.mdio.paddr_mmd = cpu_to_be16(FW_LDST_CMD_PADDR_V(phy_addr) |
FW_LDST_CMD_MMD_V(mmd));
c.u.mdio.raddr = cpu_to_be16(reg);
ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c); ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
if (ret == 0) if (ret == 0)
*valp = ntohs(c.u.mdio.rval); *valp = be16_to_cpu(c.u.mdio.rval);
return ret; return ret;
} }
...@@ -3635,16 +3649,19 @@ int t4_mdio_rd(struct adapter *adap, unsigned int mbox, unsigned int phy_addr, ...@@ -3635,16 +3649,19 @@ int t4_mdio_rd(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
int t4_mdio_wr(struct adapter *adap, unsigned int mbox, unsigned int phy_addr, int t4_mdio_wr(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
unsigned int mmd, unsigned int reg, u16 val) unsigned int mmd, unsigned int reg, u16 val)
{ {
u32 ldst_addrspace;
struct fw_ldst_cmd c; struct fw_ldst_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_addrspace = htonl(FW_CMD_OP_V(FW_LDST_CMD) | FW_CMD_REQUEST_F | ldst_addrspace = FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_MDIO);
FW_CMD_WRITE_F | FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_MDIO)); c.op_to_addrspace = cpu_to_be32(FW_CMD_OP_V(FW_LDST_CMD) |
c.cycles_to_len16 = htonl(FW_LEN16(c)); FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
c.u.mdio.paddr_mmd = htons(FW_LDST_CMD_PADDR_V(phy_addr) | ldst_addrspace);
FW_LDST_CMD_MMD_V(mmd)); c.cycles_to_len16 = cpu_to_be32(FW_LEN16(c));
c.u.mdio.raddr = htons(reg); c.u.mdio.paddr_mmd = cpu_to_be16(FW_LDST_CMD_PADDR_V(phy_addr) |
c.u.mdio.rval = htons(val); FW_LDST_CMD_MMD_V(mmd));
c.u.mdio.raddr = cpu_to_be16(reg);
c.u.mdio.rval = cpu_to_be16(val);
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -3778,11 +3795,11 @@ int t4_fw_hello(struct adapter *adap, unsigned int mbox, unsigned int evt_mbox, ...@@ -3778,11 +3795,11 @@ int t4_fw_hello(struct adapter *adap, unsigned int mbox, unsigned int evt_mbox,
retry: retry:
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
INIT_CMD(c, HELLO, WRITE); INIT_CMD(c, HELLO, WRITE);
c.err_to_clearinit = htonl( c.err_to_clearinit = cpu_to_be32(
FW_HELLO_CMD_MASTERDIS_V(master == MASTER_CANT) | FW_HELLO_CMD_MASTERDIS_V(master == MASTER_CANT) |
FW_HELLO_CMD_MASTERFORCE_V(master == MASTER_MUST) | FW_HELLO_CMD_MASTERFORCE_V(master == MASTER_MUST) |
FW_HELLO_CMD_MBMASTER_V(master == MASTER_MUST ? mbox : FW_HELLO_CMD_MBMASTER_V(master == MASTER_MUST ?
FW_HELLO_CMD_MBMASTER_M) | mbox : FW_HELLO_CMD_MBMASTER_M) |
FW_HELLO_CMD_MBASYNCNOT_V(evt_mbox) | FW_HELLO_CMD_MBASYNCNOT_V(evt_mbox) |
FW_HELLO_CMD_STAGE_V(fw_hello_cmd_stage_os) | FW_HELLO_CMD_STAGE_V(fw_hello_cmd_stage_os) |
FW_HELLO_CMD_CLEARINIT_F); FW_HELLO_CMD_CLEARINIT_F);
...@@ -3803,7 +3820,7 @@ int t4_fw_hello(struct adapter *adap, unsigned int mbox, unsigned int evt_mbox, ...@@ -3803,7 +3820,7 @@ int t4_fw_hello(struct adapter *adap, unsigned int mbox, unsigned int evt_mbox,
return ret; return ret;
} }
v = ntohl(c.err_to_clearinit); v = be32_to_cpu(c.err_to_clearinit);
master_mbox = FW_HELLO_CMD_MBMASTER_G(v); master_mbox = FW_HELLO_CMD_MBMASTER_G(v);
if (state) { if (state) {
if (v & FW_HELLO_CMD_ERR_F) if (v & FW_HELLO_CMD_ERR_F)
...@@ -3932,7 +3949,7 @@ int t4_fw_reset(struct adapter *adap, unsigned int mbox, int reset) ...@@ -3932,7 +3949,7 @@ int t4_fw_reset(struct adapter *adap, unsigned int mbox, int reset)
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
INIT_CMD(c, RESET, WRITE); INIT_CMD(c, RESET, WRITE);
c.val = htonl(reset); c.val = cpu_to_be32(reset);
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -3965,8 +3982,8 @@ static int t4_fw_halt(struct adapter *adap, unsigned int mbox, int force) ...@@ -3965,8 +3982,8 @@ static int t4_fw_halt(struct adapter *adap, unsigned int mbox, int force)
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
INIT_CMD(c, RESET, WRITE); INIT_CMD(c, RESET, WRITE);
c.val = htonl(PIORST_F | PIORSTMODE_F); c.val = cpu_to_be32(PIORST_F | PIORSTMODE_F);
c.halt_pkd = htonl(FW_RESET_CMD_HALT_F); c.halt_pkd = cpu_to_be32(FW_RESET_CMD_HALT_F);
ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -4105,7 +4122,7 @@ int t4_fw_upgrade(struct adapter *adap, unsigned int mbox, ...@@ -4105,7 +4122,7 @@ int t4_fw_upgrade(struct adapter *adap, unsigned int mbox,
* the newly loaded firmware will handle this right by checking * the newly loaded firmware will handle this right by checking
* its header flags to see if it advertises the capability. * its header flags to see if it advertises the capability.
*/ */
reset = ((ntohl(fw_hdr->flags) & FW_HDR_FLAGS_RESET_HALT) == 0); reset = ((be32_to_cpu(fw_hdr->flags) & FW_HDR_FLAGS_RESET_HALT) == 0);
return t4_fw_restart(adap, mbox, reset); return t4_fw_restart(adap, mbox, reset);
} }
...@@ -4260,17 +4277,19 @@ int t4_query_params(struct adapter *adap, unsigned int mbox, unsigned int pf, ...@@ -4260,17 +4277,19 @@ int t4_query_params(struct adapter *adap, unsigned int mbox, unsigned int pf,
return -EINVAL; return -EINVAL;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_vfn = htonl(FW_CMD_OP_V(FW_PARAMS_CMD) | FW_CMD_REQUEST_F | c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_PARAMS_CMD) |
FW_CMD_READ_F | FW_PARAMS_CMD_PFN_V(pf) | FW_CMD_REQUEST_F | FW_CMD_READ_F |
FW_PARAMS_CMD_VFN_V(vf)); FW_PARAMS_CMD_PFN_V(pf) |
c.retval_len16 = htonl(FW_LEN16(c)); FW_PARAMS_CMD_VFN_V(vf));
c.retval_len16 = cpu_to_be32(FW_LEN16(c));
for (i = 0; i < nparams; i++, p += 2) for (i = 0; i < nparams; i++, p += 2)
*p = htonl(*params++); *p = cpu_to_be32(*params++);
ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c); ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
if (ret == 0) if (ret == 0)
for (i = 0, p = &c.param[0].val; i < nparams; i++, p += 2) for (i = 0, p = &c.param[0].val; i < nparams; i++, p += 2)
*val++ = ntohl(*p); *val++ = be32_to_cpu(*p);
return ret; return ret;
} }
...@@ -4338,13 +4357,14 @@ int t4_set_params(struct adapter *adap, unsigned int mbox, unsigned int pf, ...@@ -4338,13 +4357,14 @@ int t4_set_params(struct adapter *adap, unsigned int mbox, unsigned int pf,
return -EINVAL; return -EINVAL;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_vfn = htonl(FW_CMD_OP_V(FW_PARAMS_CMD) | FW_CMD_REQUEST_F | c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_PARAMS_CMD) |
FW_CMD_WRITE_F | FW_PARAMS_CMD_PFN_V(pf) | FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
FW_PARAMS_CMD_VFN_V(vf)); FW_PARAMS_CMD_PFN_V(pf) |
c.retval_len16 = htonl(FW_LEN16(c)); FW_PARAMS_CMD_VFN_V(vf));
c.retval_len16 = cpu_to_be32(FW_LEN16(c));
while (nparams--) { while (nparams--) {
*p++ = htonl(*params++); *p++ = cpu_to_be32(*params++);
*p++ = htonl(*val++); *p++ = cpu_to_be32(*val++);
} }
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
...@@ -4380,20 +4400,21 @@ int t4_cfg_pfvf(struct adapter *adap, unsigned int mbox, unsigned int pf, ...@@ -4380,20 +4400,21 @@ int t4_cfg_pfvf(struct adapter *adap, unsigned int mbox, unsigned int pf,
struct fw_pfvf_cmd c; struct fw_pfvf_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_vfn = htonl(FW_CMD_OP_V(FW_PFVF_CMD) | FW_CMD_REQUEST_F | c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_PFVF_CMD) | FW_CMD_REQUEST_F |
FW_CMD_WRITE_F | FW_PFVF_CMD_PFN_V(pf) | FW_CMD_WRITE_F | FW_PFVF_CMD_PFN_V(pf) |
FW_PFVF_CMD_VFN_V(vf)); FW_PFVF_CMD_VFN_V(vf));
c.retval_len16 = htonl(FW_LEN16(c)); c.retval_len16 = cpu_to_be32(FW_LEN16(c));
c.niqflint_niq = htonl(FW_PFVF_CMD_NIQFLINT_V(rxqi) | c.niqflint_niq = cpu_to_be32(FW_PFVF_CMD_NIQFLINT_V(rxqi) |
FW_PFVF_CMD_NIQ_V(rxq)); FW_PFVF_CMD_NIQ_V(rxq));
c.type_to_neq = htonl(FW_PFVF_CMD_CMASK_V(cmask) | c.type_to_neq = cpu_to_be32(FW_PFVF_CMD_CMASK_V(cmask) |
FW_PFVF_CMD_PMASK_V(pmask) | FW_PFVF_CMD_PMASK_V(pmask) |
FW_PFVF_CMD_NEQ_V(txq)); FW_PFVF_CMD_NEQ_V(txq));
c.tc_to_nexactf = htonl(FW_PFVF_CMD_TC_V(tc) | FW_PFVF_CMD_NVI_V(vi) | c.tc_to_nexactf = cpu_to_be32(FW_PFVF_CMD_TC_V(tc) |
FW_PFVF_CMD_NEXACTF_V(nexact)); FW_PFVF_CMD_NVI_V(vi) |
c.r_caps_to_nethctrl = htonl(FW_PFVF_CMD_R_CAPS_V(rcaps) | FW_PFVF_CMD_NEXACTF_V(nexact));
FW_PFVF_CMD_WX_CAPS_V(wxcaps) | c.r_caps_to_nethctrl = cpu_to_be32(FW_PFVF_CMD_R_CAPS_V(rcaps) |
FW_PFVF_CMD_NETHCTRL_V(txq_eth_ctrl)); FW_PFVF_CMD_WX_CAPS_V(wxcaps) |
FW_PFVF_CMD_NETHCTRL_V(txq_eth_ctrl));
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -4422,10 +4443,10 @@ int t4_alloc_vi(struct adapter *adap, unsigned int mbox, unsigned int port, ...@@ -4422,10 +4443,10 @@ int t4_alloc_vi(struct adapter *adap, unsigned int mbox, unsigned int port,
struct fw_vi_cmd c; struct fw_vi_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_vfn = htonl(FW_CMD_OP_V(FW_VI_CMD) | FW_CMD_REQUEST_F | c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_VI_CMD) | FW_CMD_REQUEST_F |
FW_CMD_WRITE_F | FW_CMD_EXEC_F | FW_CMD_WRITE_F | FW_CMD_EXEC_F |
FW_VI_CMD_PFN_V(pf) | FW_VI_CMD_VFN_V(vf)); FW_VI_CMD_PFN_V(pf) | FW_VI_CMD_VFN_V(vf));
c.alloc_to_len16 = htonl(FW_VI_CMD_ALLOC_F | FW_LEN16(c)); c.alloc_to_len16 = cpu_to_be32(FW_VI_CMD_ALLOC_F | FW_LEN16(c));
c.portid_pkd = FW_VI_CMD_PORTID_V(port); c.portid_pkd = FW_VI_CMD_PORTID_V(port);
c.nmac = nmac - 1; c.nmac = nmac - 1;
...@@ -4447,8 +4468,8 @@ int t4_alloc_vi(struct adapter *adap, unsigned int mbox, unsigned int port, ...@@ -4447,8 +4468,8 @@ int t4_alloc_vi(struct adapter *adap, unsigned int mbox, unsigned int port,
} }
} }
if (rss_size) if (rss_size)
*rss_size = FW_VI_CMD_RSSSIZE_G(ntohs(c.rsssize_pkd)); *rss_size = FW_VI_CMD_RSSSIZE_G(be16_to_cpu(c.rsssize_pkd));
return FW_VI_CMD_VIID_G(ntohs(c.type_viid)); return FW_VI_CMD_VIID_G(be16_to_cpu(c.type_viid));
} }
/** /**
...@@ -4484,14 +4505,16 @@ int t4_set_rxmode(struct adapter *adap, unsigned int mbox, unsigned int viid, ...@@ -4484,14 +4505,16 @@ int t4_set_rxmode(struct adapter *adap, unsigned int mbox, unsigned int viid,
vlanex = FW_VI_RXMODE_CMD_VLANEXEN_M; vlanex = FW_VI_RXMODE_CMD_VLANEXEN_M;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_RXMODE_CMD) | FW_CMD_REQUEST_F | c.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_RXMODE_CMD) |
FW_CMD_WRITE_F | FW_VI_RXMODE_CMD_VIID_V(viid)); FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
c.retval_len16 = htonl(FW_LEN16(c)); FW_VI_RXMODE_CMD_VIID_V(viid));
c.mtu_to_vlanexen = htonl(FW_VI_RXMODE_CMD_MTU_V(mtu) | c.retval_len16 = cpu_to_be32(FW_LEN16(c));
FW_VI_RXMODE_CMD_PROMISCEN_V(promisc) | c.mtu_to_vlanexen =
FW_VI_RXMODE_CMD_ALLMULTIEN_V(all_multi) | cpu_to_be32(FW_VI_RXMODE_CMD_MTU_V(mtu) |
FW_VI_RXMODE_CMD_BROADCASTEN_V(bcast) | FW_VI_RXMODE_CMD_PROMISCEN_V(promisc) |
FW_VI_RXMODE_CMD_VLANEXEN_V(vlanex)); FW_VI_RXMODE_CMD_ALLMULTIEN_V(all_multi) |
FW_VI_RXMODE_CMD_BROADCASTEN_V(bcast) |
FW_VI_RXMODE_CMD_VLANEXEN_V(vlanex));
return t4_wr_mbox_meat(adap, mbox, &c, sizeof(c), NULL, sleep_ok); return t4_wr_mbox_meat(adap, mbox, &c, sizeof(c), NULL, sleep_ok);
} }
...@@ -4532,15 +4555,17 @@ int t4_alloc_mac_filt(struct adapter *adap, unsigned int mbox, ...@@ -4532,15 +4555,17 @@ int t4_alloc_mac_filt(struct adapter *adap, unsigned int mbox,
return -EINVAL; return -EINVAL;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_MAC_CMD) | FW_CMD_REQUEST_F | c.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_MAC_CMD) |
FW_CMD_WRITE_F | (free ? FW_CMD_EXEC_F : 0) | FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
FW_VI_MAC_CMD_VIID_V(viid)); (free ? FW_CMD_EXEC_F : 0) |
c.freemacs_to_len16 = htonl(FW_VI_MAC_CMD_FREEMACS_V(free) | FW_VI_MAC_CMD_VIID_V(viid));
FW_CMD_LEN16_V((naddr + 2) / 2)); c.freemacs_to_len16 = cpu_to_be32(FW_VI_MAC_CMD_FREEMACS_V(free) |
FW_CMD_LEN16_V((naddr + 2) / 2));
for (i = 0, p = c.u.exact; i < naddr; i++, p++) { for (i = 0, p = c.u.exact; i < naddr; i++, p++) {
p->valid_to_idx = htons(FW_VI_MAC_CMD_VALID_F | p->valid_to_idx =
FW_VI_MAC_CMD_IDX_V(FW_VI_MAC_ADD_MAC)); cpu_to_be16(FW_VI_MAC_CMD_VALID_F |
FW_VI_MAC_CMD_IDX_V(FW_VI_MAC_ADD_MAC));
memcpy(p->macaddr, addr[i], sizeof(p->macaddr)); memcpy(p->macaddr, addr[i], sizeof(p->macaddr));
} }
...@@ -4549,7 +4574,7 @@ int t4_alloc_mac_filt(struct adapter *adap, unsigned int mbox, ...@@ -4549,7 +4574,7 @@ int t4_alloc_mac_filt(struct adapter *adap, unsigned int mbox,
return ret; return ret;
for (i = 0, p = c.u.exact; i < naddr; i++, p++) { for (i = 0, p = c.u.exact; i < naddr; i++, p++) {
u16 index = FW_VI_MAC_CMD_IDX_G(ntohs(p->valid_to_idx)); u16 index = FW_VI_MAC_CMD_IDX_G(be16_to_cpu(p->valid_to_idx));
if (idx) if (idx)
idx[i] = index >= max_naddr ? 0xffff : index; idx[i] = index >= max_naddr ? 0xffff : index;
...@@ -4595,17 +4620,18 @@ int t4_change_mac(struct adapter *adap, unsigned int mbox, unsigned int viid, ...@@ -4595,17 +4620,18 @@ int t4_change_mac(struct adapter *adap, unsigned int mbox, unsigned int viid,
mode = add_smt ? FW_VI_MAC_SMT_AND_MPSTCAM : FW_VI_MAC_MPS_TCAM_ENTRY; mode = add_smt ? FW_VI_MAC_SMT_AND_MPSTCAM : FW_VI_MAC_MPS_TCAM_ENTRY;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_MAC_CMD) | FW_CMD_REQUEST_F | c.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_MAC_CMD) |
FW_CMD_WRITE_F | FW_VI_MAC_CMD_VIID_V(viid)); FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
c.freemacs_to_len16 = htonl(FW_CMD_LEN16_V(1)); FW_VI_MAC_CMD_VIID_V(viid));
p->valid_to_idx = htons(FW_VI_MAC_CMD_VALID_F | c.freemacs_to_len16 = cpu_to_be32(FW_CMD_LEN16_V(1));
FW_VI_MAC_CMD_SMAC_RESULT_V(mode) | p->valid_to_idx = cpu_to_be16(FW_VI_MAC_CMD_VALID_F |
FW_VI_MAC_CMD_IDX_V(idx)); FW_VI_MAC_CMD_SMAC_RESULT_V(mode) |
FW_VI_MAC_CMD_IDX_V(idx));
memcpy(p->macaddr, addr, sizeof(p->macaddr)); memcpy(p->macaddr, addr, sizeof(p->macaddr));
ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c); ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
if (ret == 0) { if (ret == 0) {
ret = FW_VI_MAC_CMD_IDX_G(ntohs(p->valid_to_idx)); ret = FW_VI_MAC_CMD_IDX_G(be16_to_cpu(p->valid_to_idx));
if (ret >= max_mac_addr) if (ret >= max_mac_addr)
ret = -ENOMEM; ret = -ENOMEM;
} }
...@@ -4629,11 +4655,12 @@ int t4_set_addr_hash(struct adapter *adap, unsigned int mbox, unsigned int viid, ...@@ -4629,11 +4655,12 @@ int t4_set_addr_hash(struct adapter *adap, unsigned int mbox, unsigned int viid,
struct fw_vi_mac_cmd c; struct fw_vi_mac_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_MAC_CMD) | FW_CMD_REQUEST_F | c.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_MAC_CMD) |
FW_CMD_WRITE_F | FW_VI_ENABLE_CMD_VIID_V(viid)); FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
c.freemacs_to_len16 = htonl(FW_VI_MAC_CMD_HASHVECEN_F | FW_VI_ENABLE_CMD_VIID_V(viid));
FW_VI_MAC_CMD_HASHUNIEN_V(ucast) | c.freemacs_to_len16 = cpu_to_be32(FW_VI_MAC_CMD_HASHVECEN_F |
FW_CMD_LEN16_V(1)); FW_VI_MAC_CMD_HASHUNIEN_V(ucast) |
FW_CMD_LEN16_V(1));
c.u.hash.hashvec = cpu_to_be64(vec); c.u.hash.hashvec = cpu_to_be64(vec);
return t4_wr_mbox_meat(adap, mbox, &c, sizeof(c), NULL, sleep_ok); return t4_wr_mbox_meat(adap, mbox, &c, sizeof(c), NULL, sleep_ok);
} }
...@@ -4656,12 +4683,13 @@ int t4_enable_vi_params(struct adapter *adap, unsigned int mbox, ...@@ -4656,12 +4683,13 @@ int t4_enable_vi_params(struct adapter *adap, unsigned int mbox,
struct fw_vi_enable_cmd c; struct fw_vi_enable_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_ENABLE_CMD) | FW_CMD_REQUEST_F | c.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_ENABLE_CMD) |
FW_CMD_EXEC_F | FW_VI_ENABLE_CMD_VIID_V(viid)); FW_CMD_REQUEST_F | FW_CMD_EXEC_F |
FW_VI_ENABLE_CMD_VIID_V(viid));
c.ien_to_len16 = htonl(FW_VI_ENABLE_CMD_IEN_V(rx_en) | c.ien_to_len16 = cpu_to_be32(FW_VI_ENABLE_CMD_IEN_V(rx_en) |
FW_VI_ENABLE_CMD_EEN_V(tx_en) | FW_LEN16(c) | FW_VI_ENABLE_CMD_EEN_V(tx_en) |
FW_VI_ENABLE_CMD_DCB_INFO_V(dcb_en)); FW_VI_ENABLE_CMD_DCB_INFO_V(dcb_en) |
FW_LEN16(c));
return t4_wr_mbox_ns(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox_ns(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -4696,10 +4724,11 @@ int t4_identify_port(struct adapter *adap, unsigned int mbox, unsigned int viid, ...@@ -4696,10 +4724,11 @@ int t4_identify_port(struct adapter *adap, unsigned int mbox, unsigned int viid,
struct fw_vi_enable_cmd c; struct fw_vi_enable_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_ENABLE_CMD) | FW_CMD_REQUEST_F | c.op_to_viid = cpu_to_be32(FW_CMD_OP_V(FW_VI_ENABLE_CMD) |
FW_CMD_EXEC_F | FW_VI_ENABLE_CMD_VIID_V(viid)); FW_CMD_REQUEST_F | FW_CMD_EXEC_F |
c.ien_to_len16 = htonl(FW_VI_ENABLE_CMD_LED_F | FW_LEN16(c)); FW_VI_ENABLE_CMD_VIID_V(viid));
c.blinkdur = htons(nblinks); c.ien_to_len16 = cpu_to_be32(FW_VI_ENABLE_CMD_LED_F | FW_LEN16(c));
c.blinkdur = cpu_to_be16(nblinks);
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -4723,14 +4752,14 @@ int t4_iq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, ...@@ -4723,14 +4752,14 @@ int t4_iq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
struct fw_iq_cmd c; struct fw_iq_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_vfn = htonl(FW_CMD_OP_V(FW_IQ_CMD) | FW_CMD_REQUEST_F | c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_IQ_CMD) | FW_CMD_REQUEST_F |
FW_CMD_EXEC_F | FW_IQ_CMD_PFN_V(pf) | FW_CMD_EXEC_F | FW_IQ_CMD_PFN_V(pf) |
FW_IQ_CMD_VFN_V(vf)); FW_IQ_CMD_VFN_V(vf));
c.alloc_to_len16 = htonl(FW_IQ_CMD_FREE_F | FW_LEN16(c)); c.alloc_to_len16 = cpu_to_be32(FW_IQ_CMD_FREE_F | FW_LEN16(c));
c.type_to_iqandstindex = htonl(FW_IQ_CMD_TYPE_V(iqtype)); c.type_to_iqandstindex = cpu_to_be32(FW_IQ_CMD_TYPE_V(iqtype));
c.iqid = htons(iqid); c.iqid = cpu_to_be16(iqid);
c.fl0id = htons(fl0id); c.fl0id = cpu_to_be16(fl0id);
c.fl1id = htons(fl1id); c.fl1id = cpu_to_be16(fl1id);
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -4750,11 +4779,12 @@ int t4_eth_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, ...@@ -4750,11 +4779,12 @@ int t4_eth_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
struct fw_eq_eth_cmd c; struct fw_eq_eth_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_ETH_CMD) | FW_CMD_REQUEST_F | c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_EQ_ETH_CMD) |
FW_CMD_EXEC_F | FW_EQ_ETH_CMD_PFN_V(pf) | FW_CMD_REQUEST_F | FW_CMD_EXEC_F |
FW_EQ_ETH_CMD_VFN_V(vf)); FW_EQ_ETH_CMD_PFN_V(pf) |
c.alloc_to_len16 = htonl(FW_EQ_ETH_CMD_FREE_F | FW_LEN16(c)); FW_EQ_ETH_CMD_VFN_V(vf));
c.eqid_pkd = htonl(FW_EQ_ETH_CMD_EQID_V(eqid)); c.alloc_to_len16 = cpu_to_be32(FW_EQ_ETH_CMD_FREE_F | FW_LEN16(c));
c.eqid_pkd = cpu_to_be32(FW_EQ_ETH_CMD_EQID_V(eqid));
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -4774,11 +4804,12 @@ int t4_ctrl_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, ...@@ -4774,11 +4804,12 @@ int t4_ctrl_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
struct fw_eq_ctrl_cmd c; struct fw_eq_ctrl_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_CTRL_CMD) | FW_CMD_REQUEST_F | c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_EQ_CTRL_CMD) |
FW_CMD_EXEC_F | FW_EQ_CTRL_CMD_PFN_V(pf) | FW_CMD_REQUEST_F | FW_CMD_EXEC_F |
FW_EQ_CTRL_CMD_VFN_V(vf)); FW_EQ_CTRL_CMD_PFN_V(pf) |
c.alloc_to_len16 = htonl(FW_EQ_CTRL_CMD_FREE_F | FW_LEN16(c)); FW_EQ_CTRL_CMD_VFN_V(vf));
c.cmpliqid_eqid = htonl(FW_EQ_CTRL_CMD_EQID_V(eqid)); c.alloc_to_len16 = cpu_to_be32(FW_EQ_CTRL_CMD_FREE_F | FW_LEN16(c));
c.cmpliqid_eqid = cpu_to_be32(FW_EQ_CTRL_CMD_EQID_V(eqid));
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -4798,11 +4829,12 @@ int t4_ofld_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, ...@@ -4798,11 +4829,12 @@ int t4_ofld_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
struct fw_eq_ofld_cmd c; struct fw_eq_ofld_cmd c;
memset(&c, 0, sizeof(c)); memset(&c, 0, sizeof(c));
c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_OFLD_CMD) | FW_CMD_REQUEST_F | c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_EQ_OFLD_CMD) |
FW_CMD_EXEC_F | FW_EQ_OFLD_CMD_PFN_V(pf) | FW_CMD_REQUEST_F | FW_CMD_EXEC_F |
FW_EQ_OFLD_CMD_VFN_V(vf)); FW_EQ_OFLD_CMD_PFN_V(pf) |
c.alloc_to_len16 = htonl(FW_EQ_OFLD_CMD_FREE_F | FW_LEN16(c)); FW_EQ_OFLD_CMD_VFN_V(vf));
c.eqid_pkd = htonl(FW_EQ_OFLD_CMD_EQID_V(eqid)); c.alloc_to_len16 = cpu_to_be32(FW_EQ_OFLD_CMD_FREE_F | FW_LEN16(c));
c.eqid_pkd = cpu_to_be32(FW_EQ_OFLD_CMD_EQID_V(eqid));
return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL); return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
} }
...@@ -4820,11 +4852,11 @@ int t4_handle_fw_rpl(struct adapter *adap, const __be64 *rpl) ...@@ -4820,11 +4852,11 @@ int t4_handle_fw_rpl(struct adapter *adap, const __be64 *rpl)
if (opcode == FW_PORT_CMD) { /* link/module state change message */ if (opcode == FW_PORT_CMD) { /* link/module state change message */
int speed = 0, fc = 0; int speed = 0, fc = 0;
const struct fw_port_cmd *p = (void *)rpl; const struct fw_port_cmd *p = (void *)rpl;
int chan = FW_PORT_CMD_PORTID_G(ntohl(p->op_to_portid)); int chan = FW_PORT_CMD_PORTID_G(be32_to_cpu(p->op_to_portid));
int port = adap->chan_map[chan]; int port = adap->chan_map[chan];
struct port_info *pi = adap2pinfo(adap, port); struct port_info *pi = adap2pinfo(adap, port);
struct link_config *lc = &pi->link_cfg; struct link_config *lc = &pi->link_cfg;
u32 stat = ntohl(p->u.info.lstatus_to_modtype); u32 stat = be32_to_cpu(p->u.info.lstatus_to_modtype);
int link_ok = (stat & FW_PORT_CMD_LSTATUS_F) != 0; int link_ok = (stat & FW_PORT_CMD_LSTATUS_F) != 0;
u32 mod = FW_PORT_CMD_MODTYPE_G(stat); u32 mod = FW_PORT_CMD_MODTYPE_G(stat);
...@@ -5138,18 +5170,19 @@ int t4_init_devlog_params(struct adapter *adap) ...@@ -5138,18 +5170,19 @@ int t4_init_devlog_params(struct adapter *adap)
/* Otherwise, ask the firmware for it's Device Log Parameters. /* Otherwise, ask the firmware for it's Device Log Parameters.
*/ */
memset(&devlog_cmd, 0, sizeof(devlog_cmd)); memset(&devlog_cmd, 0, sizeof(devlog_cmd));
devlog_cmd.op_to_write = htonl(FW_CMD_OP_V(FW_DEVLOG_CMD) | devlog_cmd.op_to_write = cpu_to_be32(FW_CMD_OP_V(FW_DEVLOG_CMD) |
FW_CMD_REQUEST_F | FW_CMD_READ_F); FW_CMD_REQUEST_F | FW_CMD_READ_F);
devlog_cmd.retval_len16 = htonl(FW_LEN16(devlog_cmd)); devlog_cmd.retval_len16 = cpu_to_be32(FW_LEN16(devlog_cmd));
ret = t4_wr_mbox(adap, adap->mbox, &devlog_cmd, sizeof(devlog_cmd), ret = t4_wr_mbox(adap, adap->mbox, &devlog_cmd, sizeof(devlog_cmd),
&devlog_cmd); &devlog_cmd);
if (ret) if (ret)
return ret; return ret;
devlog_meminfo = ntohl(devlog_cmd.memtype_devlog_memaddr16_devlog); devlog_meminfo =
be32_to_cpu(devlog_cmd.memtype_devlog_memaddr16_devlog);
dparams->memtype = FW_DEVLOG_CMD_MEMTYPE_DEVLOG_G(devlog_meminfo); dparams->memtype = FW_DEVLOG_CMD_MEMTYPE_DEVLOG_G(devlog_meminfo);
dparams->start = FW_DEVLOG_CMD_MEMADDR16_DEVLOG_G(devlog_meminfo) << 4; dparams->start = FW_DEVLOG_CMD_MEMADDR16_DEVLOG_G(devlog_meminfo) << 4;
dparams->size = ntohl(devlog_cmd.memsize_devlog); dparams->size = be32_to_cpu(devlog_cmd.memsize_devlog);
return 0; return 0;
} }
...@@ -5298,14 +5331,15 @@ int t4_init_rss_mode(struct adapter *adap, int mbox) ...@@ -5298,14 +5331,15 @@ int t4_init_rss_mode(struct adapter *adap, int mbox)
for_each_port(adap, i) { for_each_port(adap, i) {
struct port_info *p = adap2pinfo(adap, i); struct port_info *p = adap2pinfo(adap, i);
rvc.op_to_viid = htonl(FW_CMD_OP_V(FW_RSS_VI_CONFIG_CMD) | rvc.op_to_viid =
FW_CMD_REQUEST_F | FW_CMD_READ_F | cpu_to_be32(FW_CMD_OP_V(FW_RSS_VI_CONFIG_CMD) |
FW_RSS_VI_CONFIG_CMD_VIID_V(p->viid)); FW_CMD_REQUEST_F | FW_CMD_READ_F |
rvc.retval_len16 = htonl(FW_LEN16(rvc)); FW_RSS_VI_CONFIG_CMD_VIID_V(p->viid));
rvc.retval_len16 = cpu_to_be32(FW_LEN16(rvc));
ret = t4_wr_mbox(adap, mbox, &rvc, sizeof(rvc), &rvc); ret = t4_wr_mbox(adap, mbox, &rvc, sizeof(rvc), &rvc);
if (ret) if (ret)
return ret; return ret;
p->rss_mode = ntohl(rvc.u.basicvirtual.defaultq_to_udpen); p->rss_mode = be32_to_cpu(rvc.u.basicvirtual.defaultq_to_udpen);
} }
return 0; return 0;
} }
...@@ -5327,10 +5361,10 @@ int t4_port_init(struct adapter *adap, int mbox, int pf, int vf) ...@@ -5327,10 +5361,10 @@ int t4_port_init(struct adapter *adap, int mbox, int pf, int vf)
while ((adap->params.portvec & (1 << j)) == 0) while ((adap->params.portvec & (1 << j)) == 0)
j++; j++;
c.op_to_portid = htonl(FW_CMD_OP_V(FW_PORT_CMD) | c.op_to_portid = cpu_to_be32(FW_CMD_OP_V(FW_PORT_CMD) |
FW_CMD_REQUEST_F | FW_CMD_READ_F | FW_CMD_REQUEST_F | FW_CMD_READ_F |
FW_PORT_CMD_PORTID_V(j)); FW_PORT_CMD_PORTID_V(j));
c.action_to_len16 = htonl( c.action_to_len16 = cpu_to_be32(
FW_PORT_CMD_ACTION_V(FW_PORT_ACTION_GET_PORT_INFO) | FW_PORT_CMD_ACTION_V(FW_PORT_ACTION_GET_PORT_INFO) |
FW_LEN16(c)); FW_LEN16(c));
ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c); ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
...@@ -5348,22 +5382,23 @@ int t4_port_init(struct adapter *adap, int mbox, int pf, int vf) ...@@ -5348,22 +5382,23 @@ int t4_port_init(struct adapter *adap, int mbox, int pf, int vf)
memcpy(adap->port[i]->dev_addr, addr, ETH_ALEN); memcpy(adap->port[i]->dev_addr, addr, ETH_ALEN);
adap->port[i]->dev_port = j; adap->port[i]->dev_port = j;
ret = ntohl(c.u.info.lstatus_to_modtype); ret = be32_to_cpu(c.u.info.lstatus_to_modtype);
p->mdio_addr = (ret & FW_PORT_CMD_MDIOCAP_F) ? p->mdio_addr = (ret & FW_PORT_CMD_MDIOCAP_F) ?
FW_PORT_CMD_MDIOADDR_G(ret) : -1; FW_PORT_CMD_MDIOADDR_G(ret) : -1;
p->port_type = FW_PORT_CMD_PTYPE_G(ret); p->port_type = FW_PORT_CMD_PTYPE_G(ret);
p->mod_type = FW_PORT_MOD_TYPE_NA; p->mod_type = FW_PORT_MOD_TYPE_NA;
rvc.op_to_viid = htonl(FW_CMD_OP_V(FW_RSS_VI_CONFIG_CMD) | rvc.op_to_viid =
FW_CMD_REQUEST_F | FW_CMD_READ_F | cpu_to_be32(FW_CMD_OP_V(FW_RSS_VI_CONFIG_CMD) |
FW_RSS_VI_CONFIG_CMD_VIID(p->viid)); FW_CMD_REQUEST_F | FW_CMD_READ_F |
rvc.retval_len16 = htonl(FW_LEN16(rvc)); FW_RSS_VI_CONFIG_CMD_VIID(p->viid));
rvc.retval_len16 = cpu_to_be32(FW_LEN16(rvc));
ret = t4_wr_mbox(adap, mbox, &rvc, sizeof(rvc), &rvc); ret = t4_wr_mbox(adap, mbox, &rvc, sizeof(rvc), &rvc);
if (ret) if (ret)
return ret; return ret;
p->rss_mode = ntohl(rvc.u.basicvirtual.defaultq_to_udpen); p->rss_mode = be32_to_cpu(rvc.u.basicvirtual.defaultq_to_udpen);
init_link_config(&p->link_cfg, ntohs(c.u.info.pcap)); init_link_config(&p->link_cfg, be16_to_cpu(c.u.info.pcap));
j++; j++;
} }
return 0; return 0;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7