Difuse/difos
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'openwrt:master' into master

Browse source
This commit is contained in:
Hayzam Sherif 2023-03-29 00:46:13 +05:30 committed by GitHub
commit 138ae57d88
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 1903 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
package/network/utils/comgt/files/ncm.sh
View file

@ -86,10 +86,25 @@ proto_ncm_setup() {
return 1
}
[ -n "$delay" ] && sleep "$delay"
start=$(date +%s)
while true; do
manufacturer=$(gcom -d "$device" -s /etc/gcom/getcardinfo.gcom | awk 'NF && $0 !~ /AT\+CGMI/ { sub(/\+CGMI: /,""); print tolower($1); exit; }')
[ $? -ne 0 -o -z "$manufacturer" ] && {
[ "$manufacturer" = "error" ] && {
manufacturer=""
}
[ -n "$manufacturer" ] && {
break
}
[ -z "$delay" ] && {
break
}
sleep 1
elapsed=$(($(date +%s) - start))
[ "$elapsed" -gt "$delay" ] && {
break
}
done
[ -z "$manufacturer" ] && {
echo "Failed to get modem information"
proto_notify_error "$interface" GETINFO_FAILED
return 1

1
target/linux/bmips/config-5.15
View file

@ -10,6 +10,7 @@ CONFIG_B53_MMAP_DRIVER=y
CONFIG_B53_SPI_DRIVER=y
CONFIG_BCM6345_EXT_IRQ=y
CONFIG_BCM6345_L1_IRQ=y
CONFIG_BCM6348_ENET=y
CONFIG_BCM6368_ENETSW=y
CONFIG_BCM63XX_POWER=y
CONFIG_BCM7038_WDT=y

11
target/linux/bmips/dts/bcm6358-huawei-hg556a-b.dts
View file

@ -140,6 +140,17 @@
status = "okay";
};
&ethernet1 {
status = "okay";
nvmem-cells = <&macaddr_cfe_6a0>;
nvmem-cell-names = "mac-address";
};
&iudma {
status = "okay";
};
&ohci {
status = "okay";
};

79
target/linux/bmips/dts/bcm6358.dtsi
View file

@ -346,5 +346,84 @@
status = "disabled";
};
ethernet0: ethernet@fffe4000 {
compatible = "brcm,bcm6358-emac";
reg = <0xfffe4000 0x2dc>;
clocks = <&periph_clk BCM6358_CLK_ENET0>;
interrupt-parent = <&periph_intc>;
interrupts = <BCM6358_IRQ_EMAC0>,
<BCM6358_IRQ_EMAC0_RX_DMA>,
<BCM6358_IRQ_EMAC0_TX_DMA>;
interrupt-names = "emac",
"rx",
"tx";
brcm,iudma = <&iudma>;
dma-rx = <0>;
dma-tx = <1>;
status = "disabled";
mdio0: mdio {
#address-cells = <1>;
#size-cells = <0>;
};
};
ethernet1: ethernet@fffe4800 {
compatible = "brcm,bcm6358-emac";
reg = <0xfffe4800 0x2dc>;
clocks = <&periph_clk BCM6358_CLK_ENET1>;
interrupt-parent = <&periph_intc>;
interrupts = <BCM6358_IRQ_EMAC1>,
<BCM6358_IRQ_EMAC1_RX_DMA>,
<BCM6358_IRQ_EMAC1_TX_DMA>;
interrupt-names = "emac",
"rx",
"tx";
brcm,iudma = <&iudma>;
brcm,external-mii;
dma-rx = <2>;
dma-tx = <3>;
status = "disabled";
mdio1: mdio {
#address-cells = <1>;
#size-cells = <0>;
};
};
iudma: dma@fffe5000 {
#address-cells = <1>;
#size-cells = <1>;
compatible = "brcm,bcm6358-iudma";
reg = <0xfffe5000 0x24>,
<0xfffe5100 0x80>,
<0xfffe5200 0x80>;
reg-names = "dma",
"dma-channels",
"dma-sram";
dma-channels = <8>;
clocks = <&periph_clk BCM6358_CLK_EMUSB>,
<&periph_clk BCM6358_CLK_USBSU>,
<&periph_clk BCM6358_CLK_EPHY>,
<&periph_clk BCM6358_CLK_ENET>;
resets = <&periph_rst BCM6358_RST_ENET>,
<&periph_rst BCM6358_RST_EPHY>;
status = "disabled";
};
};
};

1594
target/linux/bmips/files/drivers/net/ethernet/broadcom/bcm6348-enet.c Normal file
View file

File diff suppressed because it is too large Load diff

256
target/linux/bmips/files/drivers/net/ethernet/broadcom/bcm6368-enetsw.c
View file

@ -194,9 +194,6 @@ struct bcm6368_enetsw {
/* number of dma desc in tx ring */
int tx_ring_size;
/* maximum dma burst size */
int dma_maxburst;
/* cpu view of rx dma ring */
struct bcm6368_enetsw_desc *tx_desc_cpu;
@ -220,15 +217,6 @@ struct bcm6368_enetsw {
/* platform device reference */
struct platform_device *pdev;
/* dma channel enable mask */
u32 dma_chan_en_mask;
/* dma channel interrupt mask */
u32 dma_chan_int_mask;
/* dma channel width */
unsigned int dma_chan_width;
};
static inline void dma_writel(struct bcm6368_enetsw *priv, u32 val, u32 off)
@ -238,27 +226,29 @@ static inline void dma_writel(struct bcm6368_enetsw *priv, u32 val, u32 off)
static inline u32 dma_readl(struct bcm6368_enetsw *priv, u32 off, int chan)
{
return __raw_readl(priv->dma_chan + off + chan * priv->dma_chan_width);
return __raw_readl(priv->dma_chan + off + chan * DMA_CHAN_WIDTH);
}
static inline void dmac_writel(struct bcm6368_enetsw *priv, u32 val,
u32 off, int chan)
static inline void dmac_writel(struct bcm6368_enetsw *priv, u32 val, u32 off,
int chan)
{
__raw_writel(val, priv->dma_chan + off + chan * priv->dma_chan_width);
__raw_writel(val, priv->dma_chan + off + chan * DMA_CHAN_WIDTH);
}
static inline void dmas_writel(struct bcm6368_enetsw *priv, u32 val,
u32 off, int chan)
{
__raw_writel(val, priv->dma_sram + off + chan * priv->dma_chan_width);
__raw_writel(val, priv->dma_sram + off + chan * DMA_CHAN_WIDTH);
}
/*
* refill rx queue
*/
static int bcm6368_enetsw_refill_rx(struct net_device *dev, bool napi_mode)
static int bcm6368_enetsw_refill_rx(struct net_device *ndev, bool napi_mode)
{
struct bcm6368_enetsw *priv = netdev_priv(dev);
struct bcm6368_enetsw *priv = netdev_priv(ndev);
struct platform_device *pdev = priv->pdev;
struct device *dev = &pdev->dev;
while (priv->rx_desc_count < priv->rx_ring_size) {
struct bcm6368_enetsw_desc *desc;
@ -280,9 +270,9 @@ static int bcm6368_enetsw_refill_rx(struct net_device *dev, bool napi_mode)
if (unlikely(!buf))
break;
p = dma_map_single(&priv->pdev->dev, buf + NET_SKB_PAD,
p = dma_map_single(dev, buf + NET_SKB_PAD,
priv->rx_buf_size, DMA_FROM_DEVICE);
if (unlikely(dma_mapping_error(&priv->pdev->dev, p))) {
if (unlikely(dma_mapping_error(dev, p))) {
skb_free_frag(buf);
break;
}
@ -310,8 +300,8 @@ static int bcm6368_enetsw_refill_rx(struct net_device *dev, bool napi_mode)
/* If rx ring is still empty, set a timer to try allocating
* again at a later time. */
if (priv->rx_desc_count == 0 && netif_running(dev)) {
dev_warn(&priv->pdev->dev, "unable to refill rx ring\n");
if (priv->rx_desc_count == 0 && netif_running(ndev)) {
dev_warn(dev, "unable to refill rx ring\n");
priv->rx_timeout.expires = jiffies + HZ;
add_timer(&priv->rx_timeout);
}
@ -325,20 +315,21 @@ static int bcm6368_enetsw_refill_rx(struct net_device *dev, bool napi_mode)
static void bcm6368_enetsw_refill_rx_timer(struct timer_list *t)
{
struct bcm6368_enetsw *priv = from_timer(priv, t, rx_timeout);
struct net_device *dev = priv->net_dev;
struct net_device *ndev = priv->net_dev;
spin_lock(&priv->rx_lock);
bcm6368_enetsw_refill_rx(dev, false);
bcm6368_enetsw_refill_rx(ndev, false);
spin_unlock(&priv->rx_lock);
}
/*
* extract packet from rx queue
*/
static int bcm6368_enetsw_receive_queue(struct net_device *dev, int budget)
static int bcm6368_enetsw_receive_queue(struct net_device *ndev, int budget)
{
struct bcm6368_enetsw *priv = netdev_priv(dev);
struct device *kdev = &priv->pdev->dev;
struct bcm6368_enetsw *priv = netdev_priv(ndev);
struct platform_device *pdev = priv->pdev;
struct device *dev = &pdev->dev;
struct list_head rx_list;
struct sk_buff *skb;
int processed = 0;
@ -379,7 +370,7 @@ static int bcm6368_enetsw_receive_queue(struct net_device *dev, int budget)
/* if the packet does not have start of packet _and_
* end of packet flag set, then just recycle it */
if ((len_stat & DMADESC_ESOP_MASK) != DMADESC_ESOP_MASK) {
dev->stats.rx_dropped++;
ndev->stats.rx_dropped++;
continue;
}
@ -396,19 +387,19 @@ static int bcm6368_enetsw_receive_queue(struct net_device *dev, int budget)
if (unlikely(!nbuf)) {
/* forget packet, just rearm desc */
dev->stats.rx_dropped++;
ndev->stats.rx_dropped++;
continue;
}
dma_sync_single_for_cpu(kdev, desc->address,
dma_sync_single_for_cpu(dev, desc->address,
len, DMA_FROM_DEVICE);
memcpy(nbuf + NET_SKB_PAD, buf + NET_SKB_PAD, len);
dma_sync_single_for_device(kdev, desc->address,
dma_sync_single_for_device(dev, desc->address,
len, DMA_FROM_DEVICE);
buf = nbuf;
frag_size = nfrag_size;
} else {
dma_unmap_single(kdev, desc->address,
dma_unmap_single(dev, desc->address,
priv->rx_buf_size, DMA_FROM_DEVICE);
priv->rx_buf[desc_idx] = NULL;
frag_size = priv->rx_frag_size;
@ -417,27 +408,27 @@ static int bcm6368_enetsw_receive_queue(struct net_device *dev, int budget)
skb = napi_build_skb(buf, frag_size);
if (unlikely(!skb)) {
skb_free_frag(buf);
dev->stats.rx_dropped++;
ndev->stats.rx_dropped++;
continue;
}
skb_reserve(skb, NET_SKB_PAD);
skb_put(skb, len);
dev->stats.rx_packets++;
dev->stats.rx_bytes += len;
ndev->stats.rx_packets++;
ndev->stats.rx_bytes += len;
list_add_tail(&skb->list, &rx_list);
} while (processed < budget);
list_for_each_entry(skb, &rx_list, list)
skb->protocol = eth_type_trans(skb, dev);
skb->protocol = eth_type_trans(skb, ndev);
netif_receive_skb_list(&rx_list);
priv->rx_desc_count -= processed;
if (processed || !priv->rx_desc_count) {
bcm6368_enetsw_refill_rx(dev, true);
bcm6368_enetsw_refill_rx(ndev, true);
/* kick rx dma */
dmac_writel(priv, priv->dma_chan_en_mask,
dmac_writel(priv, DMAC_CHANCFG_EN_MASK,
DMAC_CHANCFG_REG, priv->rx_chan);
}
@ -447,10 +438,12 @@ static int bcm6368_enetsw_receive_queue(struct net_device *dev, int budget)
/*
* try to or force reclaim of transmitted buffers
*/
static int bcm6368_enetsw_tx_reclaim(struct net_device *dev, int force,
static int bcm6368_enetsw_tx_reclaim(struct net_device *ndev, int force,
int budget)
{
struct bcm6368_enetsw *priv = netdev_priv(dev);
struct bcm6368_enetsw *priv = netdev_priv(ndev);
struct platform_device *pdev = priv->pdev;
struct device *dev = &pdev->dev;
unsigned int bytes = 0;
int released = 0;
@ -475,7 +468,7 @@ static int bcm6368_enetsw_tx_reclaim(struct net_device *dev, int force,
skb = priv->tx_skb[priv->tx_dirty_desc];
priv->tx_skb[priv->tx_dirty_desc] = NULL;
dma_unmap_single(&priv->pdev->dev, desc->address, skb->len,
dma_unmap_single(dev, desc->address, skb->len,
DMA_TO_DEVICE);
priv->tx_dirty_desc++;
@ -486,17 +479,17 @@ static int bcm6368_enetsw_tx_reclaim(struct net_device *dev, int force,
spin_unlock(&priv->tx_lock);
if (desc->len_stat & DMADESC_UNDER_MASK)
dev->stats.tx_errors++;
ndev->stats.tx_errors++;
bytes += skb->len;
napi_consume_skb(skb, budget);
released++;
}
netdev_completed_queue(dev, released, bytes);
netdev_completed_queue(ndev, released, bytes);
if (netif_queue_stopped(dev) && released)
netif_wake_queue(dev);
if (netif_queue_stopped(ndev) && released)
netif_wake_queue(ndev);
return released;
}
@ -507,20 +500,20 @@ static int bcm6368_enetsw_tx_reclaim(struct net_device *dev, int force,
static int bcm6368_enetsw_poll(struct napi_struct *napi, int budget)
{
struct bcm6368_enetsw *priv = container_of(napi, struct bcm6368_enetsw, napi);
struct net_device *dev = priv->net_dev;
struct net_device *ndev = priv->net_dev;
int rx_work_done;
/* ack interrupts */
dmac_writel(priv, priv->dma_chan_int_mask,
dmac_writel(priv, DMAC_IR_PKTDONE_MASK,
DMAC_IR_REG, priv->rx_chan);
dmac_writel(priv, priv->dma_chan_int_mask,
dmac_writel(priv, DMAC_IR_PKTDONE_MASK,
DMAC_IR_REG, priv->tx_chan);
/* reclaim sent skb */
bcm6368_enetsw_tx_reclaim(dev, 0, budget);
bcm6368_enetsw_tx_reclaim(ndev, 0, budget);
spin_lock(&priv->rx_lock);
rx_work_done = bcm6368_enetsw_receive_queue(dev, budget);
rx_work_done = bcm6368_enetsw_receive_queue(ndev, budget);
spin_unlock(&priv->rx_lock);
if (rx_work_done >= budget) {
@ -533,9 +526,9 @@ static int bcm6368_enetsw_poll(struct napi_struct *napi, int budget)
napi_complete_done(napi, rx_work_done);
/* restore rx/tx interrupt */
dmac_writel(priv, priv->dma_chan_int_mask,
dmac_writel(priv, DMAC_IR_PKTDONE_MASK,
DMAC_IRMASK_REG, priv->rx_chan);
dmac_writel(priv, priv->dma_chan_int_mask,
dmac_writel(priv, DMAC_IR_PKTDONE_MASK,
DMAC_IRMASK_REG, priv->tx_chan);
return rx_work_done;
@ -546,8 +539,8 @@ static int bcm6368_enetsw_poll(struct napi_struct *napi, int budget)
*/
static irqreturn_t bcm6368_enetsw_isr_dma(int irq, void *dev_id)
{
struct net_device *dev = dev_id;
struct bcm6368_enetsw *priv = netdev_priv(dev);
struct net_device *ndev = dev_id;
struct bcm6368_enetsw *priv = netdev_priv(ndev);
/* mask rx/tx interrupts */
dmac_writel(priv, 0, DMAC_IRMASK_REG, priv->rx_chan);
@ -562,9 +555,11 @@ static irqreturn_t bcm6368_enetsw_isr_dma(int irq, void *dev_id)
* tx request callback
*/
static netdev_tx_t
bcm6368_enetsw_start_xmit(struct sk_buff *skb, struct net_device *dev)
bcm6368_enetsw_start_xmit(struct sk_buff *skb, struct net_device *ndev)
{
struct bcm6368_enetsw *priv = netdev_priv(dev);
struct bcm6368_enetsw *priv = netdev_priv(ndev);
struct platform_device *pdev = priv->pdev;
struct device *dev = &pdev->dev;
struct bcm6368_enetsw_desc *desc;
u32 len_stat;
netdev_tx_t ret;
@ -576,9 +571,8 @@ bcm6368_enetsw_start_xmit(struct sk_buff *skb, struct net_device *dev)
/* make sure the tx hw queue is not full, should not happen
* since we stop queue before it's the case */
if (unlikely(!priv->tx_desc_count)) {
netif_stop_queue(dev);
dev_err(&priv->pdev->dev, "xmit called with no tx desc "
"available?\n");
netif_stop_queue(ndev);
dev_err(dev, "xmit called with no tx desc available?\n");
ret = NETDEV_TX_BUSY;
goto out_unlock;
}
@ -604,9 +598,8 @@ bcm6368_enetsw_start_xmit(struct sk_buff *skb, struct net_device *dev)
}
/* fill descriptor */
p = dma_map_single(&priv->pdev->dev, skb->data, skb->len,
DMA_TO_DEVICE);
if (unlikely(dma_mapping_error(&priv->pdev->dev, p))) {
p = dma_map_single(dev, skb->data, skb->len, DMA_TO_DEVICE);
if (unlikely(dma_mapping_error(dev, p))) {
dev_kfree_skb(skb);
ret = NETDEV_TX_OK;
goto out_unlock;
@ -634,18 +627,18 @@ bcm6368_enetsw_start_xmit(struct sk_buff *skb, struct net_device *dev)
desc->len_stat = len_stat;
wmb();
netdev_sent_queue(dev, skb->len);
netdev_sent_queue(ndev, skb->len);
/* kick tx dma */
dmac_writel(priv, priv->dma_chan_en_mask, DMAC_CHANCFG_REG,
dmac_writel(priv, DMAC_CHANCFG_EN_MASK, DMAC_CHANCFG_REG,
priv->tx_chan);
/* stop queue if no more desc available */
if (!priv->tx_desc_count)
netif_stop_queue(dev);
netif_stop_queue(ndev);
dev->stats.tx_bytes += skb->len;
dev->stats.tx_packets++;
ndev->stats.tx_bytes += skb->len;
ndev->stats.tx_packets++;
ret = NETDEV_TX_OK;
out_unlock:
@ -673,10 +666,11 @@ static void bcm6368_enetsw_disable_dma(struct bcm6368_enetsw *priv, int chan)
} while (limit--);
}
static int bcm6368_enetsw_open(struct net_device *dev)
static int bcm6368_enetsw_open(struct net_device *ndev)
{
struct bcm6368_enetsw *priv = netdev_priv(dev);
struct device *kdev = &priv->pdev->dev;
struct bcm6368_enetsw *priv = netdev_priv(ndev);
struct platform_device *pdev = priv->pdev;
struct device *dev = &pdev->dev;
int i, ret;
unsigned int size;
void *p;
@ -687,22 +681,22 @@ static int bcm6368_enetsw_open(struct net_device *dev)
dmac_writel(priv, 0, DMAC_IRMASK_REG, priv->tx_chan);
ret = request_irq(priv->irq_rx, bcm6368_enetsw_isr_dma,
0, dev->name, dev);
0, ndev->name, ndev);
if (ret)
goto out_freeirq;
if (priv->irq_tx != -1) {
ret = request_irq(priv->irq_tx, bcm6368_enetsw_isr_dma,
0, dev->name, dev);
0, ndev->name, ndev);
if (ret)
goto out_freeirq_rx;
}
/* allocate rx dma ring */
size = priv->rx_ring_size * sizeof(struct bcm6368_enetsw_desc);
p = dma_alloc_coherent(kdev, size, &priv->rx_desc_dma, GFP_KERNEL);
p = dma_alloc_coherent(dev, size, &priv->rx_desc_dma, GFP_KERNEL);
if (!p) {
dev_err(kdev, "cannot allocate rx ring %u\n", size);
dev_err(dev, "cannot allocate rx ring %u\n", size);
ret = -ENOMEM;
goto out_freeirq_tx;
}
@ -713,9 +707,9 @@ static int bcm6368_enetsw_open(struct net_device *dev)
/* allocate tx dma ring */
size = priv->tx_ring_size * sizeof(struct bcm6368_enetsw_desc);
p = dma_alloc_coherent(kdev, size, &priv->tx_desc_dma, GFP_KERNEL);
p = dma_alloc_coherent(dev, size, &priv->tx_desc_dma, GFP_KERNEL);
if (!p) {
dev_err(kdev, "cannot allocate tx ring\n");
dev_err(dev, "cannot allocate tx ring\n");
ret = -ENOMEM;
goto out_free_rx_ring;
}
@ -727,7 +721,7 @@ static int bcm6368_enetsw_open(struct net_device *dev)
priv->tx_skb = kzalloc(sizeof(struct sk_buff *) * priv->tx_ring_size,
GFP_KERNEL);
if (!priv->tx_skb) {
dev_err(kdev, "cannot allocate tx skb queue\n");
dev_err(dev, "cannot allocate tx skb queue\n");
ret = -ENOMEM;
goto out_free_tx_ring;
}
@ -741,7 +735,7 @@ static int bcm6368_enetsw_open(struct net_device *dev)
priv->rx_buf = kzalloc(sizeof(unsigned char *) * priv->rx_ring_size,
GFP_KERNEL);
if (!priv->rx_buf) {
dev_err(kdev, "cannot allocate rx buffer queue\n");
dev_err(dev, "cannot allocate rx buffer queue\n");
ret = -ENOMEM;
goto out_free_tx_skb;
}
@ -754,8 +748,8 @@ static int bcm6368_enetsw_open(struct net_device *dev)
dma_writel(priv, DMA_BUFALLOC_FORCE_MASK | 0,
DMA_BUFALLOC_REG(priv->rx_chan));
if (bcm6368_enetsw_refill_rx(dev, false)) {
dev_err(kdev, "cannot allocate rx buffer queue\n");
if (bcm6368_enetsw_refill_rx(ndev, false)) {
dev_err(dev, "cannot allocate rx buffer queue\n");
ret = -ENOMEM;
goto out;
}
@ -775,9 +769,9 @@ static int bcm6368_enetsw_open(struct net_device *dev)
dmas_writel(priv, 0, DMAS_SRAM4_REG, priv->tx_chan);
/* set dma maximum burst len */
dmac_writel(priv, priv->dma_maxburst,
dmac_writel(priv, ENETSW_DMA_MAXBURST,
DMAC_MAXBURST_REG, priv->rx_chan);
dmac_writel(priv, priv->dma_maxburst,
dmac_writel(priv, ENETSW_DMA_MAXBURST,
DMAC_MAXBURST_REG, priv->tx_chan);
/* set flow control low/high threshold to 1/3 / 2/3 */
@ -808,8 +802,8 @@ static int bcm6368_enetsw_open(struct net_device *dev)
dmac_writel(priv, DMAC_IR_PKTDONE_MASK,
DMAC_IRMASK_REG, priv->tx_chan);
netif_carrier_on(dev);
netif_start_queue(dev);
netif_carrier_on(ndev);
netif_start_queue(ndev);
return 0;
@ -821,7 +815,7 @@ out:
continue;
desc = &priv->rx_desc_cpu[i];
dma_unmap_single(kdev, desc->address, priv->rx_buf_size,
dma_unmap_single(dev, desc->address, priv->rx_buf_size,
DMA_FROM_DEVICE);
skb_free_frag(priv->rx_buf[i]);
}
@ -831,31 +825,32 @@ out_free_tx_skb:
kfree(priv->tx_skb);
out_free_tx_ring:
dma_free_coherent(kdev, priv->tx_desc_alloc_size,
dma_free_coherent(dev, priv->tx_desc_alloc_size,
priv->tx_desc_cpu, priv->tx_desc_dma);
out_free_rx_ring:
dma_free_coherent(kdev, priv->rx_desc_alloc_size,
dma_free_coherent(dev, priv->rx_desc_alloc_size,
priv->rx_desc_cpu, priv->rx_desc_dma);
out_freeirq_tx:
if (priv->irq_tx != -1)
free_irq(priv->irq_tx, dev);
free_irq(priv->irq_tx, ndev);
out_freeirq_rx:
free_irq(priv->irq_rx, dev);
free_irq(priv->irq_rx, ndev);
out_freeirq:
return ret;
}
static int bcm6368_enetsw_stop(struct net_device *dev)
static int bcm6368_enetsw_stop(struct net_device *ndev)
{
struct bcm6368_enetsw *priv = netdev_priv(dev);
struct device *kdev = &priv->pdev->dev;
struct bcm6368_enetsw *priv = netdev_priv(ndev);
struct platform_device *pdev = priv->pdev;
struct device *dev = &pdev->dev;
int i;
netif_stop_queue(dev);
netif_stop_queue(ndev);
napi_disable(&priv->napi);
del_timer_sync(&priv->rx_timeout);
@ -868,7 +863,7 @@ static int bcm6368_enetsw_stop(struct net_device *dev)
bcm6368_enetsw_disable_dma(priv, priv->rx_chan);
/* force reclaim of all tx buffers */
bcm6368_enetsw_tx_reclaim(dev, 1, 0);
bcm6368_enetsw_tx_reclaim(ndev, 1, 0);
/* free the rx buffer ring */
for (i = 0; i < priv->rx_ring_size; i++) {
@ -878,7 +873,7 @@ static int bcm6368_enetsw_stop(struct net_device *dev)
continue;
desc = &priv->rx_desc_cpu[i];
dma_unmap_single_attrs(kdev, desc->address, priv->rx_buf_size,
dma_unmap_single_attrs(dev, desc->address, priv->rx_buf_size,
DMA_FROM_DEVICE,
DMA_ATTR_SKIP_CPU_SYNC);
skb_free_frag(priv->rx_buf[i]);
@ -887,15 +882,15 @@ static int bcm6368_enetsw_stop(struct net_device *dev)
/* free remaining allocated memory */
kfree(priv->rx_buf);
kfree(priv->tx_skb);
dma_free_coherent(kdev, priv->rx_desc_alloc_size,
dma_free_coherent(dev, priv->rx_desc_alloc_size,
priv->rx_desc_cpu, priv->rx_desc_dma);
dma_free_coherent(kdev, priv->tx_desc_alloc_size,
dma_free_coherent(dev, priv->tx_desc_alloc_size,
priv->tx_desc_cpu, priv->tx_desc_dma);
if (priv->irq_tx != -1)
free_irq(priv->irq_tx, dev);
free_irq(priv->irq_rx, dev);
free_irq(priv->irq_tx, ndev);
free_irq(priv->irq_rx, ndev);
netdev_reset_queue(dev);
netdev_reset_queue(ndev);
return 0;
}
@ -908,19 +903,25 @@ static const struct net_device_ops bcm6368_enetsw_ops = {
static int bcm6368_enetsw_probe(struct platform_device *pdev)
{
struct bcm6368_enetsw *priv;
struct device *dev = &pdev->dev;
struct device_node *node = dev->of_node;
struct bcm6368_enetsw *priv;
struct net_device *ndev;
struct resource *res;
unsigned i;
int num_resets;
int ret;
ndev = alloc_etherdev(sizeof(*priv));
ndev = devm_alloc_etherdev(dev, sizeof(*priv));
if (!ndev)
return -ENOMEM;
platform_set_drvdata(pdev, ndev);
SET_NETDEV_DEV(ndev, dev);
priv = netdev_priv(ndev);
priv->pdev = pdev;
priv->net_dev = ndev;
priv->num_pms = of_count_phandle_with_args(node, "power-domains",
"#power-domain-cells");
@ -960,18 +961,18 @@ static int bcm6368_enetsw_probe(struct platform_device *pdev)
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dma");
priv->dma_base = devm_ioremap_resource(dev, res);
if (IS_ERR(priv->dma_base))
if (IS_ERR_OR_NULL(priv->dma_base))
return PTR_ERR(priv->dma_base);
res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
"dma-channels");
priv->dma_chan = devm_ioremap_resource(dev, res);
if (IS_ERR(priv->dma_chan))
if (IS_ERR_OR_NULL(priv->dma_chan))
return PTR_ERR(priv->dma_chan);
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dma-sram");
priv->dma_sram = devm_ioremap_resource(dev, res);
if (IS_ERR(priv->dma_sram))
if (IS_ERR_OR_NULL(priv->dma_sram))
return PTR_ERR(priv->dma_sram);
priv->irq_rx = platform_get_irq_byname(pdev, "rx");
@ -992,15 +993,8 @@ static int bcm6368_enetsw_probe(struct platform_device *pdev)
priv->rx_ring_size = ENETSW_DEF_RX_DESC;
priv->tx_ring_size = ENETSW_DEF_TX_DESC;
priv->dma_maxburst = ENETSW_DMA_MAXBURST;
priv->copybreak = ENETSW_DEF_CPY_BREAK;
priv->dma_chan_en_mask = DMAC_CHANCFG_EN_MASK;
priv->dma_chan_int_mask = DMAC_IR_PKTDONE_MASK;
priv->dma_chan_width = DMA_CHAN_WIDTH;
of_get_mac_address(node, ndev->dev_addr);
if (is_valid_ether_addr(ndev->dev_addr)) {
dev_info(dev, "mtd mac %pM\n", ndev->dev_addr);
@ -1010,7 +1004,7 @@ static int bcm6368_enetsw_probe(struct platform_device *pdev)
}
priv->rx_buf_size = ALIGN(ndev->mtu + ENETSW_MTU_OVERHEAD,
priv->dma_maxburst * 4);
ENETSW_DMA_MAXBURST * 4);
priv->rx_frag_size = ENETSW_FRAG_SIZE(priv->rx_buf_size);
@ -1018,14 +1012,14 @@ static int bcm6368_enetsw_probe(struct platform_device *pdev)
if (priv->num_clocks) {
priv->clock = devm_kcalloc(dev, priv->num_clocks,
sizeof(struct clk *), GFP_KERNEL);
if (!priv->clock)
return -ENOMEM;
if (IS_ERR_OR_NULL(priv->clock))
return PTR_ERR(priv->clock);
}
for (i = 0; i < priv->num_clocks; i++) {
priv->clock[i] = of_clk_get(node, i);
if (IS_ERR(priv->clock[i])) {
dev_err(dev, "error getting clock %d\n", i);
return -EINVAL;
return PTR_ERR(priv->clock[i]);
}
ret = clk_prepare_enable(priv->clock[i]);
@ -1035,20 +1029,24 @@ static int bcm6368_enetsw_probe(struct platform_device *pdev)
}
}
priv->num_resets = of_count_phandle_with_args(node, "resets",
num_resets = of_count_phandle_with_args(node, "resets",
"#reset-cells");
if (num_resets > 0)
priv->num_resets = num_resets;
else
priv->num_resets = 0;
if (priv->num_resets) {
priv->reset = devm_kcalloc(dev, priv->num_resets,
sizeof(struct reset_control *),
GFP_KERNEL);
if (!priv->reset)
return -ENOMEM;
if (IS_ERR_OR_NULL(priv->reset))
return PTR_ERR(priv->reset);
}
for (i = 0; i < priv->num_resets; i++) {
priv->reset[i] = devm_reset_control_get_by_index(dev, i);
if (IS_ERR(priv->reset[i])) {
dev_err(dev, "error getting reset %d\n", i);
return -EINVAL;
return PTR_ERR(priv->reset[i]);
}
ret = reset_control_reset(priv->reset[i]);
@ -1068,16 +1066,16 @@ static int bcm6368_enetsw_probe(struct platform_device *pdev)
ndev->mtu = ETH_DATA_LEN + ENETSW_TAG_SIZE;
ndev->max_mtu = ETH_DATA_LEN + ENETSW_TAG_SIZE;
netif_napi_add(ndev, &priv->napi, bcm6368_enetsw_poll, 16);
SET_NETDEV_DEV(ndev, dev);
ret = register_netdev(ndev);
if (ret)
ret = devm_register_netdev(dev, ndev);
if (ret) {
netif_napi_del(&priv->napi);
goto out_disable_clk;
}
netif_carrier_off(ndev);
platform_set_drvdata(pdev, ndev);
priv->pdev = pdev;
priv->net_dev = ndev;
dev_info(dev, "%s at 0x%px, IRQ %d\n", ndev->name, priv->dma_base, ndev->irq);
return 0;
@ -1098,8 +1096,6 @@ static int bcm6368_enetsw_remove(struct platform_device *pdev)
struct bcm6368_enetsw *priv = netdev_priv(ndev);
unsigned int i;
unregister_netdev(ndev);
pm_runtime_put_sync(dev);
for (i = 0; priv->pm && i < priv->num_pms; i++) {
dev_pm_domain_detach(priv->pm[i], true);
@ -1112,8 +1108,6 @@ static int bcm6368_enetsw_remove(struct platform_device *pdev)
for (i = 0; i < priv->num_clocks; i++)
clk_disable_unprepare(priv->clock[i]);
free_netdev(ndev);
return 0;
}

3
target/linux/bmips/generic/base-files/etc/board.d/02_network
View file

@ -11,6 +11,9 @@ comtrend,vr-3025u)
ucidef_set_bridge_device switch
ucidef_set_interface_lan "lan1 lan2 lan3 lan4"
;;
huawei,hg556a-b)
ucidef_set_interface_lan "eth0"
;;
esac
board_config_flush

16
target/linux/bmips/nand/base-files/etc/board.d/03_gpio_switches Normal file
View file

@ -0,0 +1,16 @@
# SPDX-License-Identifier: GPL-2.0-or-later
. /lib/functions/uci-defaults.sh
board_config_update
case "$(board_name)" in
sercomm,h500-s-lowi |\
sercomm,h500-s-vfes)
ucidef_add_gpio_switch "qtn_power" "Quantenna Module Power" "480" "1"
;;
esac
board_config_flush
exit 0

44
target/linux/bmips/patches-5.15/501-net-broadcom-add-BCM6348-enet-controller-driver.patch Normal file
View file

@ -0,0 +1,44 @@
From 590b60fb08cb1e70fe02d3f407c6b3dbe9ad06ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= <noltari@gmail.com>
Date: Mon, 1 Mar 2021 07:34:39 +0100
Subject: [PATCH] net: broadcom: add BCM6348 enetsw controller driver
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
This controller is present on BCM6338, BCM6348 and BCM6358 SoCs.
Signed-off-by: Álvaro Fernández Rojas <noltari@gmail.com>
---
drivers/net/ethernet/broadcom/Kconfig | 8 +
drivers/net/ethernet/broadcom/Makefile | 1 +
3 files changed, 1120 insertions(+)
create mode 100644 drivers/net/ethernet/broadcom/bcm6368-enetsw.c
--- a/drivers/net/ethernet/broadcom/Kconfig
+++ b/drivers/net/ethernet/broadcom/Kconfig
@@ -68,6 +68,14 @@ config BCM63XX_ENET
This driver supports the ethernet MACs in the Broadcom 63xx
MIPS chipset family (BCM63XX).
+config BCM6348_ENET
+ tristate "Broadcom BCM6348 internal mac support"
+ depends on BMIPS_GENERIC || COMPILE_TEST
+ default y
+ help
+ This driver supports Ethernet controller integrated into Broadcom
+ BCM6348 family SoCs.
+
config BCM6368_ENETSW
tristate "Broadcom BCM6368 internal mac support"
depends on BMIPS_GENERIC || COMPILE_TEST
--- a/drivers/net/ethernet/broadcom/Makefile
+++ b/drivers/net/ethernet/broadcom/Makefile
@@ -6,6 +6,7 @@
obj-$(CONFIG_B44) += b44.o
obj-$(CONFIG_BCM4908_ENET) += bcm4908_enet.o
obj-$(CONFIG_BCM63XX_ENET) += bcm63xx_enet.o
+obj-$(CONFIG_BCM6348_ENET) += bcm6348-enet.o
obj-$(CONFIG_BCM6368_ENETSW) += bcm6368-enetsw.o
obj-$(CONFIG_BCMGENET) += genet/
obj-$(CONFIG_BNX2) += bnx2.o

8
target/linux/generic/pending-5.15/760-net-core-add-optional-threading-for-backlog-processi.patch
View file

@ -172,6 +172,14 @@ Signed-off-by: Felix Fietkau <nbd@nbd.name>
#ifdef CONFIG_RPS
remsd = oldsd->rps_ipi_list;
oldsd->rps_ipi_list = NULL;
@@ -11706,6 +11784,7 @@ static int __init net_dev_init(void)
sd->cpu = i;
#endif
+ INIT_LIST_HEAD(&sd->backlog.poll_list);
init_gro_hash(&sd->backlog);
sd->backlog.poll = process_backlog;
sd->backlog.weight = weight_p;
--- a/net/core/sysctl_net_core.c
+++ b/net/core/sysctl_net_core.c
@@ -28,6 +28,7 @@ static int int_3600 = 3600;