Skip to content

L
linux
Commit 94fe8c68 authored by Richard Röjfors's avatar Richard Röjfors Committed by David S. Miller
Browse files
Options

ks8842: Support DMA when accessed via timberdale 

This patch adds support for RX and TX DMA via the DMA API,
this is only supported when the KS8842 is accessed via timberdale.

There is no support for DMA on the generic bus interface it self,
a state machine inside the FPGA is handling RX and TX transfers to/from
buffers in the FPGA. The host CPU can do DMA to and from these buffers.

The FPGA has to handle the RX interrupts, so these must be enabled in
the ks8842 but not in the FPGA. The driver must not disable the RX interrupt
that would mean that the data transfers into the FPGA buffers would stop.

The host shall not enable TX interrupts since TX is handled by the FPGA,
the host is notified by DMA callbacks when transfers are finished.

Which DMA channels to use are added as parameters in the platform data struct.
Signed-off-by: default avatarRichard Röjfors <richard.rojfors@pelagicore.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 3eeb2997
Hide whitespace changes
Inline Side-by-side
Showing with 447 additions and 21 deletions
drivers/net/ks8842.c
View file @ 94fe8c68
......@@ -30,6 +30,9 @@
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/ks8842.h>
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>
#include <linux/scatterlist.h>
#define DRV_NAME "ks8842"
......@@ -82,6 +85,15 @@
#define IRQ_RX_ERROR 0x0080
#define ENABLED_IRQS (IRQ_LINK_CHANGE | IRQ_TX | IRQ_RX | IRQ_RX_STOPPED | \
IRQ_TX_STOPPED | IRQ_RX_OVERRUN | IRQ_RX_ERROR)
/* When running via timberdale in DMA mode, the RX interrupt should be
enabled in the KS8842, but not in the FPGA IP, since the IP handles
RX DMA internally.
TX interrupts are not needed it is handled by the FPGA the driver is
notified via DMA callbacks.
*/
#define ENABLED_IRQS_DMA_IP (IRQ_LINK_CHANGE | IRQ_RX_STOPPED | \
IRQ_TX_STOPPED | IRQ_RX_OVERRUN | IRQ_RX_ERROR)
#define ENABLED_IRQS_DMA (ENABLED_IRQS_DMA_IP | IRQ_RX)
#define REG_ISR 0x02
#define REG_RXSR 0x04
#define RXSR_VALID 0x8000
......@@ -124,6 +136,28 @@
#define MICREL_KS884X 0x01 /* 0=Timeberdale(FPGA), 1=Micrel */
#define KS884X_16BIT 0x02 /* 1=16bit, 0=32bit */
#define DMA_BUFFER_SIZE 2048
struct ks8842_tx_dma_ctl {
struct dma_chan *chan;
struct dma_async_tx_descriptor *adesc;
void *buf;
struct scatterlist sg;
int channel;
};
struct ks8842_rx_dma_ctl {
struct dma_chan *chan;
struct dma_async_tx_descriptor *adesc;
struct sk_buff *skb;
struct scatterlist sg;
struct tasklet_struct tasklet;
int channel;
};
#define KS8842_USE_DMA(adapter) (((adapter)->dma_tx.channel != -1) && \
((adapter)->dma_rx.channel != -1))
struct ks8842_adapter {
void __iomem *hw_addr;
int irq;
......@@ -132,8 +166,19 @@ struct ks8842_adapter {
spinlock_t lock; /* spinlock to be interrupt safe */
struct work_struct timeout_work;
struct net_device *netdev;
struct device *dev;
struct ks8842_tx_dma_ctl dma_tx;
struct ks8842_rx_dma_ctl dma_rx;
};
static void ks8842_dma_rx_cb(void *data);
static void ks8842_dma_tx_cb(void *data);
static inline void ks8842_resume_dma(struct ks8842_adapter *adapter)
{
iowrite32(1, adapter->hw_addr + REQ_TIMB_DMA_RESUME);
}
static inline void ks8842_select_bank(struct ks8842_adapter *adapter, u16 bank)
{
iowrite16(bank, adapter->hw_addr + REG_SELECT_BANK);
......@@ -297,8 +342,19 @@ static void ks8842_reset_hw(struct ks8842_adapter *adapter)
ks8842_write16(adapter, 18, 0xffff, REG_ISR);
/* enable interrupts */
ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
if (KS8842_USE_DMA(adapter)) {
/* When running in DMA Mode the RX interrupt is not enabled in
timberdale because RX data is received by DMA callbacks
it must still be enabled in the KS8842 because it indicates
to timberdale when there is RX data for it's DMA FIFOs */
iowrite16(ENABLED_IRQS_DMA_IP, adapter->hw_addr + REG_TIMB_IER);
ks8842_write16(adapter, 18, ENABLED_IRQS_DMA, REG_IER);
} else {
if (!(adapter->conf_flags & MICREL_KS884X))
iowrite16(ENABLED_IRQS,
adapter->hw_addr + REG_TIMB_IER);
ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
}
/* enable the switch */
ks8842_write16(adapter, 32, 0x1, REG_SW_ID_AND_ENABLE);
}
......@@ -371,6 +427,53 @@ static inline u16 ks8842_tx_fifo_space(struct ks8842_adapter *adapter)
return ks8842_read16(adapter, 16, REG_TXMIR) & 0x1fff;
}
static int ks8842_tx_frame_dma(struct sk_buff *skb, struct net_device *netdev)
{
struct ks8842_adapter *adapter = netdev_priv(netdev);
struct ks8842_tx_dma_ctl *ctl = &adapter->dma_tx;
u8 *buf = ctl->buf;
if (ctl->adesc) {
netdev_dbg(netdev, "%s: TX ongoing\n", __func__);
/* transfer ongoing */
return NETDEV_TX_BUSY;
}
sg_dma_len(&ctl->sg) = skb->len + sizeof(u32);
/* copy data to the TX buffer */
/* the control word, enable IRQ, port 1 and the length */
*buf++ = 0x00;
*buf++ = 0x01; /* Port 1 */
*buf++ = skb->len & 0xff;
*buf++ = (skb->len >> 8) & 0xff;
skb_copy_from_linear_data(skb, buf, skb->len);
dma_sync_single_range_for_device(adapter->dev,
sg_dma_address(&ctl->sg), 0, sg_dma_len(&ctl->sg),
DMA_TO_DEVICE);
/* make sure the length is a multiple of 4 */
if (sg_dma_len(&ctl->sg) % 4)
sg_dma_len(&ctl->sg) += 4 - sg_dma_len(&ctl->sg) % 4;
ctl->adesc = ctl->chan->device->device_prep_slave_sg(ctl->chan,
&ctl->sg, 1, DMA_TO_DEVICE,
DMA_PREP_INTERRUPT | DMA_COMPL_SKIP_SRC_UNMAP);
if (!ctl->adesc)
return NETDEV_TX_BUSY;
ctl->adesc->callback_param = netdev;
ctl->adesc->callback = ks8842_dma_tx_cb;
ctl->adesc->tx_submit(ctl->adesc);
netdev->stats.tx_bytes += skb->len;
dev_kfree_skb(skb);
return NETDEV_TX_OK;
}
static int ks8842_tx_frame(struct sk_buff *skb, struct net_device *netdev)
{
struct ks8842_adapter *adapter = netdev_priv(netdev);
......@@ -422,6 +525,121 @@ static int ks8842_tx_frame(struct sk_buff *skb, struct net_device *netdev)
return NETDEV_TX_OK;
}
static void ks8842_update_rx_err_counters(struct net_device *netdev, u32 status)
{
netdev_dbg(netdev, "RX error, status: %x\n", status);
netdev->stats.rx_errors++;
if (status & RXSR_TOO_LONG)
netdev->stats.rx_length_errors++;
if (status & RXSR_CRC_ERROR)
netdev->stats.rx_crc_errors++;
if (status & RXSR_RUNT)
netdev->stats.rx_frame_errors++;
}
static void ks8842_update_rx_counters(struct net_device *netdev, u32 status,
int len)
{
netdev_dbg(netdev, "RX packet, len: %d\n", len);
netdev->stats.rx_packets++;
netdev->stats.rx_bytes += len;
if (status & RXSR_MULTICAST)
netdev->stats.multicast++;
}
static int __ks8842_start_new_rx_dma(struct net_device *netdev)
{
struct ks8842_adapter *adapter = netdev_priv(netdev);
struct ks8842_rx_dma_ctl *ctl = &adapter->dma_rx;
struct scatterlist *sg = &ctl->sg;
int err;
ctl->skb = netdev_alloc_skb(netdev, DMA_BUFFER_SIZE);
if (ctl->skb) {
sg_init_table(sg, 1);
sg_dma_address(sg) = dma_map_single(adapter->dev,
ctl->skb->data, DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
err = dma_mapping_error(adapter->dev, sg_dma_address(sg));
if (unlikely(err)) {
sg_dma_address(sg) = 0;
goto out;
}
sg_dma_len(sg) = DMA_BUFFER_SIZE;
ctl->adesc = ctl->chan->device->device_prep_slave_sg(ctl->chan,
sg, 1, DMA_FROM_DEVICE,
DMA_PREP_INTERRUPT | DMA_COMPL_SKIP_SRC_UNMAP);
if (!ctl->adesc)
goto out;
ctl->adesc->callback_param = netdev;
ctl->adesc->callback = ks8842_dma_rx_cb;
ctl->adesc->tx_submit(ctl->adesc);
} else {
err = -ENOMEM;
sg_dma_address(sg) = 0;
goto out;
}
return err;
out:
if (sg_dma_address(sg))
dma_unmap_single(adapter->dev, sg_dma_address(sg),
DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
sg_dma_address(sg) = 0;
if (ctl->skb)
dev_kfree_skb(ctl->skb);
ctl->skb = NULL;
printk(KERN_ERR DRV_NAME": Failed to start RX DMA: %d\n", err);
return err;
}
static void ks8842_rx_frame_dma_tasklet(unsigned long arg)
{
struct net_device *netdev = (struct net_device *)arg;
struct ks8842_adapter *adapter = netdev_priv(netdev);
struct ks8842_rx_dma_ctl *ctl = &adapter->dma_rx;
struct sk_buff *skb = ctl->skb;
dma_addr_t addr = sg_dma_address(&ctl->sg);
u32 status;
ctl->adesc = NULL;
/* kick next transfer going */
__ks8842_start_new_rx_dma(netdev);
/* now handle the data we got */
dma_unmap_single(adapter->dev, addr, DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
status = *((u32 *)skb->data);
netdev_dbg(netdev, "%s - rx_data: status: %x\n",
__func__, status & 0xffff);
/* check the status */
if ((status & RXSR_VALID) && !(status & RXSR_ERROR)) {
int len = (status >> 16) & 0x7ff;
ks8842_update_rx_counters(netdev, status, len);
/* reserve 4 bytes which is the status word */
skb_reserve(skb, 4);
skb_put(skb, len);
skb->protocol = eth_type_trans(skb, netdev);
netif_rx(skb);
} else {
ks8842_update_rx_err_counters(netdev, status);
dev_kfree_skb(skb);
}
}
static void ks8842_rx_frame(struct net_device *netdev,
struct ks8842_adapter *adapter)
{
......@@ -445,13 +663,9 @@ static void ks8842_rx_frame(struct net_device *netdev,
if ((status & RXSR_VALID) && !(status & RXSR_ERROR)) {
struct sk_buff *skb = netdev_alloc_skb_ip_align(netdev, len);
netdev_dbg(netdev, "%s, got package, len: %d\n", __func__, len);
if (skb) {
netdev->stats.rx_packets++;
netdev->stats.rx_bytes += len;
if (status & RXSR_MULTICAST)
netdev->stats.multicast++;
ks8842_update_rx_counters(netdev, status, len);
if (adapter->conf_flags & KS884X_16BIT) {
u16 *data16 = (u16 *)skb_put(skb, len);
......@@ -477,16 +691,8 @@ static void ks8842_rx_frame(struct net_device *netdev,
netif_rx(skb);
} else
netdev->stats.rx_dropped++;
} else {
netdev_dbg(netdev, "RX error, status: %x\n", status);
netdev->stats.rx_errors++;
if (status & RXSR_TOO_LONG)
netdev->stats.rx_length_errors++;
if (status & RXSR_CRC_ERROR)
netdev->stats.rx_crc_errors++;
if (status & RXSR_RUNT)
netdev->stats.rx_frame_errors++;
}
} else
ks8842_update_rx_err_counters(netdev, status);
/* set high watermark to 3K */
ks8842_clear_bits(adapter, 0, 1 << 12, REG_QRFCR);
......@@ -541,6 +747,12 @@ void ks8842_tasklet(unsigned long arg)
isr = ks8842_read16(adapter, 18, REG_ISR);
netdev_dbg(netdev, "%s - ISR: 0x%x\n", __func__, isr);
/* when running in DMA mode, do not ack RX interrupts, it is handled
internally by timberdale, otherwise it's DMA FIFO:s would stop
*/
if (KS8842_USE_DMA(adapter))
isr &= ~IRQ_RX;
/* Ack */
ks8842_write16(adapter, 18, isr, REG_ISR);
......@@ -554,9 +766,11 @@ void ks8842_tasklet(unsigned long arg)
if (isr & IRQ_LINK_CHANGE)
ks8842_update_link_status(netdev, adapter);
if (isr & (IRQ_RX | IRQ_RX_ERROR))
/* should not get IRQ_RX when running DMA mode */
if (isr & (IRQ_RX | IRQ_RX_ERROR) && !KS8842_USE_DMA(adapter))
ks8842_handle_rx(netdev, adapter);
/* should only happen when in PIO mode */
if (isr & IRQ_TX)
ks8842_handle_tx(netdev, adapter);
......@@ -575,8 +789,17 @@ void ks8842_tasklet(unsigned long arg)
/* re-enable interrupts, put back the bank selection register */
spin_lock_irqsave(&adapter->lock, flags);
ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
if (KS8842_USE_DMA(adapter))
ks8842_write16(adapter, 18, ENABLED_IRQS_DMA, REG_IER);
else
ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
iowrite16(entry_bank, adapter->hw_addr + REG_SELECT_BANK);
/* Make sure timberdale continues DMA operations, they are stopped while
we are handling the ks8842 because we might change bank */
if (KS8842_USE_DMA(adapter))
ks8842_resume_dma(adapter);
spin_unlock_irqrestore(&adapter->lock, flags);
}
......@@ -592,8 +815,12 @@ static irqreturn_t ks8842_irq(int irq, void *devid)
netdev_dbg(netdev, "%s - ISR: 0x%x\n", __func__, isr);
if (isr) {
/* disable IRQ */
ks8842_write16(adapter, 18, 0x00, REG_IER);
if (KS8842_USE_DMA(adapter))
/* disable all but RX IRQ, since the FPGA relies on it*/
ks8842_write16(adapter, 18, IRQ_RX, REG_IER);
else
/* disable IRQ */
ks8842_write16(adapter, 18, 0x00, REG_IER);
/* schedule tasklet */
tasklet_schedule(&adapter->tasklet);
......@@ -603,9 +830,151 @@ static irqreturn_t ks8842_irq(int irq, void *devid)
iowrite16(entry_bank, adapter->hw_addr + REG_SELECT_BANK);
/* After an interrupt, tell timberdale to continue DMA operations.
DMA is disabled while we are handling the ks8842 because we might
change bank */
ks8842_resume_dma(adapter);
return ret;
}
static void ks8842_dma_rx_cb(void *data)
{
struct net_device *netdev = data;
struct ks8842_adapter *adapter = netdev_priv(netdev);
netdev_dbg(netdev, "RX DMA finished\n");
/* schedule tasklet */
if (adapter->dma_rx.adesc)
tasklet_schedule(&adapter->dma_rx.tasklet);
}
static void ks8842_dma_tx_cb(void *data)
{
struct net_device *netdev = data;
struct ks8842_adapter *adapter = netdev_priv(netdev);
struct ks8842_tx_dma_ctl *ctl = &adapter->dma_tx;
netdev_dbg(netdev, "TX DMA finished\n");
if (!ctl->adesc)
return;
netdev->stats.tx_packets++;
ctl->adesc = NULL;
if (netif_queue_stopped(netdev))
netif_wake_queue(netdev);
}
static void ks8842_stop_dma(struct ks8842_adapter *adapter)
{
struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
tx_ctl->adesc = NULL;
if (tx_ctl->chan)
tx_ctl->chan->device->device_control(tx_ctl->chan,
DMA_TERMINATE_ALL, 0);
rx_ctl->adesc = NULL;
if (rx_ctl->chan)
rx_ctl->chan->device->device_control(rx_ctl->chan,
DMA_TERMINATE_ALL, 0);
if (sg_dma_address(&rx_ctl->sg))
dma_unmap_single(adapter->dev, sg_dma_address(&rx_ctl->sg),
DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
sg_dma_address(&rx_ctl->sg) = 0;
dev_kfree_skb(rx_ctl->skb);
rx_ctl->skb = NULL;
}
static void ks8842_dealloc_dma_bufs(struct ks8842_adapter *adapter)
{
struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
ks8842_stop_dma(adapter);
if (tx_ctl->chan)
dma_release_channel(tx_ctl->chan);
tx_ctl->chan = NULL;
if (rx_ctl->chan)
dma_release_channel(rx_ctl->chan);
rx_ctl->chan = NULL;
tasklet_kill(&rx_ctl->tasklet);
if (sg_dma_address(&tx_ctl->sg))
dma_unmap_single(adapter->dev, sg_dma_address(&tx_ctl->sg),
DMA_BUFFER_SIZE, DMA_TO_DEVICE);
sg_dma_address(&tx_ctl->sg) = 0;
kfree(tx_ctl->buf);
tx_ctl->buf = NULL;
}
static bool ks8842_dma_filter_fn(struct dma_chan *chan, void *filter_param)
{
return chan->chan_id == (int)filter_param;
}
static int ks8842_alloc_dma_bufs(struct net_device *netdev)
{
struct ks8842_adapter *adapter = netdev_priv(netdev);
struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
int err;
dma_cap_mask_t mask;
dma_cap_zero(mask);
dma_cap_set(DMA_SLAVE, mask);
dma_cap_set(DMA_PRIVATE, mask);
sg_init_table(&tx_ctl->sg, 1);
tx_ctl->chan = dma_request_channel(mask, ks8842_dma_filter_fn,
(void *)tx_ctl->channel);
if (!tx_ctl->chan) {
err = -ENODEV;
goto err;
}
/* allocate DMA buffer */
tx_ctl->buf = kmalloc(DMA_BUFFER_SIZE, GFP_KERNEL);
if (!tx_ctl->buf) {
err = -ENOMEM;
goto err;
}
sg_dma_address(&tx_ctl->sg) = dma_map_single(adapter->dev,
tx_ctl->buf, DMA_BUFFER_SIZE, DMA_TO_DEVICE);
err = dma_mapping_error(adapter->dev,
sg_dma_address(&tx_ctl->sg));
if (err) {
sg_dma_address(&tx_ctl->sg) = 0;
goto err;
}
rx_ctl->chan = dma_request_channel(mask, ks8842_dma_filter_fn,
(void *)rx_ctl->channel);
if (!rx_ctl->chan) {
err = -ENODEV;
goto err;
}
tasklet_init(&rx_ctl->tasklet, ks8842_rx_frame_dma_tasklet,
(unsigned long)netdev);
return 0;
err:
ks8842_dealloc_dma_bufs(adapter);
return err;
}
/* Netdevice operations */
......@@ -616,6 +985,25 @@ static int ks8842_open(struct net_device *netdev)
netdev_dbg(netdev, "%s - entry\n", __func__);
if (KS8842_USE_DMA(adapter)) {
err = ks8842_alloc_dma_bufs(netdev);
if (!err) {
/* start RX dma */
err = __ks8842_start_new_rx_dma(netdev);
if (err)
ks8842_dealloc_dma_bufs(adapter);
}
if (err) {
printk(KERN_WARNING DRV_NAME
": Failed to initiate DMA, running PIO\n");
ks8842_dealloc_dma_bufs(adapter);
adapter->dma_rx.channel = -1;
adapter->dma_tx.channel = -1;
}
}
/* reset the HW */
ks8842_reset_hw(adapter);
......@@ -641,6 +1029,9 @@ static int ks8842_close(struct net_device *netdev)
cancel_work_sync(&adapter->timeout_work);
if (KS8842_USE_DMA(adapter))
ks8842_dealloc_dma_bufs(adapter);
/* free the irq */
free_irq(adapter->irq, netdev);
......@@ -658,6 +1049,17 @@ static netdev_tx_t ks8842_xmit_frame(struct sk_buff *skb,
netdev_dbg(netdev, "%s: entry\n", __func__);
if (KS8842_USE_DMA(adapter)) {
unsigned long flags;
ret = ks8842_tx_frame_dma(skb, netdev);
/* for now only allow one transfer at the time */
spin_lock_irqsave(&adapter->lock, flags);
if (adapter->dma_tx.adesc)
netif_stop_queue(netdev);
spin_unlock_irqrestore(&adapter->lock, flags);
return ret;
}
ret = ks8842_tx_frame(skb, netdev);
if (ks8842_tx_fifo_space(adapter) < netdev->mtu + 8)
......@@ -693,6 +1095,10 @@ static void ks8842_tx_timeout_work(struct work_struct *work)
netdev_dbg(netdev, "%s: entry\n", __func__);
spin_lock_irqsave(&adapter->lock, flags);
if (KS8842_USE_DMA(adapter))
ks8842_stop_dma(adapter);
/* disable interrupts */
ks8842_write16(adapter, 18, 0, REG_IER);
ks8842_write16(adapter, 18, 0xFFFF, REG_ISR);
......@@ -706,6 +1112,9 @@ static void ks8842_tx_timeout_work(struct work_struct *work)
ks8842_write_mac_addr(adapter, netdev->dev_addr);
ks8842_update_link_status(netdev, adapter);
if (KS8842_USE_DMA(adapter))
__ks8842_start_new_rx_dma(netdev);
}
static void ks8842_tx_timeout(struct net_device *netdev)
......@@ -765,6 +1174,19 @@ static int __devinit ks8842_probe(struct platform_device *pdev)
goto err_get_irq;
}
adapter->dev = (pdev->dev.parent) ? pdev->dev.parent : &pdev->dev;
/* DMA is only supported when accessed via timberdale */
if (!(adapter->conf_flags & MICREL_KS884X) && pdata &&
(pdata->tx_dma_channel != -1) &&
(pdata->rx_dma_channel != -1)) {
adapter->dma_rx.channel = pdata->rx_dma_channel;
adapter->dma_tx.channel = pdata->tx_dma_channel;
} else {
adapter->dma_rx.channel = -1;
adapter->dma_tx.channel = -1;
}
tasklet_init(&adapter->tasklet, ks8842_tasklet, (unsigned long)netdev);
spin_lock_init(&adapter->lock);
......
include/linux/ks8842.h
View file @ 94fe8c68
......@@ -25,10 +25,14 @@
* struct ks8842_platform_data - Platform data of the KS8842 network driver
* @macaddr: The MAC address of the device, set to all 0:s to use the on in
* the chip.
* @rx_dma_channel: The DMA channel to use for RX, -1 for none.
* @tx_dma_channel: The DMA channel to use for TX, -1 for none.
*
*/
struct ks8842_platform_data {
u8 macaddr[ETH_ALEN];
int rx_dma_channel;
int tx_dma_channel;
};
#endif
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