leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

net: ethernet: ti: cpsw: move ale, cpts and drivers params under cpsw_common

Browse Source 
The ale, cpts, version, rx_packet_max, bus_freq, interrupt pacing
parameters are common per net device that uses the same h/w. So,
move them to common driver structure.

Signed-off-by: Ivan Khoronzhuk <ivan.khoronzhuk@linaro.org>
Reviewed-by: Mugunthan V N <mugunthanvnm@ti.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Ivan Khoronzhuk 2016-08-10 02:22:44 +03:00 committed by David S. Miller
parent dbc4ec522d
commit 2a05a622d8
1 changed files with 106 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

235
drivers/net/ethernet/ti/cpsw.c
View File

@ -373,28 +373,28 @@ struct cpsw_common {
struct cpsw_wr_regs __iomem *wr_regs; struct cpsw_wr_regs __iomem *wr_regs;
u8 __iomem *hw_stats; u8 __iomem *hw_stats;
struct cpsw_host_regs __iomem *host_port_regs; struct cpsw_host_regs __iomem *host_port_regs;
u32 version;
u32 coal_intvl;
u32 bus_freq_mhz;
int rx_packet_max;
struct cpsw_slave *slaves; struct cpsw_slave *slaves;
struct cpdma_ctlr *dma; struct cpdma_ctlr *dma;
struct cpdma_chan *txch, *rxch; struct cpdma_chan *txch, *rxch;
struct cpsw_ale *ale;
bool quirk_irq; bool quirk_irq;
bool rx_irq_disabled; bool rx_irq_disabled;
bool tx_irq_disabled; bool tx_irq_disabled;
u32 irqs_table[IRQ_NUM]; u32 irqs_table[IRQ_NUM];
struct cpts *cpts;
}; };
struct cpsw_priv { struct cpsw_priv {
struct net_device *ndev; struct net_device *ndev;
struct device *dev; struct device *dev;
u32 msg_enable; u32 msg_enable;
u32 version;
u32 coal_intvl;
u32 bus_freq_mhz;
int rx_packet_max;
u8 mac_addr[ETH_ALEN]; u8 mac_addr[ETH_ALEN];
struct cpsw_ale *ale;
bool rx_pause; bool rx_pause;
bool tx_pause; bool tx_pause;
struct cpts *cpts;
u32 emac_port; u32 emac_port;
struct cpsw_common *cpsw; struct cpsw_common *cpsw;
}; };
@ -502,22 +502,16 @@ static const struct cpsw_stats cpsw_gstrings_stats[] = {
n; n--) \ n; n--) \
(func)(slave++, ##arg); \ (func)(slave++, ##arg); \
} while (0) } while (0)
#define cpsw_get_slave_priv(cpsw, __slave_no__) \
(((__slave_no__ < cpsw->data.slaves) && \
(cpsw->slaves[__slave_no__].ndev)) ? \
netdev_priv(cpsw->slaves[__slave_no__].ndev) : NULL) \
#define cpsw_dual_emac_src_port_detect(cpsw, status, priv, ndev, skb) \ #define cpsw_dual_emac_src_port_detect(cpsw, status, ndev, skb) \
do { \ do { \
if (!cpsw->data.dual_emac) \ if (!cpsw->data.dual_emac) \
break; \ break; \
if (CPDMA_RX_SOURCE_PORT(status) == 1) { \ if (CPDMA_RX_SOURCE_PORT(status) == 1) { \
ndev = cpsw->slaves[0].ndev; \ ndev = cpsw->slaves[0].ndev; \
priv = netdev_priv(ndev); \
skb->dev = ndev; \ skb->dev = ndev; \
} else if (CPDMA_RX_SOURCE_PORT(status) == 2) { \ } else if (CPDMA_RX_SOURCE_PORT(status) == 2) { \
ndev = cpsw->slaves[1].ndev; \ ndev = cpsw->slaves[1].ndev; \
priv = netdev_priv(ndev); \
skb->dev = ndev; \ skb->dev = ndev; \
} \ } \
} while (0) } while (0)
@ -528,11 +522,11 @@ static const struct cpsw_stats cpsw_gstrings_stats[] = {
priv->emac_port; \ priv->emac_port; \
int slave_port = cpsw_get_slave_port( \ int slave_port = cpsw_get_slave_port( \
slave->slave_num); \ slave->slave_num); \
cpsw_ale_add_mcast(priv->ale, addr, \ cpsw_ale_add_mcast(cpsw->ale, addr, \
1 << slave_port | ALE_PORT_HOST, \ 1 << slave_port | ALE_PORT_HOST, \
ALE_VLAN, slave->port_vlan, 0); \ ALE_VLAN, slave->port_vlan, 0); \
} else { \ } else { \
cpsw_ale_add_mcast(priv->ale, addr, \ cpsw_ale_add_mcast(cpsw->ale, addr, \
ALE_ALL_PORTS, \ ALE_ALL_PORTS, \
0, 0, 0); \ 0, 0, 0); \
} \ } \
@ -545,9 +539,8 @@ static inline int cpsw_get_slave_port(u32 slave_num)
static void cpsw_set_promiscious(struct net_device *ndev, bool enable) static void cpsw_set_promiscious(struct net_device *ndev, bool enable)
{ {
struct cpsw_priv *priv = netdev_priv(ndev); struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
struct cpsw_common *cpsw = priv->cpsw; struct cpsw_ale *ale = cpsw->ale;
struct cpsw_ale *ale = priv->ale;
int i; int i;
if (cpsw->data.dual_emac) { if (cpsw->data.dual_emac) {
@ -633,7 +626,7 @@ static void cpsw_ndo_set_rx_mode(struct net_device *ndev)
if (ndev->flags & IFF_PROMISC) { if (ndev->flags & IFF_PROMISC) {
/* Enable promiscuous mode */ /* Enable promiscuous mode */
cpsw_set_promiscious(ndev, true); cpsw_set_promiscious(ndev, true);
cpsw_ale_set_allmulti(priv->ale, IFF_ALLMULTI); cpsw_ale_set_allmulti(cpsw->ale, IFF_ALLMULTI);
return; return;
} else { } else {
/* Disable promiscuous mode */ /* Disable promiscuous mode */
@ -641,10 +634,10 @@ static void cpsw_ndo_set_rx_mode(struct net_device *ndev)
} }
/* Restore allmulti on vlans if necessary */ /* Restore allmulti on vlans if necessary */
cpsw_ale_set_allmulti(priv->ale, priv->ndev->flags & IFF_ALLMULTI); cpsw_ale_set_allmulti(cpsw->ale, priv->ndev->flags & IFF_ALLMULTI);
/* Clear all mcast from ALE */ /* Clear all mcast from ALE */
cpsw_ale_flush_multicast(priv->ale, ALE_ALL_PORTS, vid); cpsw_ale_flush_multicast(cpsw->ale, ALE_ALL_PORTS, vid);
if (!netdev_mc_empty(ndev)) { if (!netdev_mc_empty(ndev)) {
struct netdev_hw_addr *ha; struct netdev_hw_addr *ha;
@ -678,14 +671,14 @@ static void cpsw_tx_handler(void *token, int len, int status)
{ {
struct sk_buff *skb = token; struct sk_buff *skb = token;
struct net_device *ndev = skb->dev; struct net_device *ndev = skb->dev;
struct cpsw_priv *priv = netdev_priv(ndev); struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
/* Check whether the queue is stopped due to stalled tx dma, if the /* Check whether the queue is stopped due to stalled tx dma, if the
* queue is stopped then start the queue as we have free desc for tx * queue is stopped then start the queue as we have free desc for tx
*/ */
if (unlikely(netif_queue_stopped(ndev))) if (unlikely(netif_queue_stopped(ndev)))
netif_wake_queue(ndev); netif_wake_queue(ndev);
cpts_tx_timestamp(priv->cpts, skb); cpts_tx_timestamp(cpsw->cpts, skb);
ndev->stats.tx_packets++; ndev->stats.tx_packets++;
ndev->stats.tx_bytes += len; ndev->stats.tx_bytes += len;
dev_kfree_skb_any(skb); dev_kfree_skb_any(skb);
@ -696,11 +689,10 @@ static void cpsw_rx_handler(void *token, int len, int status)
struct sk_buff *skb = token; struct sk_buff *skb = token;
struct sk_buff *new_skb; struct sk_buff *new_skb;
struct net_device *ndev = skb->dev; struct net_device *ndev = skb->dev;
struct cpsw_priv *priv = netdev_priv(ndev);
int ret = 0; int ret = 0;
struct cpsw_common *cpsw = priv->cpsw; struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
cpsw_dual_emac_src_port_detect(cpsw, status, priv, ndev, skb); cpsw_dual_emac_src_port_detect(cpsw, status, ndev, skb);
if (unlikely(status < 0) || unlikely(!netif_running(ndev))) { if (unlikely(status < 0) || unlikely(!netif_running(ndev))) {
bool ndev_status = false; bool ndev_status = false;
@ -730,10 +722,10 @@ static void cpsw_rx_handler(void *token, int len, int status)
return; return;
} }
new_skb = netdev_alloc_skb_ip_align(ndev, priv->rx_packet_max); new_skb = netdev_alloc_skb_ip_align(ndev, cpsw->rx_packet_max);
if (new_skb) { if (new_skb) {
skb_put(skb, len); skb_put(skb, len);
cpts_rx_timestamp(priv->cpts, skb); cpts_rx_timestamp(cpsw->cpts, skb);
skb->protocol = eth_type_trans(skb, ndev); skb->protocol = eth_type_trans(skb, ndev);
netif_receive_skb(skb); netif_receive_skb(skb);
ndev->stats.rx_bytes += len; ndev->stats.rx_bytes += len;
@ -858,7 +850,7 @@ static void _cpsw_adjust_link(struct cpsw_slave *slave,
mac_control = cpsw->data.mac_control; mac_control = cpsw->data.mac_control;
/* enable forwarding */ /* enable forwarding */
cpsw_ale_control_set(priv->ale, slave_port, cpsw_ale_control_set(cpsw->ale, slave_port,
ALE_PORT_STATE, ALE_PORT_STATE_FORWARD); ALE_PORT_STATE, ALE_PORT_STATE_FORWARD);
if (phy->speed == 1000) if (phy->speed == 1000)
@ -882,7 +874,7 @@ static void _cpsw_adjust_link(struct cpsw_slave *slave,
} else { } else {
mac_control = 0; mac_control = 0;
/* disable forwarding */ /* disable forwarding */
cpsw_ale_control_set(priv->ale, slave_port, cpsw_ale_control_set(cpsw->ale, slave_port,
ALE_PORT_STATE, ALE_PORT_STATE_DISABLE); ALE_PORT_STATE, ALE_PORT_STATE_DISABLE);
} }
@ -914,9 +906,9 @@ static void cpsw_adjust_link(struct net_device *ndev)
static int cpsw_get_coalesce(struct net_device *ndev, static int cpsw_get_coalesce(struct net_device *ndev,
struct ethtool_coalesce *coal) struct ethtool_coalesce *coal)
{ {
struct cpsw_priv *priv = netdev_priv(ndev); struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
coal->rx_coalesce_usecs = priv->coal_intvl; coal->rx_coalesce_usecs = cpsw->coal_intvl;
return 0; return 0;
} }
@ -934,7 +926,7 @@ static int cpsw_set_coalesce(struct net_device *ndev,
coal_intvl = coal->rx_coalesce_usecs; coal_intvl = coal->rx_coalesce_usecs;
int_ctrl = readl(&cpsw->wr_regs->int_control); int_ctrl = readl(&cpsw->wr_regs->int_control);
prescale = priv->bus_freq_mhz * 4; prescale = cpsw->bus_freq_mhz * 4;
if (!coal->rx_coalesce_usecs) { if (!coal->rx_coalesce_usecs) {
int_ctrl &= ~(CPSW_INTPRESCALE_MASK | CPSW_INTPACEEN); int_ctrl &= ~(CPSW_INTPRESCALE_MASK | CPSW_INTPACEEN);
@ -973,16 +965,7 @@ update_return:
writel(int_ctrl, &cpsw->wr_regs->int_control); writel(int_ctrl, &cpsw->wr_regs->int_control);
cpsw_notice(priv, timer, "Set coalesce to %d usecs.\n", coal_intvl); cpsw_notice(priv, timer, "Set coalesce to %d usecs.\n", coal_intvl);
if (cpsw->data.dual_emac) { cpsw->coal_intvl = coal_intvl;
int i;
for (i = 0; i < cpsw->data.slaves; i++) {
priv = netdev_priv(cpsw->slaves[i].ndev);
priv->coal_intvl = coal_intvl;
}
} else {
priv->coal_intvl = coal_intvl;
}
return 0; return 0;
} }
@ -1078,18 +1061,20 @@ static inline void cpsw_add_dual_emac_def_ale_entries(
struct cpsw_priv *priv, struct cpsw_slave *slave, struct cpsw_priv *priv, struct cpsw_slave *slave,
u32 slave_port) u32 slave_port)
{ {
struct cpsw_common *cpsw = priv->cpsw;
u32 port_mask = 1 << slave_port | ALE_PORT_HOST; u32 port_mask = 1 << slave_port | ALE_PORT_HOST;
if (priv->version == CPSW_VERSION_1) if (cpsw->version == CPSW_VERSION_1)
slave_write(slave, slave->port_vlan, CPSW1_PORT_VLAN); slave_write(slave, slave->port_vlan, CPSW1_PORT_VLAN);
else else
slave_write(slave, slave->port_vlan, CPSW2_PORT_VLAN); slave_write(slave, slave->port_vlan, CPSW2_PORT_VLAN);
cpsw_ale_add_vlan(priv->ale, slave->port_vlan, port_mask, cpsw_ale_add_vlan(cpsw->ale, slave->port_vlan, port_mask,
port_mask, port_mask, 0); port_mask, port_mask, 0);
cpsw_ale_add_mcast(priv->ale, priv->ndev->broadcast, cpsw_ale_add_mcast(cpsw->ale, priv->ndev->broadcast,
port_mask, ALE_VLAN, slave->port_vlan, 0); port_mask, ALE_VLAN, slave->port_vlan, 0);
cpsw_ale_add_ucast(priv->ale, priv->mac_addr, cpsw_ale_add_ucast(cpsw->ale, priv->mac_addr,
HOST_PORT_NUM, ALE_VLAN | ALE_SECURE, slave->port_vlan); HOST_PORT_NUM, ALE_VLAN |
ALE_SECURE, slave->port_vlan);
} }
static void soft_reset_slave(struct cpsw_slave *slave) static void soft_reset_slave(struct cpsw_slave *slave)
@ -1110,7 +1095,7 @@ static void cpsw_slave_open(struct cpsw_slave *slave, struct cpsw_priv *priv)
/* setup priority mapping */ /* setup priority mapping */
__raw_writel(RX_PRIORITY_MAPPING, &slave->sliver->rx_pri_map); __raw_writel(RX_PRIORITY_MAPPING, &slave->sliver->rx_pri_map);
switch (priv->version) { switch (cpsw->version) {
case CPSW_VERSION_1: case CPSW_VERSION_1:
slave_write(slave, TX_PRIORITY_MAPPING, CPSW1_TX_PRI_MAP); slave_write(slave, TX_PRIORITY_MAPPING, CPSW1_TX_PRI_MAP);
break; break;
@ -1122,7 +1107,7 @@ static void cpsw_slave_open(struct cpsw_slave *slave, struct cpsw_priv *priv)
} }
/* setup max packet size, and mac address */ /* setup max packet size, and mac address */
__raw_writel(priv->rx_packet_max, &slave->sliver->rx_maxlen); __raw_writel(cpsw->rx_packet_max, &slave->sliver->rx_maxlen);
cpsw_set_slave_mac(slave, priv); cpsw_set_slave_mac(slave, priv);
slave->mac_control = 0; /* no link yet */ slave->mac_control = 0; /* no link yet */
@ -1132,7 +1117,7 @@ static void cpsw_slave_open(struct cpsw_slave *slave, struct cpsw_priv *priv)
if (cpsw->data.dual_emac) if (cpsw->data.dual_emac)
cpsw_add_dual_emac_def_ale_entries(priv, slave, slave_port); cpsw_add_dual_emac_def_ale_entries(priv, slave, slave_port);
else else
cpsw_ale_add_mcast(priv->ale, priv->ndev->broadcast, cpsw_ale_add_mcast(cpsw->ale, priv->ndev->broadcast,
1 << slave_port, 0, 0, ALE_MCAST_FWD_2); 1 << slave_port, 0, 0, ALE_MCAST_FWD_2);
if (slave->data->phy_node) { if (slave->data->phy_node) {
@ -1173,7 +1158,7 @@ static inline void cpsw_add_default_vlan(struct cpsw_priv *priv)
int i; int i;
int unreg_mcast_mask; int unreg_mcast_mask;
reg = (priv->version == CPSW_VERSION_1) ? CPSW1_PORT_VLAN : reg = (cpsw->version == CPSW_VERSION_1) ? CPSW1_PORT_VLAN :
CPSW2_PORT_VLAN; CPSW2_PORT_VLAN;
writel(vlan, &cpsw->host_port_regs->port_vlan); writel(vlan, &cpsw->host_port_regs->port_vlan);
@ -1186,7 +1171,7 @@ static inline void cpsw_add_default_vlan(struct cpsw_priv *priv)
else else
unreg_mcast_mask = ALE_PORT_1 | ALE_PORT_2; unreg_mcast_mask = ALE_PORT_1 | ALE_PORT_2;
cpsw_ale_add_vlan(priv->ale, vlan, ALE_ALL_PORTS, cpsw_ale_add_vlan(cpsw->ale, vlan, ALE_ALL_PORTS,
ALE_ALL_PORTS, ALE_ALL_PORTS, ALE_ALL_PORTS, ALE_ALL_PORTS,
unreg_mcast_mask); unreg_mcast_mask);
} }
@ -1199,10 +1184,10 @@ static void cpsw_init_host_port(struct cpsw_priv *priv)
/* soft reset the controller and initialize ale */ /* soft reset the controller and initialize ale */
soft_reset("cpsw", &cpsw->regs->soft_reset); soft_reset("cpsw", &cpsw->regs->soft_reset);
cpsw_ale_start(priv->ale); cpsw_ale_start(cpsw->ale);
/* switch to vlan unaware mode */ /* switch to vlan unaware mode */
cpsw_ale_control_set(priv->ale, HOST_PORT_NUM, ALE_VLAN_AWARE, cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM, ALE_VLAN_AWARE,
CPSW_ALE_VLAN_AWARE); CPSW_ALE_VLAN_AWARE);
control_reg = readl(&cpsw->regs->control); control_reg = readl(&cpsw->regs->control);
control_reg |= CPSW_VLAN_AWARE; control_reg |= CPSW_VLAN_AWARE;
@ -1216,18 +1201,18 @@ static void cpsw_init_host_port(struct cpsw_priv *priv)
&cpsw->host_port_regs->cpdma_tx_pri_map); &cpsw->host_port_regs->cpdma_tx_pri_map);
__raw_writel(0, &cpsw->host_port_regs->cpdma_rx_chan_map); __raw_writel(0, &cpsw->host_port_regs->cpdma_rx_chan_map);
cpsw_ale_control_set(priv->ale, HOST_PORT_NUM, cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM,
ALE_PORT_STATE, ALE_PORT_STATE_FORWARD); ALE_PORT_STATE, ALE_PORT_STATE_FORWARD);
if (!cpsw->data.dual_emac) { if (!cpsw->data.dual_emac) {
cpsw_ale_add_ucast(priv->ale, priv->mac_addr, HOST_PORT_NUM, cpsw_ale_add_ucast(cpsw->ale, priv->mac_addr, HOST_PORT_NUM,
0, 0); 0, 0);
cpsw_ale_add_mcast(priv->ale, priv->ndev->broadcast, cpsw_ale_add_mcast(cpsw->ale, priv->ndev->broadcast,
ALE_PORT_HOST, 0, 0, ALE_MCAST_FWD_2); ALE_PORT_HOST, 0, 0, ALE_MCAST_FWD_2);
} }
} }
static void cpsw_slave_stop(struct cpsw_slave *slave, struct cpsw_priv *priv) static void cpsw_slave_stop(struct cpsw_slave *slave, struct cpsw_common *cpsw)
{ {
u32 slave_port; u32 slave_port;
@ -1238,7 +1223,7 @@ static void cpsw_slave_stop(struct cpsw_slave *slave, struct cpsw_priv *priv)
phy_stop(slave->phy); phy_stop(slave->phy);
phy_disconnect(slave->phy); phy_disconnect(slave->phy);
slave->phy = NULL; slave->phy = NULL;
cpsw_ale_control_set(priv->ale, slave_port, cpsw_ale_control_set(cpsw->ale, slave_port,
ALE_PORT_STATE, ALE_PORT_STATE_DISABLE); ALE_PORT_STATE, ALE_PORT_STATE_DISABLE);
soft_reset_slave(slave); soft_reset_slave(slave);
} }
@ -1260,7 +1245,7 @@ static int cpsw_ndo_open(struct net_device *ndev)
cpsw_intr_disable(cpsw); cpsw_intr_disable(cpsw);
netif_carrier_off(ndev); netif_carrier_off(ndev);
reg = priv->version; reg = cpsw->version;
dev_info(priv->dev, "initializing cpsw version %d.%d (%d)\n", dev_info(priv->dev, "initializing cpsw version %d.%d (%d)\n",
CPSW_MAJOR_VERSION(reg), CPSW_MINOR_VERSION(reg), CPSW_MAJOR_VERSION(reg), CPSW_MINOR_VERSION(reg),
@ -1275,7 +1260,7 @@ static int cpsw_ndo_open(struct net_device *ndev)
if (!cpsw->data.dual_emac) if (!cpsw->data.dual_emac)
cpsw_add_default_vlan(priv); cpsw_add_default_vlan(priv);
else else
cpsw_ale_add_vlan(priv->ale, cpsw->data.default_vlan, cpsw_ale_add_vlan(cpsw->ale, cpsw->data.default_vlan,
ALE_ALL_PORTS, ALE_ALL_PORTS, 0, 0); ALE_ALL_PORTS, ALE_ALL_PORTS, 0, 0);
if (!cpsw_common_res_usage_state(cpsw)) { if (!cpsw_common_res_usage_state(cpsw)) {
@ -1313,7 +1298,7 @@ static int cpsw_ndo_open(struct net_device *ndev)
ret = -ENOMEM; ret = -ENOMEM;
skb = __netdev_alloc_skb_ip_align(priv->ndev, skb = __netdev_alloc_skb_ip_align(priv->ndev,
priv->rx_packet_max, GFP_KERNEL); cpsw->rx_packet_max, GFP_KERNEL);
if (!skb) if (!skb)
goto err_cleanup; goto err_cleanup;
ret = cpdma_chan_submit(cpsw->rxch, skb, skb->data, ret = cpdma_chan_submit(cpsw->rxch, skb, skb->data,
@ -1328,7 +1313,7 @@ static int cpsw_ndo_open(struct net_device *ndev)
*/ */
cpsw_info(priv, ifup, "submitted %d rx descriptors\n", i); cpsw_info(priv, ifup, "submitted %d rx descriptors\n", i);
if (cpts_register(cpsw->dev, priv->cpts, if (cpts_register(cpsw->dev, cpsw->cpts,
cpsw->data.cpts_clock_mult, cpsw->data.cpts_clock_mult,
cpsw->data.cpts_clock_shift)) cpsw->data.cpts_clock_shift))
dev_err(priv->dev, "error registering cpts device\n"); dev_err(priv->dev, "error registering cpts device\n");
@ -1336,10 +1321,10 @@ static int cpsw_ndo_open(struct net_device *ndev)
} }
/* Enable Interrupt pacing if configured */ /* Enable Interrupt pacing if configured */
if (priv->coal_intvl != 0) { if (cpsw->coal_intvl != 0) {
struct ethtool_coalesce coal; struct ethtool_coalesce coal;
coal.rx_coalesce_usecs = priv->coal_intvl; coal.rx_coalesce_usecs = cpsw->coal_intvl;
cpsw_set_coalesce(ndev, &coal); cpsw_set_coalesce(ndev, &coal);
} }
@ -1352,7 +1337,7 @@ static int cpsw_ndo_open(struct net_device *ndev)
err_cleanup: err_cleanup:
cpdma_ctlr_stop(cpsw->dma); cpdma_ctlr_stop(cpsw->dma);
for_each_slave(priv, cpsw_slave_stop, priv); for_each_slave(priv, cpsw_slave_stop, cpsw);
pm_runtime_put_sync(cpsw->dev); pm_runtime_put_sync(cpsw->dev);
netif_carrier_off(priv->ndev); netif_carrier_off(priv->ndev);
return ret; return ret;
@ -1370,12 +1355,12 @@ static int cpsw_ndo_stop(struct net_device *ndev)
if (cpsw_common_res_usage_state(cpsw) <= 1) { if (cpsw_common_res_usage_state(cpsw) <= 1) {
napi_disable(&cpsw->napi_rx); napi_disable(&cpsw->napi_rx);
napi_disable(&cpsw->napi_tx); napi_disable(&cpsw->napi_tx);
cpts_unregister(priv->cpts); cpts_unregister(cpsw->cpts);
cpsw_intr_disable(cpsw); cpsw_intr_disable(cpsw);
cpdma_ctlr_stop(cpsw->dma); cpdma_ctlr_stop(cpsw->dma);
cpsw_ale_stop(priv->ale); cpsw_ale_stop(cpsw->ale);
} }
for_each_slave(priv, cpsw_slave_stop, priv); for_each_slave(priv, cpsw_slave_stop, cpsw);
pm_runtime_put_sync(cpsw->dev); pm_runtime_put_sync(cpsw->dev);
if (cpsw->data.dual_emac) if (cpsw->data.dual_emac)
cpsw->slaves[priv->emac_port].open_stat = false; cpsw->slaves[priv->emac_port].open_stat = false;
@ -1398,7 +1383,7 @@ static netdev_tx_t cpsw_ndo_start_xmit(struct sk_buff *skb,
} }
if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP && if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
priv->cpts->tx_enable) cpsw->cpts->tx_enable)
skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS; skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
skb_tx_timestamp(skb); skb_tx_timestamp(skb);
@ -1424,13 +1409,12 @@ fail:
#ifdef CONFIG_TI_CPTS #ifdef CONFIG_TI_CPTS
static void cpsw_hwtstamp_v1(struct cpsw_priv *priv) static void cpsw_hwtstamp_v1(struct cpsw_common *cpsw)
{ {
struct cpsw_common *cpsw = priv->cpsw;
struct cpsw_slave *slave = &cpsw->slaves[cpsw->data.active_slave]; struct cpsw_slave *slave = &cpsw->slaves[cpsw->data.active_slave];
u32 ts_en, seq_id; u32 ts_en, seq_id;
if (!priv->cpts->tx_enable && !priv->cpts->rx_enable) { if (!cpsw->cpts->tx_enable && !cpsw->cpts->rx_enable) {
slave_write(slave, 0, CPSW1_TS_CTL); slave_write(slave, 0, CPSW1_TS_CTL);
return; return;
} }
@ -1438,10 +1422,10 @@ static void cpsw_hwtstamp_v1(struct cpsw_priv *priv)
seq_id = (30 << CPSW_V1_SEQ_ID_OFS_SHIFT) | ETH_P_1588; seq_id = (30 << CPSW_V1_SEQ_ID_OFS_SHIFT) | ETH_P_1588;
ts_en = EVENT_MSG_BITS << CPSW_V1_MSG_TYPE_OFS; ts_en = EVENT_MSG_BITS << CPSW_V1_MSG_TYPE_OFS;
if (priv->cpts->tx_enable) if (cpsw->cpts->tx_enable)
ts_en |= CPSW_V1_TS_TX_EN; ts_en |= CPSW_V1_TS_TX_EN;
if (priv->cpts->rx_enable) if (cpsw->cpts->rx_enable)
ts_en |= CPSW_V1_TS_RX_EN; ts_en |= CPSW_V1_TS_RX_EN;
slave_write(slave, ts_en, CPSW1_TS_CTL); slave_write(slave, ts_en, CPSW1_TS_CTL);
@ -1460,24 +1444,24 @@ static void cpsw_hwtstamp_v2(struct cpsw_priv *priv)
slave = &cpsw->slaves[cpsw->data.active_slave]; slave = &cpsw->slaves[cpsw->data.active_slave];
ctrl = slave_read(slave, CPSW2_CONTROL); ctrl = slave_read(slave, CPSW2_CONTROL);
switch (priv->version) { switch (cpsw->version) {
case CPSW_VERSION_2: case CPSW_VERSION_2:
ctrl &= ~CTRL_V2_ALL_TS_MASK; ctrl &= ~CTRL_V2_ALL_TS_MASK;
if (priv->cpts->tx_enable) if (cpsw->cpts->tx_enable)
ctrl |= CTRL_V2_TX_TS_BITS; ctrl |= CTRL_V2_TX_TS_BITS;
if (priv->cpts->rx_enable) if (cpsw->cpts->rx_enable)
ctrl |= CTRL_V2_RX_TS_BITS; ctrl |= CTRL_V2_RX_TS_BITS;
break; break;
case CPSW_VERSION_3: case CPSW_VERSION_3:
default: default:
ctrl &= ~CTRL_V3_ALL_TS_MASK; ctrl &= ~CTRL_V3_ALL_TS_MASK;
if (priv->cpts->tx_enable) if (cpsw->cpts->tx_enable)
ctrl |= CTRL_V3_TX_TS_BITS; ctrl |= CTRL_V3_TX_TS_BITS;
if (priv->cpts->rx_enable) if (cpsw->cpts->rx_enable)
ctrl |= CTRL_V3_RX_TS_BITS; ctrl |= CTRL_V3_RX_TS_BITS;
break; break;
} }
@ -1492,12 +1476,13 @@ static void cpsw_hwtstamp_v2(struct cpsw_priv *priv)
static int cpsw_hwtstamp_set(struct net_device *dev, struct ifreq *ifr) static int cpsw_hwtstamp_set(struct net_device *dev, struct ifreq *ifr)
{ {
struct cpsw_priv *priv = netdev_priv(dev); struct cpsw_priv *priv = netdev_priv(dev);
struct cpts *cpts = priv->cpts;
struct hwtstamp_config cfg; struct hwtstamp_config cfg;
struct cpsw_common *cpsw = priv->cpsw;
struct cpts *cpts = cpsw->cpts;
if (priv->version != CPSW_VERSION_1 && if (cpsw->version != CPSW_VERSION_1 &&
priv->version != CPSW_VERSION_2 && cpsw->version != CPSW_VERSION_2 &&
priv->version != CPSW_VERSION_3) cpsw->version != CPSW_VERSION_3)
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg))) if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
@ -1537,9 +1522,9 @@ static int cpsw_hwtstamp_set(struct net_device *dev, struct ifreq *ifr)
cpts->tx_enable = cfg.tx_type == HWTSTAMP_TX_ON; cpts->tx_enable = cfg.tx_type == HWTSTAMP_TX_ON;
switch (priv->version) { switch (cpsw->version) {
case CPSW_VERSION_1: case CPSW_VERSION_1:
cpsw_hwtstamp_v1(priv); cpsw_hwtstamp_v1(cpsw);
break; break;
case CPSW_VERSION_2: case CPSW_VERSION_2:
case CPSW_VERSION_3: case CPSW_VERSION_3:
@ -1554,13 +1539,13 @@ static int cpsw_hwtstamp_set(struct net_device *dev, struct ifreq *ifr)
static int cpsw_hwtstamp_get(struct net_device *dev, struct ifreq *ifr) static int cpsw_hwtstamp_get(struct net_device *dev, struct ifreq *ifr)
{ {
struct cpsw_priv *priv = netdev_priv(dev); struct cpsw_common *cpsw = ndev_to_cpsw(dev);
struct cpts *cpts = priv->cpts; struct cpts *cpts = cpsw->cpts;
struct hwtstamp_config cfg; struct hwtstamp_config cfg;
if (priv->version != CPSW_VERSION_1 && if (cpsw->version != CPSW_VERSION_1 &&
priv->version != CPSW_VERSION_2 && cpsw->version != CPSW_VERSION_2 &&
priv->version != CPSW_VERSION_3) cpsw->version != CPSW_VERSION_3)
return -EOPNOTSUPP; return -EOPNOTSUPP;
cfg.flags = 0; cfg.flags = 0;
@ -1632,9 +1617,9 @@ static int cpsw_ndo_set_mac_address(struct net_device *ndev, void *p)
flags = ALE_VLAN; flags = ALE_VLAN;
} }
cpsw_ale_del_ucast(priv->ale, priv->mac_addr, HOST_PORT_NUM, cpsw_ale_del_ucast(cpsw->ale, priv->mac_addr, HOST_PORT_NUM,
flags, vid); flags, vid);
cpsw_ale_add_ucast(priv->ale, addr->sa_data, HOST_PORT_NUM, cpsw_ale_add_ucast(cpsw->ale, addr->sa_data, HOST_PORT_NUM,
flags, vid); flags, vid);
memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN); memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
@ -1680,27 +1665,27 @@ static inline int cpsw_add_vlan_ale_entry(struct cpsw_priv *priv,
unreg_mcast_mask = ALE_PORT_1 | ALE_PORT_2; unreg_mcast_mask = ALE_PORT_1 | ALE_PORT_2;
} }
ret = cpsw_ale_add_vlan(priv->ale, vid, port_mask, 0, port_mask, ret = cpsw_ale_add_vlan(cpsw->ale, vid, port_mask, 0, port_mask,
unreg_mcast_mask); unreg_mcast_mask);
if (ret != 0) if (ret != 0)
return ret; return ret;
ret = cpsw_ale_add_ucast(priv->ale, priv->mac_addr, ret = cpsw_ale_add_ucast(cpsw->ale, priv->mac_addr,
HOST_PORT_NUM, ALE_VLAN, vid); HOST_PORT_NUM, ALE_VLAN, vid);
if (ret != 0) if (ret != 0)
goto clean_vid; goto clean_vid;
ret = cpsw_ale_add_mcast(priv->ale, priv->ndev->broadcast, ret = cpsw_ale_add_mcast(cpsw->ale, priv->ndev->broadcast,
port_mask, ALE_VLAN, vid, 0); port_mask, ALE_VLAN, vid, 0);
if (ret != 0) if (ret != 0)
goto clean_vlan_ucast; goto clean_vlan_ucast;
return 0; return 0;
clean_vlan_ucast: clean_vlan_ucast:
cpsw_ale_del_ucast(priv->ale, priv->mac_addr, cpsw_ale_del_ucast(cpsw->ale, priv->mac_addr,
HOST_PORT_NUM, ALE_VLAN, vid); HOST_PORT_NUM, ALE_VLAN, vid);
clean_vid: clean_vid:
cpsw_ale_del_vlan(priv->ale, vid, 0); cpsw_ale_del_vlan(cpsw->ale, vid, 0);
return ret; return ret;
} }
@ -1766,16 +1751,16 @@ static int cpsw_ndo_vlan_rx_kill_vid(struct net_device *ndev,
} }
dev_info(priv->dev, "removing vlanid %d from vlan filter\n", vid); dev_info(priv->dev, "removing vlanid %d from vlan filter\n", vid);
ret = cpsw_ale_del_vlan(priv->ale, vid, 0); ret = cpsw_ale_del_vlan(cpsw->ale, vid, 0);
if (ret != 0) if (ret != 0)
return ret; return ret;
ret = cpsw_ale_del_ucast(priv->ale, priv->mac_addr, ret = cpsw_ale_del_ucast(cpsw->ale, priv->mac_addr,
HOST_PORT_NUM, ALE_VLAN, vid); HOST_PORT_NUM, ALE_VLAN, vid);
if (ret != 0) if (ret != 0)
return ret; return ret;
ret = cpsw_ale_del_mcast(priv->ale, priv->ndev->broadcast, ret = cpsw_ale_del_mcast(cpsw->ale, priv->ndev->broadcast,
0, ALE_VLAN, vid); 0, ALE_VLAN, vid);
pm_runtime_put(cpsw->dev); pm_runtime_put(cpsw->dev);
return ret; return ret;
@ -1808,13 +1793,13 @@ static int cpsw_get_regs_len(struct net_device *ndev)
static void cpsw_get_regs(struct net_device *ndev, static void cpsw_get_regs(struct net_device *ndev,
struct ethtool_regs *regs, void *p) struct ethtool_regs *regs, void *p)
{ {
struct cpsw_priv *priv = netdev_priv(ndev);
u32 *reg = p; u32 *reg = p;
struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
/* update CPSW IP version */ /* update CPSW IP version */
regs->version = priv->version; regs->version = cpsw->version;
cpsw_ale_dump(priv->ale, reg); cpsw_ale_dump(cpsw->ale, reg);
} }
static void cpsw_get_drvinfo(struct net_device *ndev, static void cpsw_get_drvinfo(struct net_device *ndev,
@ -1844,7 +1829,7 @@ static int cpsw_get_ts_info(struct net_device *ndev,
struct ethtool_ts_info *info) struct ethtool_ts_info *info)
{ {
#ifdef CONFIG_TI_CPTS #ifdef CONFIG_TI_CPTS
struct cpsw_priv *priv = netdev_priv(ndev); struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
info->so_timestamping = info->so_timestamping =
SOF_TIMESTAMPING_TX_HARDWARE | SOF_TIMESTAMPING_TX_HARDWARE |
@ -1853,7 +1838,7 @@ static int cpsw_get_ts_info(struct net_device *ndev,
SOF_TIMESTAMPING_RX_SOFTWARE | SOF_TIMESTAMPING_RX_SOFTWARE |
SOF_TIMESTAMPING_SOFTWARE | SOF_TIMESTAMPING_SOFTWARE |
SOF_TIMESTAMPING_RAW_HARDWARE; SOF_TIMESTAMPING_RAW_HARDWARE;
info->phc_index = priv->cpts->phc_index; info->phc_index = cpsw->cpts->phc_index;
info->tx_types = info->tx_types =
(1 << HWTSTAMP_TX_OFF) | (1 << HWTSTAMP_TX_OFF) |
(1 << HWTSTAMP_TX_ON); (1 << HWTSTAMP_TX_ON);
@ -2188,7 +2173,6 @@ static int cpsw_probe_dual_emac(struct cpsw_priv *priv)
priv_sl2->ndev = ndev; priv_sl2->ndev = ndev;
priv_sl2->dev = &ndev->dev; priv_sl2->dev = &ndev->dev;
priv_sl2->msg_enable = netif_msg_init(debug_level, CPSW_DEBUG); priv_sl2->msg_enable = netif_msg_init(debug_level, CPSW_DEBUG);
priv_sl2->rx_packet_max = max(rx_packet_max, 128);
if (is_valid_ether_addr(data->slave_data[1].mac_addr)) { if (is_valid_ether_addr(data->slave_data[1].mac_addr)) {
memcpy(priv_sl2->mac_addr, data->slave_data[1].mac_addr, memcpy(priv_sl2->mac_addr, data->slave_data[1].mac_addr,
@ -2202,13 +2186,8 @@ static int cpsw_probe_dual_emac(struct cpsw_priv *priv)
} }
memcpy(ndev->dev_addr, priv_sl2->mac_addr, ETH_ALEN); memcpy(ndev->dev_addr, priv_sl2->mac_addr, ETH_ALEN);
priv_sl2->coal_intvl = 0;
priv_sl2->bus_freq_mhz = priv->bus_freq_mhz;
priv_sl2->ale = priv->ale;
priv_sl2->emac_port = 1; priv_sl2->emac_port = 1;
cpsw->slaves[1].ndev = ndev; cpsw->slaves[1].ndev = ndev;
priv_sl2->cpts = priv->cpts;
priv_sl2->version = priv->version;
ndev->features |= NETIF_F_HW_VLAN_CTAG_FILTER; ndev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
ndev->netdev_ops = &cpsw_netdev_ops; ndev->netdev_ops = &cpsw_netdev_ops;
@ -2296,9 +2275,9 @@ static int cpsw_probe(struct platform_device *pdev)
priv->ndev = ndev; priv->ndev = ndev;
priv->dev = &ndev->dev; priv->dev = &ndev->dev;
priv->msg_enable = netif_msg_init(debug_level, CPSW_DEBUG); priv->msg_enable = netif_msg_init(debug_level, CPSW_DEBUG);
priv->rx_packet_max = max(rx_packet_max, 128); cpsw->rx_packet_max = max(rx_packet_max, 128);
priv->cpts = devm_kzalloc(&pdev->dev, sizeof(struct cpts), GFP_KERNEL); cpsw->cpts = devm_kzalloc(&pdev->dev, sizeof(struct cpts), GFP_KERNEL);
if (!priv->cpts) { if (!cpsw->cpts) {
dev_err(&pdev->dev, "error allocating cpts\n"); dev_err(&pdev->dev, "error allocating cpts\n");
ret = -ENOMEM; ret = -ENOMEM;
goto clean_ndev_ret; goto clean_ndev_ret;
@ -2355,8 +2334,7 @@ static int cpsw_probe(struct platform_device *pdev)
ret = -ENODEV; ret = -ENODEV;
goto clean_runtime_disable_ret; goto clean_runtime_disable_ret;
} }
priv->coal_intvl = 0; cpsw->bus_freq_mhz = clk_get_rate(clk) / 1000000;
priv->bus_freq_mhz = clk_get_rate(clk) / 1000000;
ss_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); ss_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
ss_regs = devm_ioremap_resource(&pdev->dev, ss_res); ss_regs = devm_ioremap_resource(&pdev->dev, ss_res);
@ -2374,7 +2352,7 @@ static int cpsw_probe(struct platform_device *pdev)
pm_runtime_put_noidle(&pdev->dev); pm_runtime_put_noidle(&pdev->dev);
goto clean_runtime_disable_ret; goto clean_runtime_disable_ret;
} }
priv->version = readl(&cpsw->regs->id_ver); cpsw->version = readl(&cpsw->regs->id_ver);
pm_runtime_put_sync(&pdev->dev); pm_runtime_put_sync(&pdev->dev);
res = platform_get_resource(pdev, IORESOURCE_MEM, 1); res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
@ -2387,10 +2365,10 @@ static int cpsw_probe(struct platform_device *pdev)
memset(&dma_params, 0, sizeof(dma_params)); memset(&dma_params, 0, sizeof(dma_params));
memset(&ale_params, 0, sizeof(ale_params)); memset(&ale_params, 0, sizeof(ale_params));
switch (priv->version) { switch (cpsw->version) {
case CPSW_VERSION_1: case CPSW_VERSION_1:
cpsw->host_port_regs = ss_regs + CPSW1_HOST_PORT_OFFSET; cpsw->host_port_regs = ss_regs + CPSW1_HOST_PORT_OFFSET;
priv->cpts->reg = ss_regs + CPSW1_CPTS_OFFSET; cpsw->cpts->reg = ss_regs + CPSW1_CPTS_OFFSET;
cpsw->hw_stats = ss_regs + CPSW1_HW_STATS; cpsw->hw_stats = ss_regs + CPSW1_HW_STATS;
dma_params.dmaregs = ss_regs + CPSW1_CPDMA_OFFSET; dma_params.dmaregs = ss_regs + CPSW1_CPDMA_OFFSET;
dma_params.txhdp = ss_regs + CPSW1_STATERAM_OFFSET; dma_params.txhdp = ss_regs + CPSW1_STATERAM_OFFSET;
@ -2404,7 +2382,7 @@ static int cpsw_probe(struct platform_device *pdev)
case CPSW_VERSION_3: case CPSW_VERSION_3:
case CPSW_VERSION_4: case CPSW_VERSION_4:
cpsw->host_port_regs = ss_regs + CPSW2_HOST_PORT_OFFSET; cpsw->host_port_regs = ss_regs + CPSW2_HOST_PORT_OFFSET;
priv->cpts->reg = ss_regs + CPSW2_CPTS_OFFSET; cpsw->cpts->reg = ss_regs + CPSW2_CPTS_OFFSET;
cpsw->hw_stats = ss_regs + CPSW2_HW_STATS; cpsw->hw_stats = ss_regs + CPSW2_HW_STATS;
dma_params.dmaregs = ss_regs + CPSW2_CPDMA_OFFSET; dma_params.dmaregs = ss_regs + CPSW2_CPDMA_OFFSET;
dma_params.txhdp = ss_regs + CPSW2_STATERAM_OFFSET; dma_params.txhdp = ss_regs + CPSW2_STATERAM_OFFSET;
@ -2416,7 +2394,7 @@ static int cpsw_probe(struct platform_device *pdev)
(u32 __force) ss_res->start + CPSW2_BD_OFFSET; (u32 __force) ss_res->start + CPSW2_BD_OFFSET;
break; break;
default: default:
dev_err(priv->dev, "unknown version 0x%08x\n", priv->version); dev_err(priv->dev, "unknown version 0x%08x\n", cpsw->version);
ret = -ENODEV; ret = -ENODEV;
goto clean_runtime_disable_ret; goto clean_runtime_disable_ret;
} }
@ -2466,8 +2444,8 @@ static int cpsw_probe(struct platform_device *pdev)
ale_params.ale_entries = data->ale_entries; ale_params.ale_entries = data->ale_entries;
ale_params.ale_ports = data->slaves; ale_params.ale_ports = data->slaves;
priv->ale = cpsw_ale_create(&ale_params); cpsw->ale = cpsw_ale_create(&ale_params);
if (!priv->ale) { if (!cpsw->ale) {
dev_err(priv->dev, "error initializing ale engine\n"); dev_err(priv->dev, "error initializing ale engine\n");
ret = -ENODEV; ret = -ENODEV;
goto clean_dma_ret; goto clean_dma_ret;
@ -2555,7 +2533,7 @@ static int cpsw_probe(struct platform_device *pdev)
return 0; return 0;
clean_ale_ret: clean_ale_ret:
cpsw_ale_destroy(priv->ale); cpsw_ale_destroy(cpsw->ale);
clean_dma_ret: clean_dma_ret:
cpdma_ctlr_destroy(cpsw->dma); cpdma_ctlr_destroy(cpsw->dma);
clean_runtime_disable_ret: clean_runtime_disable_ret:
@ -2568,8 +2546,7 @@ clean_ndev_ret:
static int cpsw_remove(struct platform_device *pdev) static int cpsw_remove(struct platform_device *pdev)
{ {
struct net_device *ndev = platform_get_drvdata(pdev); struct net_device *ndev = platform_get_drvdata(pdev);
struct cpsw_priv *priv = netdev_priv(ndev); struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
struct cpsw_common *cpsw = priv->cpsw;
int ret; int ret;
ret = pm_runtime_get_sync(&pdev->dev); ret = pm_runtime_get_sync(&pdev->dev);
@ -2582,7 +2559,7 @@ static int cpsw_remove(struct platform_device *pdev)
unregister_netdev(cpsw->slaves[1].ndev); unregister_netdev(cpsw->slaves[1].ndev);
unregister_netdev(ndev); unregister_netdev(ndev);
cpsw_ale_destroy(priv->ale); cpsw_ale_destroy(cpsw->ale);
cpdma_ctlr_destroy(cpsw->dma); cpdma_ctlr_destroy(cpsw->dma);
of_platform_depopulate(&pdev->dev); of_platform_depopulate(&pdev->dev);
pm_runtime_put_sync(&pdev->dev); pm_runtime_put_sync(&pdev->dev);