From efca975add2d5894f2127061c2fc615faf0799d7 Mon Sep 17 00:00:00 2001 From: n028372 Date: Mon, 15 Jan 2024 17:20:03 +0800 Subject: [PATCH 1/8] =?UTF-8?q?=E6=96=B0=E5=A2=9Eusb=5Fnet=5Fadapter?= =?UTF-8?q?=E6=A8=A1=E5=9D=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: n028372 --- adapter/khdf/linux/model/usb/host/Makefile | 3 +- .../model/usb/host/include/usb_net_adapter.h | 92 ++ .../model/usb/host/src/usb_net_adapter.c | 1278 +++++++++++++++++ .../model/usb/include/hdf_usb_net_manager.h | 65 + .../model/usb/include/hdf_usb_pnp_manage.h | 1 + 5 files changed, 1438 insertions(+), 1 deletion(-) create mode 100755 adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h create mode 100755 adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c create mode 100755 framework/model/usb/include/hdf_usb_net_manager.h diff --git a/adapter/khdf/linux/model/usb/host/Makefile b/adapter/khdf/linux/model/usb/host/Makefile index 4a392d9a8..afd1a6eed 100644 --- a/adapter/khdf/linux/model/usb/host/Makefile +++ b/adapter/khdf/linux/model/usb/host/Makefile @@ -11,7 +11,8 @@ USB_PNP_NOTIFY_ROOT_DIR = ./ obj-$(CONFIG_DRIVERS_HDF_USB_PNP_NOTIFY) += \ - $(USB_PNP_NOTIFY_ROOT_DIR)/src/usb_pnp_notify.o + $(USB_PNP_NOTIFY_ROOT_DIR)/src/usb_pnp_notify.o \ + $(USB_PNP_NOTIFY_ROOT_DIR)/src/usb_net_adapter.o ccflags-y += -lm -lc -lgcc \ -I$(srctree)/drivers/hdf/khdf/model/usb/host/include \ diff --git a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h new file mode 100755 index 000000000..588fd77c6 --- /dev/null +++ b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h @@ -0,0 +1,92 @@ +#ifndef HDF_NET_USB_ADAPTER_H +#define HDF_NET_USB_ADAPTER_H + +#include "osal_mutex.h" +#include "hdf_log.h" +#include "hdf_usb_net_manager.h" + +#define HARCH_LOG_TAG "[-net-hdf-]" +#define HARCH_NET_INFO_PRINT(fmt,...) \ +do{ \ + if(1){\ + HDF_LOGI(HARCH_LOG_TAG"[%s][%d]:"fmt"\n",__FUNCTION__,__LINE__,##__VA_ARGS__);}\ +}while(0) + +struct rndis_data_hdr { + __le32 msg_type; /* RNDIS_MSG_PACKET */ + __le32 msg_len; /* rndis_data_hdr + data_len + pad */ + __le32 data_offset; /* 36 -- right after header */ + __le32 data_len; /* ... real packet size */ + + __le32 oob_data_offset; /* zero */ + __le32 oob_data_len; /* zero */ + __le32 num_oob; /* zero */ + __le32 packet_data_offset; /* zero */ + + __le32 packet_data_len; /* zero */ + __le32 vc_handle; /* zero */ + __le32 reserved; /* zero */ +} __attribute__ ((packed)); + +struct UsbnetAdapter{ + struct IDeviceIoService service; + struct HdfDeviceObject *deviceObject; + unsigned can_dma_sg:1; + struct net_device *net; + int32_t msg_enable; + struct UsbnetTransInfo usbnetInfo; + struct OsalMutex sendSkbClock; + + unsigned char pkt_cnt, pkt_err; + + /* various kinds of pending driver work */ + wait_queue_head_t wait; + struct timer_list delay; + + struct sk_buff_head rxq; + struct sk_buff_head txq; + + struct sk_buff_head done; + struct sk_buff_head rxq_pause; + struct tasklet_struct bh; + + struct pcpu_sw_netstats __percpu *stats64; + + struct work_struct kevent; + struct work_struct TxCompleteWorkqueue; + struct work_struct RxCompleteWorkqueue; + unsigned int TxLen; + unsigned int RxLen; + unsigned long flags; +# define EVENT_TX_HALT 0 +# define EVENT_RX_HALT 1 +# define EVENT_RX_MEMORY 2 +# define EVENT_STS_SPLIT 3 +# define EVENT_LINK_RESET 4 +# define EVENT_RX_PAUSED 5 +# define EVENT_DEV_ASLEEP 6 +# define EVENT_DEV_OPEN 7 +# define EVENT_DEVICE_REPORT_IDLE 8 +# define EVENT_NO_RUNTIME_PM 9 +# define EVENT_RX_KILL 10 +# define EVENT_LINK_CHANGE 11 +# define EVENT_SET_RX_MODE 12 +# define EVENT_NO_IP_ALIGN 13 + +}; + +/* we record the state for each of our queued skbs */ +enum skb_state { + illegal = 0, + tx_start, tx_done, + rx_start, rx_done, rx_cleanup, + unlink_start +}; + +struct skb_data { /* skb->cb is one of these */ + enum skb_state state; + long length; + unsigned long packets; +}; + +#endif diff --git a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c new file mode 100755 index 000000000..1ea38d8b1 --- /dev/null +++ b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c @@ -0,0 +1,1278 @@ +#include +#include +#include +#include + +#include +#include +#include +#if defined(CONFIG_DRIVERS_HDF_IMX8MM_ETHERNET) +#include +#include +#endif +#include +#include +#include "osal_mem.h" +#include "securec.h" + +#include "hdf_device_desc.h" +#include "usb_net_adapter.h" + +#define HDF_LOG_TAG UsbnetAdapter +#define TX_TIMEOUT_JIFFIES (5*HZ) +#define RNDIS_MSG_PACKET 0x00000001 /* 1-N packets */ + +// between wakeups +#define UNLINK_TIMEOUT_MS 3 +#define TX_QLEN(dev) ((dev)->usbnetInfo.txQlen) + +/* use ethtool to change the level for any given device */ +static int msg_level = -1; +module_param (msg_level, int, 0); +MODULE_PARM_DESC (msg_level, "Override default message level"); + +static int printf_char_buffer(char *buff, int size, bool isPrint) +{ + if (isPrint) + { + int i = 0; + printk("===-harch-=== printf_char_buffer begin\n"); + for (i = 0; i < size; i++) + { + printk(KERN_CONT"%02x ", buff[i]); + if ((i+1) % 32 == 0) + { + printk(KERN_CONT"\n"); + } + } + printk("===-harch-=== printf_char_buffer end\n"); + } + return 0; +} + +static void analysis_skb(struct sk_buff *skb) { + + struct net_device *dev = skb->dev; + struct ethhdr *ethh = eth_hdr(skb); + struct iphdr *ip = ip_hdr(skb); + + unsigned int *src_ip = &ip->saddr; + unsigned int *dst_ip = &ip->daddr; + unsigned char *src_mac = ethh->h_source; + unsigned char *dst_mac = ethh->h_dest; + + printk(" source ip:%pI4\n",src_ip); + printk(" dest ip:%pI4\n",dst_ip); + printk(" destination eth addr:%x:%x:%x:%x:%x:%x\n", + ethh->h_dest[0],ethh->h_dest[1],ethh->h_dest[2],ethh->h_dest[3],ethh->h_dest[4],ethh->h_dest[5]); + printk(" source eth addr:%x:%x:%x:%x:%x:%x\n", + ethh->h_source[0],ethh->h_source[1],ethh->h_source[2],ethh->h_source[3],ethh->h_source[4],ethh->h_source[5]); +} + +int32_t UsbnetAdapterSendBufToUsb(const struct HdfDeviceObject *device, uint32_t id, + const void *buf, uint32_t writeSize) +{ + HARCH_NET_INFO_PRINT("writeSize: %d", writeSize); + int32_t ret = HDF_SUCCESS; + if ((device == NULL) || (buf == NULL)) { + HDF_LOGE("%s param is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + + struct HdfSBuf *data = HdfSbufObtainDefaultSize(); + if (data == NULL) { + HDF_LOGE("fail to obtain sbuf data"); + return HDF_FAILURE; + } + + if (!HdfSbufWriteBuffer(data, buf, writeSize)) { + HDF_LOGE("fail to write sbuf"); + ret = HDF_FAILURE; + goto out; + } + + if (HdfDeviceSendEvent(device, id, data) != HDF_SUCCESS) { + HDF_LOGE("%s: send sensor data event failed", __func__); + ret = HDF_FAILURE; + goto out; + } + ret = HDF_SUCCESS; + +out: + HdfSbufRecycle(data); + return ret; +} + + +static void rx_complete(struct work_struct *work){ + + unsigned long flags = 0; + struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, RxCompleteWorkqueue); + struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + + HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); + + HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); + + flags = u64_stats_update_begin_irqsave(&stats64->syncp); + stats64->rx_packets++; + stats64->rx_bytes += usbNet->RxLen; + u64_stats_update_end_irqrestore(&stats64->syncp, flags); + + HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); + + HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); + +} + +/* Passes this packet up the stack, updating its accounting. + * Some link protocols batch packets, so their rx_fixup paths + * can return clones as well as just modify the original skb. + */ +void UsbnetAdapterSkbReturn (struct UsbnetAdapter *usbNet, struct sk_buff *skb) +{ + + if (test_bit(EVENT_RX_PAUSED, &usbNet->flags)) { + skb_queue_tail(&usbNet->rxq_pause, skb); + return; + } + + /* only update if unset to allow minidriver rx_fixup override */ + if (skb->protocol == 0) + skb->protocol = eth_type_trans (skb, usbNet->net); + + usbNet->RxLen = skb->len; + schedule_work_on(0,&usbNet->RxCompleteWorkqueue); + HARCH_NET_INFO_PRINT("< rx, len %zu, type 0x%x\n", skb->len + sizeof (struct ethhdr), skb->protocol); + (void)memset_s(skb->cb, sizeof (struct skb_data), 0, sizeof (struct skb_data)); + + if (skb_defer_rx_timestamp(skb)) + return; + + HARCH_NET_INFO_PRINT("-------rx before netif_rx"); + printf_char_buffer(skb->data, skb->len, false); + + int status = NET_RX_SUCCESS; + status = netif_rx (skb); + + HARCH_NET_INFO_PRINT("netif_rx status %d\n", status); + if (status != NET_RX_SUCCESS) + HARCH_NET_INFO_PRINT("netif_rx status %d\n", status); +} + + +/* + * DATA -- host must not write zlps + */ +static int rndisRxFixup(struct UsbnetAdapter *usbNet, struct sk_buff *skb) +{ + /* This check is no longer done by usbnet */ + if (skb->len < usbNet->net->hard_header_len) + return 0; + + /* peripheral may have batched packets to us... */ + while (likely(skb->len)) { + struct rndis_data_hdr *hdr = (void *)skb->data; + struct sk_buff *skb2; + u32 msg_type, msg_len, data_offset, data_len; + + msg_type = le32_to_cpu(hdr->msg_type); + msg_len = le32_to_cpu(hdr->msg_len); + data_offset = le32_to_cpu(hdr->data_offset); + data_len = le32_to_cpu(hdr->data_len); + + /* don't choke if we see oob, per-packet data, etc */ + if (unlikely(msg_type != RNDIS_MSG_PACKET || skb->len < msg_len + || (data_offset + data_len + 8) > msg_len)) { + usbNet->net->stats.rx_frame_errors++; + netdev_dbg(usbNet->net, "bad rndis message %d/%d/%d/%d, len %d\n", + le32_to_cpu(hdr->msg_type), + msg_len, data_offset, data_len, skb->len); + return 0; + } + skb_pull(skb, 8 + data_offset); + + /* at most one packet left? */ + if (likely((data_len - skb->len) <= sizeof *hdr)) { + skb_trim(skb, data_len); + break; + } + + /* try to return all the packets in the batch */ + skb2 = skb_clone(skb, GFP_ATOMIC); + if (unlikely(!skb2)) + break; + skb_pull(skb, msg_len - sizeof *hdr); + skb_trim(skb2, data_len); + UsbnetAdapterSkbReturn(usbNet, skb2); + } + return 1; +} + +static inline void UsbnetAdapterRxProcess (struct UsbnetAdapter *usbNet, struct sk_buff *skb) +{ + HARCH_NET_INFO_PRINT("-------rx before fix"); + printf_char_buffer(skb->data, skb->len, false); + + if (!rndisRxFixup(usbNet, skb)) { + /* With RX_ASSEMBLE, rx_fixup() must update counters */ + if (!(usbNet->usbnetInfo.usbFlags & FLAG_RX_ASSEMBLE)) + usbNet->net->stats.rx_errors++; + goto done; + } + // else network stack removes extra byte if we forced a short packet + HARCH_NET_INFO_PRINT("--------rx after fix"); + printf_char_buffer(skb->data, skb->len, false); + + /* all data was already cloned from skb inside the driver */ + if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) + { + HARCH_NET_INFO_PRINT("usbNet->driver_info->flags = %d",usbNet->usbnetInfo.usbFlags); + goto done; + } + + if (skb->len < ETH_HLEN) { + usbNet->net->stats.rx_errors++; + usbNet->net->stats.rx_length_errors++; + HARCH_NET_INFO_PRINT("rx length %d\n", skb->len); + } else { + HARCH_NET_INFO_PRINT("UsbnetAdapterSkbReturn"); + UsbnetAdapterSkbReturn(usbNet, skb); + return; + } + +done: + skb_queue_tail(&usbNet->done, skb); +} + +static void UsbnetAdapterBh (struct timer_list *t) +{ + HARCH_NET_INFO_PRINT("begin"); + struct UsbnetAdapter *usbNet = from_timer(usbNet, t, delay); + + struct sk_buff *skb = NULL; + struct skb_data *entry = NULL; + + while ((skb = skb_dequeue (&usbNet->done))) { + entry = (struct skb_data *) skb->cb; + HARCH_NET_INFO_PRINT("entry->state = %d",entry->state); + + switch (entry->state) { + case rx_done: + HARCH_NET_INFO_PRINT("rx_done"); + entry->state = rx_cleanup; + UsbnetAdapterRxProcess (usbNet, skb); + continue; + case tx_done: + HARCH_NET_INFO_PRINT("tx_done"); + /* fall-through */ + fallthrough; + case rx_cleanup: + HARCH_NET_INFO_PRINT("rx_cleanup"); + dev_kfree_skb (skb); + continue; + default: + HARCH_NET_INFO_PRINT("bogus skb state %d\n", entry->state); + /* fall-through */ + } + } + HARCH_NET_INFO_PRINT(); + /* restart RX again after disabling due to high error rate */ + clear_bit(EVENT_RX_KILL, &usbNet->flags); + + /* waiting for all pending urbs to complete? + * only then can we forgo submitting anew + */ + if (waitqueue_active(&usbNet->wait)) { + HARCH_NET_INFO_PRINT("waitqueue_active"); + if (usbNet->rxq.qlen + usbNet->txq.qlen + usbNet->done.qlen == 0) + { + HARCH_NET_INFO_PRINT(); + wake_up_all(&usbNet->wait); + } + } + + if (usbNet->txq.qlen < TX_QLEN (usbNet)) + { + netif_wake_queue (usbNet->net); + HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",usbNet->txq.qlen,TX_QLEN (usbNet)); + } + HARCH_NET_INFO_PRINT("end"); +} + +static void UsbnetAdapterBhTasklet(unsigned long data) +{ + HARCH_NET_INFO_PRINT("begin"); + struct timer_list *t = (struct timer_list *)data; + + UsbnetAdapterBh(t); + HARCH_NET_INFO_PRINT("end"); +} + +/* The caller must hold list->lock */ +static void UsbnetAdapterQueueSkb(struct sk_buff_head *list, + struct sk_buff *newsk, enum skb_state state) +{ + struct skb_data *entry = (struct skb_data *) newsk->cb; + + __skb_queue_tail(list, newsk); + entry->state = state; +} + +static enum skb_state UsbnetAdapterDeferBh(struct UsbnetAdapter *usbNet, struct sk_buff *skb, + struct sk_buff_head *list, enum skb_state state) +{ + unsigned long flags = 0; + enum skb_state old_state = illegal; + struct skb_data *entry = (struct skb_data *) skb->cb; + + spin_lock_irqsave(&list->lock, flags); + old_state = entry->state; + entry->state = state; + __skb_unlink(skb, list); + + /* UsbnetAdapterDeferBh() is never called with list == &usbNet->done. + * spin_lock_nested() tells lockdep that it is OK to take + * usbNet->done.lock here with list->lock held. + */ + spin_lock_nested(&usbNet->done.lock, SINGLE_DEPTH_NESTING); + + __skb_queue_tail(&usbNet->done, skb); + if (usbNet->done.qlen == 1) + tasklet_schedule(&usbNet->bh); + + spin_unlock(&usbNet->done.lock); + spin_unlock_irqrestore(&list->lock, flags); + + return old_state; +} + +int32_t UsbnetAdapterOpen(struct net_device *net) +{ + HARCH_NET_INFO_PRINT("begin"); + if (NULL == net) + { + HDF_LOGE("net device object is invalid"); + return HDF_FAILURE; + } + struct UsbnetAdapter *usbNet = netdev_priv(net); + if (NULL == usbNet) + { + HDF_LOGE("usb net adapter object is invalid"); + return HDF_FAILURE; + } + + set_bit(EVENT_DEV_OPEN, &usbNet->flags); + + netif_start_queue (net); + + /* set device param, if find usb net host need, then it should send to it */ + /* reset rx error state */ + usbNet->pkt_cnt = 0; + usbNet->pkt_err = 0; + + clear_bit(EVENT_RX_KILL, &usbNet->flags); + + /* send info to usb start usb function */ + /* need transform usb_net_host change about usbNet->driverInfo->flags and set it on usb_net_host */ + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_OPEN_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + if (ret != HDF_SUCCESS) + { + HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); + OsalMutexUnlock(&usbNet->sendSkbClock); + return HDF_FAILURE; + } + OsalMutexUnlock(&usbNet->sendSkbClock); + + tasklet_schedule (&usbNet->bh); + + return HDF_SUCCESS; +} + +static void waitSkbQueueEmpty(struct sk_buff_head *q) +{ + unsigned long flags = 0; + HARCH_NET_INFO_PRINT(); + spin_lock_irqsave(&q->lock, flags); + while (!skb_queue_empty(q)) { + spin_unlock_irqrestore(&q->lock, flags); + schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS)); + set_current_state(TASK_UNINTERRUPTIBLE); + spin_lock_irqsave(&q->lock, flags); + } + spin_unlock_irqrestore(&q->lock, flags); +} + +// precondition: never called in_interrupt +static void UsbnetAdapterTerminateUrbs(struct UsbnetAdapter *usbNet) +{ + HARCH_NET_INFO_PRINT(); + + DECLARE_WAITQUEUE(wait, current); + /* ensure there are no more active urbs */ + add_wait_queue(&usbNet->wait, &wait); + set_current_state(TASK_UNINTERRUPTIBLE); + /* maybe wait for deletions to finish. */ + waitSkbQueueEmpty(&usbNet->rxq); + waitSkbQueueEmpty(&usbNet->txq); + + waitSkbQueueEmpty(&usbNet->done); + set_current_state(TASK_RUNNING); + remove_wait_queue(&usbNet->wait, &wait); +} + +int32_t UsbnetAdapterStop(struct net_device *net) +{ + HARCH_NET_INFO_PRINT("begin"); + if (NULL == net) + { + HDF_LOGE("net device object is invalid"); + return HDF_FAILURE; + } + + struct UsbnetAdapter *usbNet = netdev_priv(net); + if (NULL == usbNet) + { + HDF_LOGE("usb net adapter object is invalid"); + return HDF_FAILURE; + } + + struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + + HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); + + HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); + + /* 1. clear_bit(EVENT_DEV_OPEN, &dev->flags); */ + clear_bit(EVENT_DEV_OPEN, &usbNet->flags); + /* 2. netif_stop_queue (net); */ + netif_stop_queue (net); + HARCH_NET_INFO_PRINT("stop stats: rx/tx %lu/%lu, errs %lu/%lu\n", + net->stats.rx_packets, net->stats.tx_packets, + net->stats.rx_errors, net->stats.tx_errors); + + /* 3. pm = usb_autopm_get_interface(dev->intf); do nothing */ + /* 4. if (info->stop) { no stop interface impl in rndis driver info */ + /* 5. if (!(info->flags & FLAG_AVOID_UNLINK_URBS)) do nothing*/ + if (!(usbNet->usbnetInfo.usbFlags & FLAG_AVOID_UNLINK_URBS)){ + UsbnetAdapterTerminateUrbs(usbNet); + } + + /* 6. usbnet_status_stop(dev); none */ + /* 7. usbnet_purge_paused_rxq(dev); none */ + skb_queue_purge(&usbNet->rxq_pause); + /* 8. mpn = !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags); if (info->manage_power && mpn) + no manage_power interface impl in rndis driver info*/ + /* 9. dev->flags = 0; */ + usbNet->flags = 0; + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_CLOSE_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + if (ret != HDF_SUCCESS) + { + HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); + OsalMutexUnlock(&usbNet->sendSkbClock); + return HDF_FAILURE; + } + OsalMutexUnlock(&usbNet->sendSkbClock); + /* 10. del_timer_sync (&dev->delay); */ + del_timer_sync (&usbNet->delay); + /* 11. tasklet_kill (&dev->bh); */ + tasklet_kill (&usbNet->bh); + /* 12. cancel_work_sync(&dev->kevent); no kevent, do nothing */ + //cancel_work_sync(&usbNet->kevent); + cancel_work_sync(&usbNet->TxCompleteWorkqueue); + cancel_work_sync(&usbNet->RxCompleteWorkqueue); + return HDF_SUCCESS; +} + +struct sk_buff *RndisTxFixup(struct sk_buff *skb, gfp_t flags) +{ + struct rndis_data_hdr *hdr = NULL; + struct sk_buff *skb2 = NULL; + unsigned len = skb->len; + + if (likely(!skb_cloned(skb))) { + int room = skb_headroom(skb); + + /* enough head room as-is? */ + if (unlikely((sizeof *hdr) <= room)) + goto fill; + + /* enough room, but needs to be readjusted? */ + room += skb_tailroom(skb); + if (likely((sizeof *hdr) <= room)) { + skb->data = memmove(skb->head + sizeof *hdr, + skb->data, len); + skb_set_tail_pointer(skb, len); + goto fill; + } + } + + /* create a new skb, with the correct size (and tailpad) */ + skb2 = skb_copy_expand(skb, sizeof *hdr, 1, flags); + dev_kfree_skb_any(skb); + if (unlikely(!skb2)) + return skb2; + skb = skb2; + + /* fill out the RNDIS header. we won't bother trying to batch + * packets; Linux minimizes wasted bandwidth through tx queues. + */ +fill: + HARCH_NET_INFO_PRINT("%s:%d fill skb by rndis host", __func__, __LINE__); + hdr = __skb_push(skb, sizeof *hdr); + memset(hdr, 0, sizeof *hdr); + hdr->msg_type = cpu_to_le32(RNDIS_MSG_PACKET); + hdr->msg_len = cpu_to_le32(skb->len); + hdr->data_offset = cpu_to_le32(sizeof(*hdr) - 8); + hdr->data_len = cpu_to_le32(len); + + /* FIXME make the last packet always be short ... */ + return skb; +} + +static void tx_complete(struct work_struct *work) +{ + unsigned long flags = 0; + struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, TxCompleteWorkqueue); + struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + + printk("tx_complete dump_stack start usbNet->usbnetInfo.mtu = %d\n",usbNet->usbnetInfo.mtu); + dump_stack(); + printk("tx_complete dump_stack end\n"); + + HARCH_NET_INFO_PRINT("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); + + HARCH_NET_INFO_PRINT("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); + + flags = u64_stats_update_begin_irqsave(&stats64->syncp); + stats64->tx_packets++; + stats64->tx_bytes += usbNet->TxLen; + u64_stats_update_end_irqrestore(&stats64->syncp, flags); + + HARCH_NET_INFO_PRINT("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); + + HARCH_NET_INFO_PRINT("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); +} + +netdev_tx_t UsbnetAdapterStartXmit(struct sk_buff *skb, struct net_device *net) +{ + analysis_skb(skb); + HARCH_NET_INFO_PRINT("netif_running = %d, netif_device_present = %d" , netif_running (net),netif_device_present (net)); + HARCH_NET_INFO_PRINT("netif_carrier_ok = %d" , netif_carrier_ok (net)); + + /* print org skb data info */ + HARCH_NET_INFO_PRINT("UsbnetAdapterStartXmit skb->data = %x, len = %d",skb->data, skb->len); + printf_char_buffer(skb->data, skb->len, false); + struct UsbnetAdapter *usbNet = netdev_priv(net); + + //1.time tamp + if (skb) + skb_tx_timestamp(skb); + //2.fix up + struct sk_buff* skb_fixup = NULL; + + /* rndis fixup sk_buf */ + skb_fixup = RndisTxFixup(skb, GFP_ATOMIC); + if (NULL == skb_fixup) + { + if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET){ + goto not_drop; + } + HDF_LOGE("fail to tx fixup by rndis host"); + goto drop; + } + + HARCH_NET_INFO_PRINT("UsbnetAdapterStartXmit skb_fixup->data = %x, len = %d",skb_fixup->data, skb_fixup->len); + /* print org skb data info */ + printf_char_buffer(skb_fixup->data, skb_fixup->len, false); + //3.send to usb + + // send msg to usb + unsigned long flags = 0; + spin_lock_irqsave(&usbNet->txq.lock, flags); + if (netif_queue_stopped(usbNet->net)) { + goto drop; + } + + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_SEND_DATA_TO_USB, + (unsigned char *)(skb_fixup->data), skb_fixup->len); + + if (ret != HDF_SUCCESS) { + HDF_LOGE("fail to UsbnetHost SendEvent!"); +drop: + net->stats.tx_dropped++; +not_drop: + spin_unlock_irqrestore(&usbNet->txq.lock, flags); + if (skb_fixup) { + dev_kfree_skb_any (skb_fixup); + } + } else { + netif_trans_update(usbNet->net); + UsbnetAdapterQueueSkb(&usbNet->txq, skb_fixup, tx_start); + + if (usbNet->txq.qlen >= TX_QLEN (usbNet)) + { + HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",usbNet->txq.qlen,TX_QLEN (usbNet)); + netif_stop_queue (usbNet->net); + } + + spin_unlock_irqrestore(&usbNet->txq.lock, flags); + + usbNet->TxLen = skb_fixup->len; + schedule_work_on(0,&usbNet->TxCompleteWorkqueue); + + enum skb_state state = UsbnetAdapterDeferBh(usbNet, skb_fixup, &usbNet->txq, tx_done); + HARCH_NET_INFO_PRINT("state= %d", state); + + HARCH_NET_INFO_PRINT("========print tosend skb data info========"); + } + return NETDEV_TX_OK; +} + +static void UsbnetAdapterTXTimeout(struct net_device *net, unsigned int txqueue) +{ + //send to device + HARCH_NET_INFO_PRINT("begin"); + if ( NULL == net) { + HDF_LOGE("%s net device object is invalid", __func__); + return; + } + struct UsbnetAdapter *usbNet = netdev_priv(net); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + /* 1. unlink_urbs (dev, &dev->txq); maybe later be used */ + + /* 2. tasklet_schedule (&dev->bh) */ + tasklet_schedule (&usbNet->bh); + + /* 3. if (dev->driver_info->recover) none, rndis host no recover impl */ + + return; +} + +/* some work can't be done in tasklets, so we use keventd + * + * NOTE: annoying asymmetry: if it's active, schedule_work() fails, + * but tasklet_schedule() doesn't. hope the failure is rare. + */ +void UsbnetAdapter_defer_kevent (struct UsbnetAdapter *usbNet, int work) +{ + HARCH_NET_INFO_PRINT("begin"); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + set_bit (work, &usbNet->flags); + /* need update flags to usb_net_host */ + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + if (ret != HDF_SUCCESS) + { + HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); + OsalMutexUnlock(&usbNet->sendSkbClock); + return; + } + OsalMutexUnlock(&usbNet->sendSkbClock); + + if (!schedule_work (&usbNet->kevent)) + HARCH_NET_INFO_PRINT("kevent %d may have been dropped\n", work); + else + HARCH_NET_INFO_PRINT("kevent %d scheduled\n", work); +} + +void UsbnetAdapterSetRxMode(struct net_device *net) +{ + //send to device + HARCH_NET_INFO_PRINT("begin"); + return; + + if ( NULL == net) { + HDF_LOGE("%s net device object is invalid", __func__); + return; + } + struct UsbnetAdapter *usbNet = netdev_priv(net); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + /* usbnet_defer_kevent(dev, EVENT_SET_RX_MODE); */ + UsbnetAdapter_defer_kevent(usbNet, EVENT_SET_RX_MODE); + return; +} + +void UsbnetAdapter_pause_rx(struct UsbnetAdapter *usbNet) +{ + HARCH_NET_INFO_PRINT("begin"); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + set_bit(EVENT_RX_PAUSED, &usbNet->flags); + /* need update flags to usb_net_host */ + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + if (ret != HDF_SUCCESS) + { + HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); + OsalMutexUnlock(&usbNet->sendSkbClock); + return; + } + OsalMutexUnlock(&usbNet->sendSkbClock); + + HARCH_NET_INFO_PRINT("paused rx queue enabled\n"); +} + +void UsbnetAdapter_unlink_rx_urbs(struct UsbnetAdapter *usbNet) +{ + HARCH_NET_INFO_PRINT("begin"); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + + if (netif_running(usbNet->net)) { + /* (void) unlink_urbs (usbNet, &usbNet->rxq); */ + tasklet_schedule(&usbNet->bh); + } +} + +void UsbnetAdapter_resume_rx(struct UsbnetAdapter *usbNet) +{ + HARCH_NET_INFO_PRINT("begin"); + int num = 0; + struct sk_buff *skb = NULL; + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + + clear_bit(EVENT_RX_PAUSED, &usbNet->flags); + /* need update flags to usb_net_host */ + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + if (ret != HDF_SUCCESS) + { + HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); + OsalMutexUnlock(&usbNet->sendSkbClock); + return; + } + OsalMutexUnlock(&usbNet->sendSkbClock); + + while ((skb = skb_dequeue(&usbNet->rxq_pause)) != NULL) { + UsbnetAdapterSkbReturn(usbNet, skb); + num++; + } + + tasklet_schedule(&usbNet->bh); + HARCH_NET_INFO_PRINT("paused rx queue disabled, %d skbs requeued\n", num); +} + + +int32_t UsbnetAdapterChangeMtu(struct net_device *net, int newMtu) +{ + //send to device + HARCH_NET_INFO_PRINT("begin"); + if ( NULL == net) { + HDF_LOGE("%s net device object is invalid", __func__); + return HDF_FAILURE; + } + + struct UsbnetAdapter *usbNet = netdev_priv(net); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return HDF_FAILURE; + } + + /* 1. int ll_mtu = new_mtu + net->hard_header_len; + int old_hard_mtu = dev->hard_mtu; + int old_rx_urb_size = dev->rx_urb_size; + */ + HARCH_NET_INFO_PRINT("newMtu:%d", newMtu); + int ll_mtu = newMtu + net->hard_header_len; + int old_hard_mtu = usbNet->usbnetInfo.hardMtu; + int old_rx_urb_size = usbNet->usbnetInfo.rxUrbSize; + + /* 2. no second zero-length packet read wanted after mtu-sized packets */ + if ((ll_mtu % usbNet->usbnetInfo.maxpacket) == 0) { + HARCH_NET_INFO_PRINT(""); + return -EDOM; + } + + /* 3. set usbNet->hard_mtu */ + net->mtu = newMtu; + usbNet->usbnetInfo.hardMtu = net->mtu + net->hard_header_len; + + /* 4. pause and resume usbnet */ + if (usbNet->usbnetInfo.rxUrbSize == old_hard_mtu) { + usbNet->usbnetInfo.rxUrbSize = usbNet->usbnetInfo.hardMtu; + if (usbNet->usbnetInfo.rxUrbSize > old_rx_urb_size) { + UsbnetAdapter_pause_rx(usbNet); + UsbnetAdapter_unlink_rx_urbs(usbNet); + UsbnetAdapter_resume_rx(usbNet); + } + } + + /* need transmit hard_mtu to usb net host, UsbnetHostUpdateMaxQlen need this param */ + HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x mtu = %d, hardHeaderLen = %d, link = %d needReset = %d, hardMtu = %d, rxUrbSize = %d, maxpacket =%d", + usbNet->usbnetInfo.name,usbNet->usbnetInfo.flags, usbNet->usbnetInfo.usbFlags, + usbNet->usbnetInfo.mtu, usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, + usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu, usbNet->usbnetInfo.rxUrbSize, + usbNet->usbnetInfo.maxpacket + ); + /* 5. max qlen depend on hard_mtu and rx_urb_size */ + //UsbnetHostUpdateMaxQlen(usbNet); + /* need update flags to usb_net_host */ + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_MAXQLEN, (const void *)&usbNet->usbnetInfo, sizeof(usbNet->usbnetInfo)); + if (ret != HDF_SUCCESS) + { + HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); + OsalMutexUnlock(&usbNet->sendSkbClock); + return ret; + } + OsalMutexUnlock(&usbNet->sendSkbClock); + return HDF_SUCCESS; +} + +void UsbnetAdapterGetStats64(struct net_device *net, struct rtnl_link_stats64 *stats) +{ + //send to device + HARCH_NET_INFO_PRINT("begin"); + + struct UsbnetAdapter *usbNet = netdev_priv(net); + netdev_stats_to_stats64(stats, &net->stats); + dev_fetch_sw_netstats(stats, usbNet->stats64); + + struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + + HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); + + HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); + + HARCH_NET_INFO_PRINT("end"); + + return; +} + +static struct net_device_ops g_UsbnetAdapterDeviceOps = { + .ndo_open = UsbnetAdapterOpen, + .ndo_stop = UsbnetAdapterStop, + .ndo_start_xmit = UsbnetAdapterStartXmit, + .ndo_tx_timeout = UsbnetAdapterTXTimeout, + .ndo_set_rx_mode = UsbnetAdapterSetRxMode, + .ndo_change_mtu = UsbnetAdapterChangeMtu, + .ndo_get_stats64 = UsbnetAdapterGetStats64, + .ndo_set_mac_address = eth_mac_addr, + .ndo_validate_addr = eth_validate_addr, +}; + +/* drivers may override default ethtool_ops in their bind() routine */ +static const struct ethtool_ops g_UsbnetAdapterEthtoolOps = { +}; + +void UsbnetAdapterLinkChange(struct UsbnetAdapter *usbNet, bool link, bool need_reset) +{ + HARCH_NET_INFO_PRINT("begin"); + /* update link after link is reseted */ + if (link && !need_reset) + netif_carrier_on(usbNet->net); + else + netif_carrier_off(usbNet->net); +} + +static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct HdfSBuf *data, gfp_t flags) +{ + HARCH_NET_INFO_PRINT("begin"); + unsigned char *buff = NULL; + uint32_t infoSize = 0; + int ret = HDF_SUCCESS; + + bool flag = HdfSbufReadBuffer(data, (const void **)(&(buff)), &infoSize); + if ((!flag) || buff == NULL) { + HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag); + return HDF_ERR_INVALID_PARAM; + } + + HARCH_NET_INFO_PRINT("infoSize= %d", infoSize); + struct net_device *net = (struct net_device *)device->priv; + if (net == NULL) + return HDF_ERR_INVALID_PARAM; + + HARCH_NET_INFO_PRINT("recv msg buff"); + printf_char_buffer(buff, infoSize, false); + + + struct UsbnetAdapter *usbNet = netdev_priv(net); + if (usbNet == NULL) + return HDF_ERR_INVALID_PARAM; + + struct sk_buff *skb = NULL; + struct skb_data *entry = NULL; + uint32_t skb_size = sizeof(struct iphdr) + sizeof(struct udphdr) + infoSize; + size_t size = (skb_size > usbNet->usbnetInfo.rxUrbSize ? usbNet->usbnetInfo.rxUrbSize : skb_size ); + HARCH_NET_INFO_PRINT("size = %d", size); + + if (test_bit(EVENT_NO_IP_ALIGN, &usbNet->flags)) + skb = __netdev_alloc_skb(usbNet->net, size, flags); + else + skb = __netdev_alloc_skb_ip_align(usbNet->net, size, flags); + + if (!skb) { + HARCH_NET_INFO_PRINT("no rx skb\n"); + UsbnetAdapter_defer_kevent(usbNet, EVENT_RX_MEMORY); + return HDF_DEV_ERR_NO_MEMORY; + } + + entry = (struct skb_data *) skb->cb; + entry->length = 0; + skb_put (skb, infoSize); + if (memcpy_s(skb->data, infoSize, buff, infoSize) != EOK) { + HARCH_NET_INFO_PRINT("memcpy_s error "); + return HDF_ERR_INVALID_PARAM; + } + + HARCH_NET_INFO_PRINT("skb->len = %d",skb->len); + HARCH_NET_INFO_PRINT("recv msg skbBuff"); + printf_char_buffer(skb->data, skb->len, false); + + // success recv + unsigned long lockflags = 0; + spin_lock_irqsave (&usbNet->rxq.lock, lockflags); + UsbnetAdapterQueueSkb(&usbNet->rxq, skb, rx_start); + spin_unlock_irqrestore (&usbNet->rxq.lock, lockflags); + + struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); + + // rx complete + enum skb_state state = rx_done; + /* stop rx if packet error rate is high */ + if (++usbNet->pkt_cnt > 30) { + HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); + usbNet->pkt_cnt = 0; + usbNet->pkt_err = 0; + } else { + HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); + if (state == rx_cleanup) + usbNet->pkt_err++; + + if (usbNet->pkt_err > 20) + set_bit(EVENT_RX_KILL, &usbNet->flags); + } + HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); + state = UsbnetAdapterDeferBh(usbNet, skb, &usbNet->rxq, state); + HARCH_NET_INFO_PRINT("state= %d", state); + + HARCH_NET_INFO_PRINT("end"); + return HDF_SUCCESS; +} + +// precondition: never called in_interrupt +static struct device_type wlanType = { + .name = "wlan", +}; + +static struct device_type wwanType = { + .name = "wwan", +}; + +int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) +{ + HARCH_NET_INFO_PRINT("begin"); + int ret = HDF_SUCCESS; + uint32_t infoSize = 0; + struct UsbnetTransInfo *uNetTransInfo = NULL; + + bool flag = HdfSbufReadBuffer(data, (const void **)(&(uNetTransInfo)), &infoSize); + if ((!flag) || uNetTransInfo == NULL) { + ret = HDF_ERR_INVALID_PARAM; + HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag); + return ret; + } + + struct net_device *net = alloc_etherdev(sizeof(struct UsbnetAdapter)); + if (net == NULL) { + HARCH_NET_INFO_PRINT(); + goto out; + } + + device->priv = net; + HARCH_NET_INFO_PRINT(); + struct UsbnetAdapter *usbNet = netdev_priv(net); + usbNet->deviceObject = device; + + //info from usb + if (memcpy_s(&(usbNet->usbnetInfo), sizeof(struct UsbnetTransInfo), + uNetTransInfo, sizeof(struct UsbnetTransInfo)) != EOK) { + HARCH_NET_INFO_PRINT("memcpy_s error "); + goto out0; + } + + HARCH_NET_INFO_PRINT("name = %s, \ + flags = %d, \ + usbFlags = %x, \ + mtu = %d, \ + hardHeaderLen = %d, \ + link = %d, \ + needReset = %d, \ + hardMtu = %d, \ + rxUrbSize = %d, \ + maxpacket = %d", + usbNet->usbnetInfo.name, + usbNet->usbnetInfo.flags, + usbNet->usbnetInfo.usbFlags, + usbNet->usbnetInfo.mtu, + usbNet->usbnetInfo.hardHeaderLen, + usbNet->usbnetInfo.link, + usbNet->usbnetInfo.needReset, + usbNet->usbnetInfo.hardMtu, + usbNet->usbnetInfo.rxUrbSize, + usbNet->usbnetInfo.maxpacket); + + usbNet->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); + if (!usbNet->stats64) + goto out0; + + usbNet->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV + | NETIF_MSG_PROBE | NETIF_MSG_LINK| NETIF_MSG_RX_ERR|NETIF_MSG_TX_ERR); + + OsalMutexInit(&usbNet->sendSkbClock); + + init_waitqueue_head(&usbNet->wait); + skb_queue_head_init (&usbNet->rxq); + skb_queue_head_init (&usbNet->txq); + skb_queue_head_init (&usbNet->done); + skb_queue_head_init(&usbNet->rxq_pause); + + // init work for tx_complete rx_complete + INIT_WORK(&usbNet->TxCompleteWorkqueue, tx_complete); + INIT_WORK(&usbNet->RxCompleteWorkqueue, rx_complete); + + usbNet->bh.func = (void (*)(unsigned long))UsbnetAdapterBhTasklet; + usbNet->bh.data = (unsigned long)&usbNet->delay; //struct timer_list delay; + + timer_setup(&usbNet->delay, UsbnetAdapterBh, 0); + + usbNet->net = net; + // 1.addr + static u8 node_id[ETH_ALEN]; + if (usbNet->usbnetInfo.isGetmacAddr) + { + if (memcpy_s(node_id, ETH_ALEN, usbNet->usbnetInfo.macAddr, ETH_ALEN) != EOK) { + goto out0; + } + }else + { + eth_random_addr(node_id); + } + memcpy(net->dev_addr, node_id, sizeof(node_id)); + HARCH_NET_INFO_PRINT("macAddr addr %pM", net->dev_addr); + + // 2. mtu + net->min_mtu = 0; + net->max_mtu = ETH_MAX_MTU; + + net->netdev_ops = &g_UsbnetAdapterDeviceOps; + net->watchdog_timeo = TX_TIMEOUT_JIFFIES; + net->ethtool_ops = &g_UsbnetAdapterEthtoolOps; + + //3. name and mtu + strcpy (net->name, "usb%d"); + if (usbNet->usbnetInfo.isBindDevice) + { + /* heuristic: "usb%d" for links we know are two-host, + else "eth%d" when there's reasonable doubt. userspace + can rename the link if it knows better. + */ + if ((usbNet->usbnetInfo.usbFlags & FLAG_ETHER) != 0 && + ((usbNet->usbnetInfo.usbFlags & FLAG_POINTTOPOINT) == 0 || + (net->dev_addr[0] & 0x02) == 0)) + { + HARCH_NET_INFO_PRINT(); + strcpy (net->name, "eth%d"); + } + + /* WLAN devices should always be named "wlan%d" */ + if ((usbNet->usbnetInfo.usbFlags & FLAG_WLAN) != 0) + { + HARCH_NET_INFO_PRINT(); + strcpy(net->name, "wlan%d"); + } + /* WWAN devices should always be named "wwan%d" */ + if ((usbNet->usbnetInfo.usbFlags & FLAG_WWAN) != 0) + { + HARCH_NET_INFO_PRINT(); + strcpy(net->name, "wwan%d"); + } + + /* devices that cannot do ARP */ + if ((usbNet->usbnetInfo.usbFlags & FLAG_NOARP) != 0) + { + net->flags |= IFF_NOARP; + } + + HARCH_NET_INFO_PRINT("usbNet->usbnetInfo.mtu = %d",usbNet->usbnetInfo.mtu); + /* maybe the remote can't receive an Ethernet MTU */ + net->mtu = usbNet->usbnetInfo.mtu; + net->hard_header_len = usbNet->usbnetInfo.hardHeaderLen; + + HARCH_NET_INFO_PRINT("net->mtu= %d",net->mtu); + } + + HARCH_NET_INFO_PRINT("net->name= %s",net->name); + /* let userspace know we have a random address */ + if (ether_addr_equal(net->dev_addr, node_id)) + net->addr_assign_type = NET_ADDR_RANDOM; + + if ((usbNet->usbnetInfo.usbFlags & FLAG_WLAN) != 0) + SET_NETDEV_DEVTYPE(net, &wlanType); + + if (usbNet->usbnetInfo.usbFlags & FLAG_WWAN != 0) + SET_NETDEV_DEVTYPE(net, &wwanType); + + ret = register_netdev(net); + if (ret) + goto out0; + + HARCH_NET_INFO_PRINT( "register net %pM\n", net->dev_addr); + + netif_device_attach(net); + + HARCH_NET_INFO_PRINT( "netif_device_attach net %pM\n", net->dev_addr); + + if (usbNet->usbnetInfo.usbFlags & FLAG_LINK_INTR) + { + HARCH_NET_INFO_PRINT(); + UsbnetAdapterLinkChange(usbNet, 0, 0); + } + return HDF_SUCCESS; + +out0: + cancel_work_sync(&usbNet->TxCompleteWorkqueue); + cancel_work_sync(&usbNet->RxCompleteWorkqueue); + free_netdev(net); +out: + return ret; +} + +static int32_t UsbnetAdapterDisconnect(struct HdfDeviceObject *device) +{ + HARCH_NET_INFO_PRINT("begin"); + if (device == NULL) { + HDF_LOGI("%s: device is null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + //free net + struct net_device *net = (struct net_device *)device->priv; + unregister_netdev (net); + + struct UsbnetAdapter *usbNet = netdev_priv(net); + if (usbNet->stats64) + { + free_percpu(usbNet->stats64); + } + + UsbnetAdapterTerminateUrbs(usbNet); + skb_queue_purge(&usbNet->rxq_pause); + OsalMutexDestroy(&usbNet->sendSkbClock); + + free_netdev(net); + return HDF_SUCCESS; +} + +static int32_t UsbnetAdapterDispatch( + struct HdfDeviceIoClient *client, int32_t cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HARCH_NET_INFO_PRINT("begin, received cmd = %d", cmd); + + int32_t ret = HDF_ERR_INVALID_PARAM; + switch (cmd) + { + case USB_NET_REGISTER_NET: + { + //add new usbnet device + ret = UsbnetAdapterProbe(client->device, data); + } + break; + case USB_NET_CLOSE_NET: + { + ret = UsbnetAdapterDisconnect(client->device); + } + break; + case USB_NET_RECIVE_DATA_FROM_USB: + { + ret = UsbnetAdapterRxComplete(client->device, data, GFP_ATOMIC); + } + break; + default: + HDF_LOGI("%s: no this cmd: %d", __func__, cmd); + break; + } + + if (!HdfSbufWriteInt32(reply, ret)) { + HDF_LOGE("%s: reply int32 fail", __func__); + } + + return ret; +} + +static int32_t UsbnetAdapterBind(struct HdfDeviceObject *device) +{ + HARCH_NET_INFO_PRINT("begin"); + static struct IDeviceIoService UsbnetAdapterService = { + .Dispatch = UsbnetAdapterDispatch, + }; + + if (device == NULL) { + HARCH_NET_INFO_PRINT("device is NULL!"); + return HDF_ERR_INVALID_OBJECT; + } + device->service = &UsbnetAdapterService; + return HDF_SUCCESS; +} + +static int32_t UsbnetAdapterInit(struct HdfDeviceObject *device) +{ + HARCH_NET_INFO_PRINT("begin"); + if (device == NULL) { + HARCH_NET_INFO_PRINT("device is null!"); + return HDF_FAILURE; + } + + HARCH_NET_INFO_PRINT("UsbnetAdapterInit Init success"); + return HDF_SUCCESS; +} + +static void UsbnetAdapterRelease(struct HdfDeviceObject *device) +{ + HARCH_NET_INFO_PRINT("begin"); + return; +} + +struct HdfDriverEntry g_UsbnetAdapterEntry = { + .moduleVersion = 1, + .Bind = UsbnetAdapterBind, + .Init = UsbnetAdapterInit, + .Release = UsbnetAdapterRelease, + .moduleName = "HDF_USB_NET", +}; + +HDF_INIT(g_UsbnetAdapterEntry); diff --git a/framework/model/usb/include/hdf_usb_net_manager.h b/framework/model/usb/include/hdf_usb_net_manager.h new file mode 100755 index 000000000..870a8694c --- /dev/null +++ b/framework/model/usb/include/hdf_usb_net_manager.h @@ -0,0 +1,65 @@ +#ifndef HDF_USB_NET_MANAGE_H +#define HDF_USB_NET_MANAGE_H + +#include "hdf_base.h" +#include "hdf_device_desc.h" + + +#define MAC_ADDR_SIZE 6 +#define IFNAMSIZ 16 + +/* framing is CDC Ethernet, not writing ZLPs (hw issues), or optionally: */ +#define FLAG_FRAMING_NC 0x0001 /* guard against device dropouts */ +#define FLAG_FRAMING_GL 0x0002 /* genelink batches packets */ +#define FLAG_FRAMING_Z 0x0004 /* zaurus adds a trailer */ +#define FLAG_FRAMING_RN 0x0008 /* RNDIS batches, plus huge header */ + +#define FLAG_NO_SETINT 0x0010 /* device can't set_interface() */ +#define FLAG_ETHER 0x0020 /* maybe use "eth%d" names */ + +#define FLAG_FRAMING_AX 0x0040 /* AX88772/178 packets */ +#define FLAG_WLAN 0x0080 /* use "wlan%d" names */ +#define FLAG_AVOID_UNLINK_URBS 0x0100 /* don't unlink urbs at usbnet_stop() */ +#define FLAG_SEND_ZLP 0x0200 /* hw requires ZLPs are sent */ +#define FLAG_WWAN 0x0400 /* use "wwan%d" names */ + +#define FLAG_LINK_INTR 0x0800 /* updates link (carrier) status */ +#define FLAG_POINTTOPOINT 0x1000 /* possibly use "usb%d" names */ + +/* + * Indicates to usbnet, that USB driver accumulates multiple IP packets. + * Affects statistic (counters) and short packet handling. + */ +#define FLAG_MULTI_PACKET 0x2000 +#define FLAG_RX_ASSEMBLE 0x4000 /* rx packets may span >1 frames */ +#define FLAG_NOARP 0x8000 /* device can't do ARP */ + +enum UsbnetServiceCmd { + USB_NET_REGISTER_NET, + USB_NET_CLOSE_NET, + USB_NET_SEND_DATA_TO_USB, + USB_NET_RECIVE_DATA_FROM_USB, + USB_NET_OPEN_USB, + USB_NET_CLOSE_USB, + USB_NET_UPDATE_FLAGS, + USB_NET_UPDATE_MAXQLEN +}; + +struct UsbnetTransInfo { + uint8_t isBindDevice; + char name[IFNAMSIZ]; /**< Network device name {@link IFNAMSIZ} */ + uint8_t isGetmacAddr; + uint8_t macAddr[MAC_ADDR_SIZE]; /**< MAC address {@link MAC_ADDR_SIZE} */ + uint32_t flags; /**< Network port status */ + uint32_t mtu; /**< Maximum transmission unit */ + uint16_t hardHeaderLen; /**< Header length */ + uint8_t link; + uint8_t needReset; + uint32_t usbFlags; /**< usb device match flags */ + uint32_t rxUrbSize; /* size for rx urbs */ + uint32_t hardMtu; /* count any extra framing */ + uint32_t maxpacket; + int txQlen; +}; + +#endif \ No newline at end of file diff --git a/framework/model/usb/include/hdf_usb_pnp_manage.h b/framework/model/usb/include/hdf_usb_pnp_manage.h index 0f0c811d1..943707dda 100644 --- a/framework/model/usb/include/hdf_usb_pnp_manage.h +++ b/framework/model/usb/include/hdf_usb_pnp_manage.h @@ -54,6 +54,7 @@ enum { }; struct UsbPnpNotifyServiceInfo { + uint8_t curInterfaceNumber; uint32_t length; int32_t devNum; -- Gitee From 798d00f272f4dd781802045604ce3b0b099278b5 Mon Sep 17 00:00:00 2001 From: n028372 Date: Tue, 16 Jan 2024 17:08:55 +0800 Subject: [PATCH 2/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: n028372 --- .../model/usb/host/include/usb_net_adapter.h | 8 + .../model/usb/host/src/usb_net_adapter.c | 1360 +++++++++-------- .../model/usb/include/hdf_usb_net_manager.h | 46 +- 3 files changed, 719 insertions(+), 695 deletions(-) diff --git a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h index 588fd77c6..a8db860f3 100755 --- a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h +++ b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h @@ -1,3 +1,11 @@ +/* + * Copyright (c) 2023-2024 ArcherMind Technology (Nanjing) Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + #ifndef HDF_NET_USB_ADAPTER_H #define HDF_NET_USB_ADAPTER_H diff --git a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c index 1ea38d8b1..77ab64436 100755 --- a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c +++ b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c @@ -1,3 +1,11 @@ +/* + * Copyright (c) 2023-2024 ArcherMind Technology (Nanjing) Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + #include #include #include @@ -18,13 +26,13 @@ #include "hdf_device_desc.h" #include "usb_net_adapter.h" -#define HDF_LOG_TAG UsbnetAdapter -#define TX_TIMEOUT_JIFFIES (5*HZ) -#define RNDIS_MSG_PACKET 0x00000001 /* 1-N packets */ +#define HDF_LOG_TAG UsbnetAdapter +#define TX_TIMEOUT_JIFFIES (5*HZ) +#define RNDIS_MSG_PACKET 0x00000001 /* 1-N packets */ // between wakeups -#define UNLINK_TIMEOUT_MS 3 -#define TX_QLEN(dev) ((dev)->usbnetInfo.txQlen) +#define UNLINK_TIMEOUT_MS 3 +#define TX_QLEN(dev) ((dev)->usbnetInfo.txQlen) /* use ethtool to change the level for any given device */ static int msg_level = -1; @@ -33,25 +41,25 @@ MODULE_PARM_DESC (msg_level, "Override default message level"); static int printf_char_buffer(char *buff, int size, bool isPrint) { - if (isPrint) - { - int i = 0; - printk("===-harch-=== printf_char_buffer begin\n"); - for (i = 0; i < size; i++) - { - printk(KERN_CONT"%02x ", buff[i]); - if ((i+1) % 32 == 0) - { - printk(KERN_CONT"\n"); - } - } - printk("===-harch-=== printf_char_buffer end\n"); - } - return 0; + if (isPrint) + { + int i = 0; + printk("===-harch-=== printf_char_buffer begin\n"); + for (i = 0; i < size; i++) + { + printk(KERN_CONT"%02x ", buff[i]); + if ((i+1) % 32 == 0) + { + printk(KERN_CONT"\n"); + } + } + printk("===-harch-=== printf_char_buffer end\n"); + } + return 0; } static void analysis_skb(struct sk_buff *skb) { - + struct net_device *dev = skb->dev; struct ethhdr *ethh = eth_hdr(skb); struct iphdr *ip = ip_hdr(skb); @@ -64,13 +72,13 @@ static void analysis_skb(struct sk_buff *skb) { printk(" source ip:%pI4\n",src_ip); printk(" dest ip:%pI4\n",dst_ip); printk(" destination eth addr:%x:%x:%x:%x:%x:%x\n", - ethh->h_dest[0],ethh->h_dest[1],ethh->h_dest[2],ethh->h_dest[3],ethh->h_dest[4],ethh->h_dest[5]); + ethh->h_dest[0],ethh->h_dest[1],ethh->h_dest[2],ethh->h_dest[3],ethh->h_dest[4],ethh->h_dest[5]); printk(" source eth addr:%x:%x:%x:%x:%x:%x\n", - ethh->h_source[0],ethh->h_source[1],ethh->h_source[2],ethh->h_source[3],ethh->h_source[4],ethh->h_source[5]); + ethh->h_source[0],ethh->h_source[1],ethh->h_source[2],ethh->h_source[3],ethh->h_source[4],ethh->h_source[5]); } int32_t UsbnetAdapterSendBufToUsb(const struct HdfDeviceObject *device, uint32_t id, - const void *buf, uint32_t writeSize) + const void *buf, uint32_t writeSize) { HARCH_NET_INFO_PRINT("writeSize: %d", writeSize); int32_t ret = HDF_SUCCESS; @@ -105,27 +113,27 @@ out: static void rx_complete(struct work_struct *work){ - - unsigned long flags = 0; - struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, RxCompleteWorkqueue); - struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + + unsigned long flags = 0; + struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, RxCompleteWorkqueue); + struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); - HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); - HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); - - flags = u64_stats_update_begin_irqsave(&stats64->syncp); - stats64->rx_packets++; - stats64->rx_bytes += usbNet->RxLen; - u64_stats_update_end_irqrestore(&stats64->syncp, flags); + HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); + + flags = u64_stats_update_begin_irqsave(&stats64->syncp); + stats64->rx_packets++; + stats64->rx_bytes += usbNet->RxLen; + u64_stats_update_end_irqrestore(&stats64->syncp, flags); - HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); - HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); } @@ -135,33 +143,33 @@ static void rx_complete(struct work_struct *work){ */ void UsbnetAdapterSkbReturn (struct UsbnetAdapter *usbNet, struct sk_buff *skb) { - - if (test_bit(EVENT_RX_PAUSED, &usbNet->flags)) { - skb_queue_tail(&usbNet->rxq_pause, skb); - return; - } - - /* only update if unset to allow minidriver rx_fixup override */ - if (skb->protocol == 0) - skb->protocol = eth_type_trans (skb, usbNet->net); - - usbNet->RxLen = skb->len; - schedule_work_on(0,&usbNet->RxCompleteWorkqueue); - HARCH_NET_INFO_PRINT("< rx, len %zu, type 0x%x\n", skb->len + sizeof (struct ethhdr), skb->protocol); - (void)memset_s(skb->cb, sizeof (struct skb_data), 0, sizeof (struct skb_data)); - - if (skb_defer_rx_timestamp(skb)) - return; + + if (test_bit(EVENT_RX_PAUSED, &usbNet->flags)) { + skb_queue_tail(&usbNet->rxq_pause, skb); + return; + } + + /* only update if unset to allow minidriver rx_fixup override */ + if (skb->protocol == 0) + skb->protocol = eth_type_trans (skb, usbNet->net); + + usbNet->RxLen = skb->len; + schedule_work_on(0,&usbNet->RxCompleteWorkqueue); + HARCH_NET_INFO_PRINT("< rx, len %zu, type 0x%x\n", skb->len + sizeof (struct ethhdr), skb->protocol); + (void)memset_s(skb->cb, sizeof (struct skb_data), 0, sizeof (struct skb_data)); + + if (skb_defer_rx_timestamp(skb)) + return; HARCH_NET_INFO_PRINT("-------rx before netif_rx"); - printf_char_buffer(skb->data, skb->len, false); + printf_char_buffer(skb->data, skb->len, false); - int status = NET_RX_SUCCESS; - status = netif_rx (skb); - - HARCH_NET_INFO_PRINT("netif_rx status %d\n", status); - if (status != NET_RX_SUCCESS) - HARCH_NET_INFO_PRINT("netif_rx status %d\n", status); + int status = NET_RX_SUCCESS; + status = netif_rx (skb); + + HARCH_NET_INFO_PRINT("netif_rx status %d\n", status); + if (status != NET_RX_SUCCESS) + HARCH_NET_INFO_PRINT("netif_rx status %d\n", status); } @@ -170,183 +178,183 @@ void UsbnetAdapterSkbReturn (struct UsbnetAdapter *usbNet, struct sk_buff *skb) */ static int rndisRxFixup(struct UsbnetAdapter *usbNet, struct sk_buff *skb) { - /* This check is no longer done by usbnet */ - if (skb->len < usbNet->net->hard_header_len) - return 0; - - /* peripheral may have batched packets to us... */ - while (likely(skb->len)) { - struct rndis_data_hdr *hdr = (void *)skb->data; - struct sk_buff *skb2; - u32 msg_type, msg_len, data_offset, data_len; - - msg_type = le32_to_cpu(hdr->msg_type); - msg_len = le32_to_cpu(hdr->msg_len); - data_offset = le32_to_cpu(hdr->data_offset); - data_len = le32_to_cpu(hdr->data_len); - - /* don't choke if we see oob, per-packet data, etc */ - if (unlikely(msg_type != RNDIS_MSG_PACKET || skb->len < msg_len - || (data_offset + data_len + 8) > msg_len)) { - usbNet->net->stats.rx_frame_errors++; - netdev_dbg(usbNet->net, "bad rndis message %d/%d/%d/%d, len %d\n", - le32_to_cpu(hdr->msg_type), - msg_len, data_offset, data_len, skb->len); - return 0; - } - skb_pull(skb, 8 + data_offset); - - /* at most one packet left? */ - if (likely((data_len - skb->len) <= sizeof *hdr)) { - skb_trim(skb, data_len); - break; - } - - /* try to return all the packets in the batch */ - skb2 = skb_clone(skb, GFP_ATOMIC); - if (unlikely(!skb2)) - break; - skb_pull(skb, msg_len - sizeof *hdr); - skb_trim(skb2, data_len); - UsbnetAdapterSkbReturn(usbNet, skb2); - } - return 1; + /* This check is no longer done by usbnet */ + if (skb->len < usbNet->net->hard_header_len) + return 0; + + /* peripheral may have batched packets to us... */ + while (likely(skb->len)) { + struct rndis_data_hdr *hdr = (void *)skb->data; + struct sk_buff *skb2; + u32 msg_type, msg_len, data_offset, data_len; + + msg_type = le32_to_cpu(hdr->msg_type); + msg_len = le32_to_cpu(hdr->msg_len); + data_offset = le32_to_cpu(hdr->data_offset); + data_len = le32_to_cpu(hdr->data_len); + + /* don't choke if we see oob, per-packet data, etc */ + if (unlikely(msg_type != RNDIS_MSG_PACKET || skb->len < msg_len + || (data_offset + data_len + 8) > msg_len)) { + usbNet->net->stats.rx_frame_errors++; + netdev_dbg(usbNet->net, "bad rndis message %d/%d/%d/%d, len %d\n", + le32_to_cpu(hdr->msg_type), + msg_len, data_offset, data_len, skb->len); + return 0; + } + skb_pull(skb, 8 + data_offset); + + /* at most one packet left? */ + if (likely((data_len - skb->len) <= sizeof *hdr)) { + skb_trim(skb, data_len); + break; + } + + /* try to return all the packets in the batch */ + skb2 = skb_clone(skb, GFP_ATOMIC); + if (unlikely(!skb2)) + break; + skb_pull(skb, msg_len - sizeof *hdr); + skb_trim(skb2, data_len); + UsbnetAdapterSkbReturn(usbNet, skb2); + } + return 1; } static inline void UsbnetAdapterRxProcess (struct UsbnetAdapter *usbNet, struct sk_buff *skb) { HARCH_NET_INFO_PRINT("-------rx before fix"); - printf_char_buffer(skb->data, skb->len, false); - - if (!rndisRxFixup(usbNet, skb)) { - /* With RX_ASSEMBLE, rx_fixup() must update counters */ - if (!(usbNet->usbnetInfo.usbFlags & FLAG_RX_ASSEMBLE)) - usbNet->net->stats.rx_errors++; - goto done; - } - // else network stack removes extra byte if we forced a short packet - HARCH_NET_INFO_PRINT("--------rx after fix"); - printf_char_buffer(skb->data, skb->len, false); - - /* all data was already cloned from skb inside the driver */ - if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) + printf_char_buffer(skb->data, skb->len, false); + + if (!rndisRxFixup(usbNet, skb)) { + /* With RX_ASSEMBLE, rx_fixup() must update counters */ + if (!(usbNet->usbnetInfo.usbFlags & FLAG_RX_ASSEMBLE)) + usbNet->net->stats.rx_errors++; + goto done; + } + // else network stack removes extra byte if we forced a short packet + HARCH_NET_INFO_PRINT("--------rx after fix"); + printf_char_buffer(skb->data, skb->len, false); + + /* all data was already cloned from skb inside the driver */ + if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) { HARCH_NET_INFO_PRINT("usbNet->driver_info->flags = %d",usbNet->usbnetInfo.usbFlags); - goto done; + goto done; } - if (skb->len < ETH_HLEN) { - usbNet->net->stats.rx_errors++; - usbNet->net->stats.rx_length_errors++; - HARCH_NET_INFO_PRINT("rx length %d\n", skb->len); - } else { + if (skb->len < ETH_HLEN) { + usbNet->net->stats.rx_errors++; + usbNet->net->stats.rx_length_errors++; + HARCH_NET_INFO_PRINT("rx length %d\n", skb->len); + } else { HARCH_NET_INFO_PRINT("UsbnetAdapterSkbReturn"); - UsbnetAdapterSkbReturn(usbNet, skb); - return; - } + UsbnetAdapterSkbReturn(usbNet, skb); + return; + } done: - skb_queue_tail(&usbNet->done, skb); + skb_queue_tail(&usbNet->done, skb); } static void UsbnetAdapterBh (struct timer_list *t) { HARCH_NET_INFO_PRINT("begin"); - struct UsbnetAdapter *usbNet = from_timer(usbNet, t, delay); + struct UsbnetAdapter *usbNet = from_timer(usbNet, t, delay); - struct sk_buff *skb = NULL; - struct skb_data *entry = NULL; + struct sk_buff *skb = NULL; + struct skb_data *entry = NULL; - while ((skb = skb_dequeue (&usbNet->done))) { - entry = (struct skb_data *) skb->cb; + while ((skb = skb_dequeue (&usbNet->done))) { + entry = (struct skb_data *) skb->cb; HARCH_NET_INFO_PRINT("entry->state = %d",entry->state); - switch (entry->state) { - case rx_done: - HARCH_NET_INFO_PRINT("rx_done"); - entry->state = rx_cleanup; - UsbnetAdapterRxProcess (usbNet, skb); - continue; - case tx_done: - HARCH_NET_INFO_PRINT("tx_done"); - /* fall-through */ - fallthrough; - case rx_cleanup: + switch (entry->state) { + case rx_done: + HARCH_NET_INFO_PRINT("rx_done"); + entry->state = rx_cleanup; + UsbnetAdapterRxProcess (usbNet, skb); + continue; + case tx_done: + HARCH_NET_INFO_PRINT("tx_done"); + /* fall-through */ + fallthrough; + case rx_cleanup: HARCH_NET_INFO_PRINT("rx_cleanup"); - dev_kfree_skb (skb); - continue; - default: - HARCH_NET_INFO_PRINT("bogus skb state %d\n", entry->state); - /* fall-through */ - } - } + dev_kfree_skb (skb); + continue; + default: + HARCH_NET_INFO_PRINT("bogus skb state %d\n", entry->state); + /* fall-through */ + } + } HARCH_NET_INFO_PRINT(); - /* restart RX again after disabling due to high error rate */ - clear_bit(EVENT_RX_KILL, &usbNet->flags); + /* restart RX again after disabling due to high error rate */ + clear_bit(EVENT_RX_KILL, &usbNet->flags); /* waiting for all pending urbs to complete? - * only then can we forgo submitting anew - */ - if (waitqueue_active(&usbNet->wait)) { + * only then can we forgo submitting anew + */ + if (waitqueue_active(&usbNet->wait)) { HARCH_NET_INFO_PRINT("waitqueue_active"); - if (usbNet->rxq.qlen + usbNet->txq.qlen + usbNet->done.qlen == 0) + if (usbNet->rxq.qlen + usbNet->txq.qlen + usbNet->done.qlen == 0) { HARCH_NET_INFO_PRINT(); - wake_up_all(&usbNet->wait); + wake_up_all(&usbNet->wait); } } - if (usbNet->txq.qlen < TX_QLEN (usbNet)) - { - netif_wake_queue (usbNet->net); - HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",usbNet->txq.qlen,TX_QLEN (usbNet)); - } + if (usbNet->txq.qlen < TX_QLEN (usbNet)) + { + netif_wake_queue (usbNet->net); + HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",usbNet->txq.qlen,TX_QLEN (usbNet)); + } HARCH_NET_INFO_PRINT("end"); } static void UsbnetAdapterBhTasklet(unsigned long data) { HARCH_NET_INFO_PRINT("begin"); - struct timer_list *t = (struct timer_list *)data; + struct timer_list *t = (struct timer_list *)data; - UsbnetAdapterBh(t); + UsbnetAdapterBh(t); HARCH_NET_INFO_PRINT("end"); } /* The caller must hold list->lock */ static void UsbnetAdapterQueueSkb(struct sk_buff_head *list, - struct sk_buff *newsk, enum skb_state state) + struct sk_buff *newsk, enum skb_state state) { - struct skb_data *entry = (struct skb_data *) newsk->cb; + struct skb_data *entry = (struct skb_data *) newsk->cb; - __skb_queue_tail(list, newsk); - entry->state = state; + __skb_queue_tail(list, newsk); + entry->state = state; } static enum skb_state UsbnetAdapterDeferBh(struct UsbnetAdapter *usbNet, struct sk_buff *skb, - struct sk_buff_head *list, enum skb_state state) + struct sk_buff_head *list, enum skb_state state) { unsigned long flags = 0; - enum skb_state old_state = illegal; + enum skb_state old_state = illegal; struct skb_data *entry = (struct skb_data *) skb->cb; spin_lock_irqsave(&list->lock, flags); - old_state = entry->state; - entry->state = state; - __skb_unlink(skb, list); + old_state = entry->state; + entry->state = state; + __skb_unlink(skb, list); - /* UsbnetAdapterDeferBh() is never called with list == &usbNet->done. - * spin_lock_nested() tells lockdep that it is OK to take - * usbNet->done.lock here with list->lock held. - */ - spin_lock_nested(&usbNet->done.lock, SINGLE_DEPTH_NESTING); + /* UsbnetAdapterDeferBh() is never called with list == &usbNet->done. + * spin_lock_nested() tells lockdep that it is OK to take + * usbNet->done.lock here with list->lock held. + */ + spin_lock_nested(&usbNet->done.lock, SINGLE_DEPTH_NESTING); - __skb_queue_tail(&usbNet->done, skb); - if (usbNet->done.qlen == 1) - tasklet_schedule(&usbNet->bh); + __skb_queue_tail(&usbNet->done, skb); + if (usbNet->done.qlen == 1) + tasklet_schedule(&usbNet->bh); - spin_unlock(&usbNet->done.lock); - spin_unlock_irqrestore(&list->lock, flags); + spin_unlock(&usbNet->done.lock); + spin_unlock_irqrestore(&list->lock, flags); return old_state; } @@ -354,289 +362,289 @@ static enum skb_state UsbnetAdapterDeferBh(struct UsbnetAdapter *usbNet, struct int32_t UsbnetAdapterOpen(struct net_device *net) { HARCH_NET_INFO_PRINT("begin"); - if (NULL == net) - { - HDF_LOGE("net device object is invalid"); - return HDF_FAILURE; - } + if (NULL == net) + { + HDF_LOGE("net device object is invalid"); + return HDF_FAILURE; + } struct UsbnetAdapter *usbNet = netdev_priv(net); - if (NULL == usbNet) - { - HDF_LOGE("usb net adapter object is invalid"); - return HDF_FAILURE; - } + if (NULL == usbNet) + { + HDF_LOGE("usb net adapter object is invalid"); + return HDF_FAILURE; + } - set_bit(EVENT_DEV_OPEN, &usbNet->flags); + set_bit(EVENT_DEV_OPEN, &usbNet->flags); - netif_start_queue (net); + netif_start_queue (net); - /* set device param, if find usb net host need, then it should send to it */ - /* reset rx error state */ - usbNet->pkt_cnt = 0; - usbNet->pkt_err = 0; + /* set device param, if find usb net host need, then it should send to it */ + /* reset rx error state */ + usbNet->pkt_cnt = 0; + usbNet->pkt_err = 0; - clear_bit(EVENT_RX_KILL, &usbNet->flags); + clear_bit(EVENT_RX_KILL, &usbNet->flags); - /* send info to usb start usb function */ - /* need transform usb_net_host change about usbNet->driverInfo->flags and set it on usb_net_host */ - OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_OPEN_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + /* send info to usb start usb function */ + /* need transform usb_net_host change about usbNet->driverInfo->flags and set it on usb_net_host */ + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_OPEN_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); - OsalMutexUnlock(&usbNet->sendSkbClock); - return HDF_FAILURE; + OsalMutexUnlock(&usbNet->sendSkbClock); + return HDF_FAILURE; } - OsalMutexUnlock(&usbNet->sendSkbClock); - - tasklet_schedule (&usbNet->bh); + OsalMutexUnlock(&usbNet->sendSkbClock); + + tasklet_schedule (&usbNet->bh); return HDF_SUCCESS; } static void waitSkbQueueEmpty(struct sk_buff_head *q) { - unsigned long flags = 0; - HARCH_NET_INFO_PRINT(); - spin_lock_irqsave(&q->lock, flags); - while (!skb_queue_empty(q)) { - spin_unlock_irqrestore(&q->lock, flags); - schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS)); - set_current_state(TASK_UNINTERRUPTIBLE); - spin_lock_irqsave(&q->lock, flags); - } - spin_unlock_irqrestore(&q->lock, flags); + unsigned long flags = 0; + HARCH_NET_INFO_PRINT(); + spin_lock_irqsave(&q->lock, flags); + while (!skb_queue_empty(q)) { + spin_unlock_irqrestore(&q->lock, flags); + schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS)); + set_current_state(TASK_UNINTERRUPTIBLE); + spin_lock_irqsave(&q->lock, flags); + } + spin_unlock_irqrestore(&q->lock, flags); } // precondition: never called in_interrupt static void UsbnetAdapterTerminateUrbs(struct UsbnetAdapter *usbNet) { - HARCH_NET_INFO_PRINT(); - - DECLARE_WAITQUEUE(wait, current); - /* ensure there are no more active urbs */ - add_wait_queue(&usbNet->wait, &wait); - set_current_state(TASK_UNINTERRUPTIBLE); - /* maybe wait for deletions to finish. */ - waitSkbQueueEmpty(&usbNet->rxq); - waitSkbQueueEmpty(&usbNet->txq); - - waitSkbQueueEmpty(&usbNet->done); - set_current_state(TASK_RUNNING); - remove_wait_queue(&usbNet->wait, &wait); + HARCH_NET_INFO_PRINT(); + + DECLARE_WAITQUEUE(wait, current); + /* ensure there are no more active urbs */ + add_wait_queue(&usbNet->wait, &wait); + set_current_state(TASK_UNINTERRUPTIBLE); + /* maybe wait for deletions to finish. */ + waitSkbQueueEmpty(&usbNet->rxq); + waitSkbQueueEmpty(&usbNet->txq); + + waitSkbQueueEmpty(&usbNet->done); + set_current_state(TASK_RUNNING); + remove_wait_queue(&usbNet->wait, &wait); } int32_t UsbnetAdapterStop(struct net_device *net) { HARCH_NET_INFO_PRINT("begin"); - if (NULL == net) - { - HDF_LOGE("net device object is invalid"); - return HDF_FAILURE; - } - - struct UsbnetAdapter *usbNet = netdev_priv(net); - if (NULL == usbNet) - { - HDF_LOGE("usb net adapter object is invalid"); - return HDF_FAILURE; - } - - struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); - - HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); - - HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); - - /* 1. clear_bit(EVENT_DEV_OPEN, &dev->flags); */ - clear_bit(EVENT_DEV_OPEN, &usbNet->flags); - /* 2. netif_stop_queue (net); */ - netif_stop_queue (net); - HARCH_NET_INFO_PRINT("stop stats: rx/tx %lu/%lu, errs %lu/%lu\n", - net->stats.rx_packets, net->stats.tx_packets, - net->stats.rx_errors, net->stats.tx_errors); - - /* 3. pm = usb_autopm_get_interface(dev->intf); do nothing */ - /* 4. if (info->stop) { no stop interface impl in rndis driver info */ - /* 5. if (!(info->flags & FLAG_AVOID_UNLINK_URBS)) do nothing*/ - if (!(usbNet->usbnetInfo.usbFlags & FLAG_AVOID_UNLINK_URBS)){ - UsbnetAdapterTerminateUrbs(usbNet); - } - - /* 6. usbnet_status_stop(dev); none */ - /* 7. usbnet_purge_paused_rxq(dev); none */ - skb_queue_purge(&usbNet->rxq_pause); - /* 8. mpn = !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags); if (info->manage_power && mpn) - no manage_power interface impl in rndis driver info*/ - /* 9. dev->flags = 0; */ - usbNet->flags = 0; - OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_CLOSE_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + if (NULL == net) + { + HDF_LOGE("net device object is invalid"); + return HDF_FAILURE; + } + + struct UsbnetAdapter *usbNet = netdev_priv(net); + if (NULL == usbNet) + { + HDF_LOGE("usb net adapter object is invalid"); + return HDF_FAILURE; + } + + struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + + HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); + + HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); + + /* 1. clear_bit(EVENT_DEV_OPEN, &dev->flags); */ + clear_bit(EVENT_DEV_OPEN, &usbNet->flags); + /* 2. netif_stop_queue (net); */ + netif_stop_queue (net); + HARCH_NET_INFO_PRINT("stop stats: rx/tx %lu/%lu, errs %lu/%lu\n", + net->stats.rx_packets, net->stats.tx_packets, + net->stats.rx_errors, net->stats.tx_errors); + + /* 3. pm = usb_autopm_get_interface(dev->intf); do nothing */ + /* 4. if (info->stop) { no stop interface impl in rndis driver info */ + /* 5. if (!(info->flags & FLAG_AVOID_UNLINK_URBS)) do nothing*/ + if (!(usbNet->usbnetInfo.usbFlags & FLAG_AVOID_UNLINK_URBS)){ + UsbnetAdapterTerminateUrbs(usbNet); + } + + /* 6. usbnet_status_stop(dev); none */ + /* 7. usbnet_purge_paused_rxq(dev); none */ + skb_queue_purge(&usbNet->rxq_pause); + /* 8. mpn = !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags); if (info->manage_power && mpn) + no manage_power interface impl in rndis driver info*/ + /* 9. dev->flags = 0; */ + usbNet->flags = 0; + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_CLOSE_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); - OsalMutexUnlock(&usbNet->sendSkbClock); - return HDF_FAILURE; + OsalMutexUnlock(&usbNet->sendSkbClock); + return HDF_FAILURE; } - OsalMutexUnlock(&usbNet->sendSkbClock); - /* 10. del_timer_sync (&dev->delay); */ - del_timer_sync (&usbNet->delay); - /* 11. tasklet_kill (&dev->bh); */ - tasklet_kill (&usbNet->bh); - /* 12. cancel_work_sync(&dev->kevent); no kevent, do nothing */ - //cancel_work_sync(&usbNet->kevent); - cancel_work_sync(&usbNet->TxCompleteWorkqueue); - cancel_work_sync(&usbNet->RxCompleteWorkqueue); + OsalMutexUnlock(&usbNet->sendSkbClock); + /* 10. del_timer_sync (&dev->delay); */ + del_timer_sync (&usbNet->delay); + /* 11. tasklet_kill (&dev->bh); */ + tasklet_kill (&usbNet->bh); + /* 12. cancel_work_sync(&dev->kevent); no kevent, do nothing */ + //cancel_work_sync(&usbNet->kevent); + cancel_work_sync(&usbNet->TxCompleteWorkqueue); + cancel_work_sync(&usbNet->RxCompleteWorkqueue); return HDF_SUCCESS; } struct sk_buff *RndisTxFixup(struct sk_buff *skb, gfp_t flags) { - struct rndis_data_hdr *hdr = NULL; - struct sk_buff *skb2 = NULL; - unsigned len = skb->len; - - if (likely(!skb_cloned(skb))) { - int room = skb_headroom(skb); - - /* enough head room as-is? */ - if (unlikely((sizeof *hdr) <= room)) - goto fill; - - /* enough room, but needs to be readjusted? */ - room += skb_tailroom(skb); - if (likely((sizeof *hdr) <= room)) { - skb->data = memmove(skb->head + sizeof *hdr, - skb->data, len); - skb_set_tail_pointer(skb, len); - goto fill; - } - } - - /* create a new skb, with the correct size (and tailpad) */ - skb2 = skb_copy_expand(skb, sizeof *hdr, 1, flags); - dev_kfree_skb_any(skb); - if (unlikely(!skb2)) - return skb2; - skb = skb2; - - /* fill out the RNDIS header. we won't bother trying to batch - * packets; Linux minimizes wasted bandwidth through tx queues. - */ + struct rndis_data_hdr *hdr = NULL; + struct sk_buff *skb2 = NULL; + unsigned len = skb->len; + + if (likely(!skb_cloned(skb))) { + int room = skb_headroom(skb); + + /* enough head room as-is? */ + if (unlikely((sizeof *hdr) <= room)) + goto fill; + + /* enough room, but needs to be readjusted? */ + room += skb_tailroom(skb); + if (likely((sizeof *hdr) <= room)) { + skb->data = memmove(skb->head + sizeof *hdr, + skb->data, len); + skb_set_tail_pointer(skb, len); + goto fill; + } + } + + /* create a new skb, with the correct size (and tailpad) */ + skb2 = skb_copy_expand(skb, sizeof *hdr, 1, flags); + dev_kfree_skb_any(skb); + if (unlikely(!skb2)) + return skb2; + skb = skb2; + + /* fill out the RNDIS header. we won't bother trying to batch + * packets; Linux minimizes wasted bandwidth through tx queues. + */ fill: - HARCH_NET_INFO_PRINT("%s:%d fill skb by rndis host", __func__, __LINE__); - hdr = __skb_push(skb, sizeof *hdr); - memset(hdr, 0, sizeof *hdr); - hdr->msg_type = cpu_to_le32(RNDIS_MSG_PACKET); - hdr->msg_len = cpu_to_le32(skb->len); - hdr->data_offset = cpu_to_le32(sizeof(*hdr) - 8); - hdr->data_len = cpu_to_le32(len); - - /* FIXME make the last packet always be short ... */ - return skb; + HARCH_NET_INFO_PRINT("%s:%d fill skb by rndis host", __func__, __LINE__); + hdr = __skb_push(skb, sizeof *hdr); + memset(hdr, 0, sizeof *hdr); + hdr->msg_type = cpu_to_le32(RNDIS_MSG_PACKET); + hdr->msg_len = cpu_to_le32(skb->len); + hdr->data_offset = cpu_to_le32(sizeof(*hdr) - 8); + hdr->data_len = cpu_to_le32(len); + + /* FIXME make the last packet always be short ... */ + return skb; } static void tx_complete(struct work_struct *work) { - unsigned long flags = 0; - struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, TxCompleteWorkqueue); - struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + unsigned long flags = 0; + struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, TxCompleteWorkqueue); + struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); - printk("tx_complete dump_stack start usbNet->usbnetInfo.mtu = %d\n",usbNet->usbnetInfo.mtu); - dump_stack(); - printk("tx_complete dump_stack end\n"); + printk("tx_complete dump_stack start usbNet->usbnetInfo.mtu = %d\n",usbNet->usbnetInfo.mtu); + dump_stack(); + printk("tx_complete dump_stack end\n"); - HARCH_NET_INFO_PRINT("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + HARCH_NET_INFO_PRINT("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); - HARCH_NET_INFO_PRINT("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + HARCH_NET_INFO_PRINT("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); - flags = u64_stats_update_begin_irqsave(&stats64->syncp); - stats64->tx_packets++; - stats64->tx_bytes += usbNet->TxLen; - u64_stats_update_end_irqrestore(&stats64->syncp, flags); + flags = u64_stats_update_begin_irqsave(&stats64->syncp); + stats64->tx_packets++; + stats64->tx_bytes += usbNet->TxLen; + u64_stats_update_end_irqrestore(&stats64->syncp, flags); - HARCH_NET_INFO_PRINT("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + HARCH_NET_INFO_PRINT("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); - HARCH_NET_INFO_PRINT("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + HARCH_NET_INFO_PRINT("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); } netdev_tx_t UsbnetAdapterStartXmit(struct sk_buff *skb, struct net_device *net) { analysis_skb(skb); HARCH_NET_INFO_PRINT("netif_running = %d, netif_device_present = %d" , netif_running (net),netif_device_present (net)); - HARCH_NET_INFO_PRINT("netif_carrier_ok = %d" , netif_carrier_ok (net)); + HARCH_NET_INFO_PRINT("netif_carrier_ok = %d" , netif_carrier_ok (net)); /* print org skb data info */ HARCH_NET_INFO_PRINT("UsbnetAdapterStartXmit skb->data = %x, len = %d",skb->data, skb->len); printf_char_buffer(skb->data, skb->len, false); struct UsbnetAdapter *usbNet = netdev_priv(net); - + //1.time tamp if (skb) skb_tx_timestamp(skb); //2.fix up - struct sk_buff* skb_fixup = NULL; - - /* rndis fixup sk_buf */ - skb_fixup = RndisTxFixup(skb, GFP_ATOMIC); - if (NULL == skb_fixup) - { - if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET){ - goto not_drop; - } - HDF_LOGE("fail to tx fixup by rndis host"); - goto drop; - } + struct sk_buff* skb_fixup = NULL; + + /* rndis fixup sk_buf */ + skb_fixup = RndisTxFixup(skb, GFP_ATOMIC); + if (NULL == skb_fixup) + { + if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET){ + goto not_drop; + } + HDF_LOGE("fail to tx fixup by rndis host"); + goto drop; + } HARCH_NET_INFO_PRINT("UsbnetAdapterStartXmit skb_fixup->data = %x, len = %d",skb_fixup->data, skb_fixup->len); - /* print org skb data info */ - printf_char_buffer(skb_fixup->data, skb_fixup->len, false); + /* print org skb data info */ + printf_char_buffer(skb_fixup->data, skb_fixup->len, false); //3.send to usb - - // send msg to usb - unsigned long flags = 0; - spin_lock_irqsave(&usbNet->txq.lock, flags); - if (netif_queue_stopped(usbNet->net)) { + + // send msg to usb + unsigned long flags = 0; + spin_lock_irqsave(&usbNet->txq.lock, flags); + if (netif_queue_stopped(usbNet->net)) { goto drop; } int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_SEND_DATA_TO_USB, - (unsigned char *)(skb_fixup->data), skb_fixup->len); + (unsigned char *)(skb_fixup->data), skb_fixup->len); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetHost SendEvent!"); drop: - net->stats.tx_dropped++; + net->stats.tx_dropped++; not_drop: - spin_unlock_irqrestore(&usbNet->txq.lock, flags); + spin_unlock_irqrestore(&usbNet->txq.lock, flags); if (skb_fixup) { dev_kfree_skb_any (skb_fixup); } } else { - netif_trans_update(usbNet->net); - UsbnetAdapterQueueSkb(&usbNet->txq, skb_fixup, tx_start); + netif_trans_update(usbNet->net); + UsbnetAdapterQueueSkb(&usbNet->txq, skb_fixup, tx_start); - if (usbNet->txq.qlen >= TX_QLEN (usbNet)) - { - HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",usbNet->txq.qlen,TX_QLEN (usbNet)); - netif_stop_queue (usbNet->net); - } + if (usbNet->txq.qlen >= TX_QLEN (usbNet)) + { + HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",usbNet->txq.qlen,TX_QLEN (usbNet)); + netif_stop_queue (usbNet->net); + } - spin_unlock_irqrestore(&usbNet->txq.lock, flags); + spin_unlock_irqrestore(&usbNet->txq.lock, flags); - usbNet->TxLen = skb_fixup->len; - schedule_work_on(0,&usbNet->TxCompleteWorkqueue); - - enum skb_state state = UsbnetAdapterDeferBh(usbNet, skb_fixup, &usbNet->txq, tx_done); - HARCH_NET_INFO_PRINT("state= %d", state); + usbNet->TxLen = skb_fixup->len; + schedule_work_on(0,&usbNet->TxCompleteWorkqueue); + + enum skb_state state = UsbnetAdapterDeferBh(usbNet, skb_fixup, &usbNet->txq, tx_done); + HARCH_NET_INFO_PRINT("state= %d", state); - HARCH_NET_INFO_PRINT("========print tosend skb data info========"); + HARCH_NET_INFO_PRINT("========print tosend skb data info========"); } return NETDEV_TX_OK; } @@ -645,22 +653,22 @@ static void UsbnetAdapterTXTimeout(struct net_device *net, unsigned int txqueue) { //send to device HARCH_NET_INFO_PRINT("begin"); - if ( NULL == net) { - HDF_LOGE("%s net device object is invalid", __func__); - return; - } - struct UsbnetAdapter *usbNet = netdev_priv(net); - if ( NULL == usbNet) { - HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); - return; - } - /* 1. unlink_urbs (dev, &dev->txq); maybe later be used */ - - /* 2. tasklet_schedule (&dev->bh) */ - tasklet_schedule (&usbNet->bh); - - /* 3. if (dev->driver_info->recover) none, rndis host no recover impl */ - + if ( NULL == net) { + HDF_LOGE("%s net device object is invalid", __func__); + return; + } + struct UsbnetAdapter *usbNet = netdev_priv(net); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + /* 1. unlink_urbs (dev, &dev->txq); maybe later be used */ + + /* 2. tasklet_schedule (&dev->bh) */ + tasklet_schedule (&usbNet->bh); + + /* 3. if (dev->driver_info->recover) none, rndis host no recover impl */ + return; } @@ -671,114 +679,114 @@ static void UsbnetAdapterTXTimeout(struct net_device *net, unsigned int txqueue) */ void UsbnetAdapter_defer_kevent (struct UsbnetAdapter *usbNet, int work) { - HARCH_NET_INFO_PRINT("begin"); - if ( NULL == usbNet) { - HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); - return; - } - set_bit (work, &usbNet->flags); - /* need update flags to usb_net_host */ - OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + HARCH_NET_INFO_PRINT("begin"); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + set_bit (work, &usbNet->flags); + /* need update flags to usb_net_host */ + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); - OsalMutexUnlock(&usbNet->sendSkbClock); - return; + OsalMutexUnlock(&usbNet->sendSkbClock); + return; } - OsalMutexUnlock(&usbNet->sendSkbClock); - - if (!schedule_work (&usbNet->kevent)) - HARCH_NET_INFO_PRINT("kevent %d may have been dropped\n", work); - else - HARCH_NET_INFO_PRINT("kevent %d scheduled\n", work); + OsalMutexUnlock(&usbNet->sendSkbClock); + + if (!schedule_work (&usbNet->kevent)) + HARCH_NET_INFO_PRINT("kevent %d may have been dropped\n", work); + else + HARCH_NET_INFO_PRINT("kevent %d scheduled\n", work); } void UsbnetAdapterSetRxMode(struct net_device *net) { //send to device HARCH_NET_INFO_PRINT("begin"); - return; - - if ( NULL == net) { - HDF_LOGE("%s net device object is invalid", __func__); - return; - } - struct UsbnetAdapter *usbNet = netdev_priv(net); - if ( NULL == usbNet) { - HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); - return; - } + return; + + if ( NULL == net) { + HDF_LOGE("%s net device object is invalid", __func__); + return; + } + struct UsbnetAdapter *usbNet = netdev_priv(net); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } /* usbnet_defer_kevent(dev, EVENT_SET_RX_MODE); */ - UsbnetAdapter_defer_kevent(usbNet, EVENT_SET_RX_MODE); + UsbnetAdapter_defer_kevent(usbNet, EVENT_SET_RX_MODE); return; } void UsbnetAdapter_pause_rx(struct UsbnetAdapter *usbNet) { - HARCH_NET_INFO_PRINT("begin"); - if ( NULL == usbNet) { - HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); - return; - } - set_bit(EVENT_RX_PAUSED, &usbNet->flags); - /* need update flags to usb_net_host */ - OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + HARCH_NET_INFO_PRINT("begin"); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + set_bit(EVENT_RX_PAUSED, &usbNet->flags); + /* need update flags to usb_net_host */ + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); - OsalMutexUnlock(&usbNet->sendSkbClock); - return; + OsalMutexUnlock(&usbNet->sendSkbClock); + return; } - OsalMutexUnlock(&usbNet->sendSkbClock); + OsalMutexUnlock(&usbNet->sendSkbClock); - HARCH_NET_INFO_PRINT("paused rx queue enabled\n"); + HARCH_NET_INFO_PRINT("paused rx queue enabled\n"); } void UsbnetAdapter_unlink_rx_urbs(struct UsbnetAdapter *usbNet) { - HARCH_NET_INFO_PRINT("begin"); - if ( NULL == usbNet) { - HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); - return; - } - - if (netif_running(usbNet->net)) { - /* (void) unlink_urbs (usbNet, &usbNet->rxq); */ - tasklet_schedule(&usbNet->bh); - } + HARCH_NET_INFO_PRINT("begin"); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + + if (netif_running(usbNet->net)) { + /* (void) unlink_urbs (usbNet, &usbNet->rxq); */ + tasklet_schedule(&usbNet->bh); + } } void UsbnetAdapter_resume_rx(struct UsbnetAdapter *usbNet) { - HARCH_NET_INFO_PRINT("begin"); - int num = 0; - struct sk_buff *skb = NULL; - if ( NULL == usbNet) { - HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); - return; - } - - clear_bit(EVENT_RX_PAUSED, &usbNet->flags); - /* need update flags to usb_net_host */ - OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + HARCH_NET_INFO_PRINT("begin"); + int num = 0; + struct sk_buff *skb = NULL; + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return; + } + + clear_bit(EVENT_RX_PAUSED, &usbNet->flags); + /* need update flags to usb_net_host */ + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); - OsalMutexUnlock(&usbNet->sendSkbClock); - return; + OsalMutexUnlock(&usbNet->sendSkbClock); + return; } - OsalMutexUnlock(&usbNet->sendSkbClock); + OsalMutexUnlock(&usbNet->sendSkbClock); - while ((skb = skb_dequeue(&usbNet->rxq_pause)) != NULL) { - UsbnetAdapterSkbReturn(usbNet, skb); - num++; - } + while ((skb = skb_dequeue(&usbNet->rxq_pause)) != NULL) { + UsbnetAdapterSkbReturn(usbNet, skb); + num++; + } - tasklet_schedule(&usbNet->bh); - HARCH_NET_INFO_PRINT("paused rx queue disabled, %d skbs requeued\n", num); + tasklet_schedule(&usbNet->bh); + HARCH_NET_INFO_PRINT("paused rx queue disabled, %d skbs requeued\n", num); } @@ -786,65 +794,65 @@ int32_t UsbnetAdapterChangeMtu(struct net_device *net, int newMtu) { //send to device HARCH_NET_INFO_PRINT("begin"); - if ( NULL == net) { - HDF_LOGE("%s net device object is invalid", __func__); - return HDF_FAILURE; - } - - struct UsbnetAdapter *usbNet = netdev_priv(net); - if ( NULL == usbNet) { - HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); - return HDF_FAILURE; - } - - /* 1. int ll_mtu = new_mtu + net->hard_header_len; - int old_hard_mtu = dev->hard_mtu; - int old_rx_urb_size = dev->rx_urb_size; - */ - HARCH_NET_INFO_PRINT("newMtu:%d", newMtu); - int ll_mtu = newMtu + net->hard_header_len; - int old_hard_mtu = usbNet->usbnetInfo.hardMtu; - int old_rx_urb_size = usbNet->usbnetInfo.rxUrbSize; - - /* 2. no second zero-length packet read wanted after mtu-sized packets */ - if ((ll_mtu % usbNet->usbnetInfo.maxpacket) == 0) { - HARCH_NET_INFO_PRINT(""); - return -EDOM; - } - - /* 3. set usbNet->hard_mtu */ - net->mtu = newMtu; - usbNet->usbnetInfo.hardMtu = net->mtu + net->hard_header_len; - - /* 4. pause and resume usbnet */ - if (usbNet->usbnetInfo.rxUrbSize == old_hard_mtu) { - usbNet->usbnetInfo.rxUrbSize = usbNet->usbnetInfo.hardMtu; - if (usbNet->usbnetInfo.rxUrbSize > old_rx_urb_size) { - UsbnetAdapter_pause_rx(usbNet); - UsbnetAdapter_unlink_rx_urbs(usbNet); - UsbnetAdapter_resume_rx(usbNet); - } - } - - /* need transmit hard_mtu to usb net host, UsbnetHostUpdateMaxQlen need this param */ - HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x mtu = %d, hardHeaderLen = %d, link = %d needReset = %d, hardMtu = %d, rxUrbSize = %d, maxpacket =%d", + if ( NULL == net) { + HDF_LOGE("%s net device object is invalid", __func__); + return HDF_FAILURE; + } + + struct UsbnetAdapter *usbNet = netdev_priv(net); + if ( NULL == usbNet) { + HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); + return HDF_FAILURE; + } + + /* 1. int ll_mtu = new_mtu + net->hard_header_len; + int old_hard_mtu = dev->hard_mtu; + int old_rx_urb_size = dev->rx_urb_size; + */ + HARCH_NET_INFO_PRINT("newMtu:%d", newMtu); + int ll_mtu = newMtu + net->hard_header_len; + int old_hard_mtu = usbNet->usbnetInfo.hardMtu; + int old_rx_urb_size = usbNet->usbnetInfo.rxUrbSize; + + /* 2. no second zero-length packet read wanted after mtu-sized packets */ + if ((ll_mtu % usbNet->usbnetInfo.maxpacket) == 0) { + HARCH_NET_INFO_PRINT(""); + return -EDOM; + } + + /* 3. set usbNet->hard_mtu */ + net->mtu = newMtu; + usbNet->usbnetInfo.hardMtu = net->mtu + net->hard_header_len; + + /* 4. pause and resume usbnet */ + if (usbNet->usbnetInfo.rxUrbSize == old_hard_mtu) { + usbNet->usbnetInfo.rxUrbSize = usbNet->usbnetInfo.hardMtu; + if (usbNet->usbnetInfo.rxUrbSize > old_rx_urb_size) { + UsbnetAdapter_pause_rx(usbNet); + UsbnetAdapter_unlink_rx_urbs(usbNet); + UsbnetAdapter_resume_rx(usbNet); + } + } + + /* need transmit hard_mtu to usb net host, UsbnetHostUpdateMaxQlen need this param */ + HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x mtu = %d, hardHeaderLen = %d, link = %d needReset = %d, hardMtu = %d, rxUrbSize = %d, maxpacket =%d", usbNet->usbnetInfo.name,usbNet->usbnetInfo.flags, usbNet->usbnetInfo.usbFlags, usbNet->usbnetInfo.mtu, usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu, usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket ); - /* 5. max qlen depend on hard_mtu and rx_urb_size */ - //UsbnetHostUpdateMaxQlen(usbNet); - /* need update flags to usb_net_host */ - OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_MAXQLEN, (const void *)&usbNet->usbnetInfo, sizeof(usbNet->usbnetInfo)); + /* 5. max qlen depend on hard_mtu and rx_urb_size */ + //UsbnetHostUpdateMaxQlen(usbNet); + /* need update flags to usb_net_host */ + OsalMutexLock(&usbNet->sendSkbClock); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_MAXQLEN, (const void *)&usbNet->usbnetInfo, sizeof(usbNet->usbnetInfo)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); - OsalMutexUnlock(&usbNet->sendSkbClock); - return ret; + OsalMutexUnlock(&usbNet->sendSkbClock); + return ret; } - OsalMutexUnlock(&usbNet->sendSkbClock); + OsalMutexUnlock(&usbNet->sendSkbClock); return HDF_SUCCESS; } @@ -853,17 +861,17 @@ void UsbnetAdapterGetStats64(struct net_device *net, struct rtnl_link_stats64 * //send to device HARCH_NET_INFO_PRINT("begin"); - struct UsbnetAdapter *usbNet = netdev_priv(net); - netdev_stats_to_stats64(stats, &net->stats); - dev_fetch_sw_netstats(stats, usbNet->stats64); + struct UsbnetAdapter *usbNet = netdev_priv(net); + netdev_stats_to_stats64(stats, &net->stats); + dev_fetch_sw_netstats(stats, usbNet->stats64); - struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); - HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); - HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); HARCH_NET_INFO_PRINT("end"); @@ -874,12 +882,12 @@ static struct net_device_ops g_UsbnetAdapterDeviceOps = { .ndo_open = UsbnetAdapterOpen, .ndo_stop = UsbnetAdapterStop, .ndo_start_xmit = UsbnetAdapterStartXmit, - .ndo_tx_timeout = UsbnetAdapterTXTimeout, - .ndo_set_rx_mode = UsbnetAdapterSetRxMode, - .ndo_change_mtu = UsbnetAdapterChangeMtu, - .ndo_get_stats64 = UsbnetAdapterGetStats64, - .ndo_set_mac_address = eth_mac_addr, - .ndo_validate_addr = eth_validate_addr, + .ndo_tx_timeout = UsbnetAdapterTXTimeout, + .ndo_set_rx_mode = UsbnetAdapterSetRxMode, + .ndo_change_mtu = UsbnetAdapterChangeMtu, + .ndo_get_stats64 = UsbnetAdapterGetStats64, + .ndo_set_mac_address = eth_mac_addr, + .ndo_validate_addr = eth_validate_addr, }; /* drivers may override default ethtool_ops in their bind() routine */ @@ -889,20 +897,20 @@ static const struct ethtool_ops g_UsbnetAdapterEthtoolOps = { void UsbnetAdapterLinkChange(struct UsbnetAdapter *usbNet, bool link, bool need_reset) { HARCH_NET_INFO_PRINT("begin"); - /* update link after link is reseted */ - if (link && !need_reset) - netif_carrier_on(usbNet->net); - else - netif_carrier_off(usbNet->net); + /* update link after link is reseted */ + if (link && !need_reset) + netif_carrier_on(usbNet->net); + else + netif_carrier_off(usbNet->net); } static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct HdfSBuf *data, gfp_t flags) { HARCH_NET_INFO_PRINT("begin"); unsigned char *buff = NULL; - uint32_t infoSize = 0; + uint32_t infoSize = 0; int ret = HDF_SUCCESS; - + bool flag = HdfSbufReadBuffer(data, (const void **)(&(buff)), &infoSize); if ((!flag) || buff == NULL) { HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag); @@ -922,26 +930,26 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd if (usbNet == NULL) return HDF_ERR_INVALID_PARAM; - struct sk_buff *skb = NULL; - struct skb_data *entry = NULL; - uint32_t skb_size = sizeof(struct iphdr) + sizeof(struct udphdr) + infoSize; - size_t size = (skb_size > usbNet->usbnetInfo.rxUrbSize ? usbNet->usbnetInfo.rxUrbSize : skb_size ); + struct sk_buff *skb = NULL; + struct skb_data *entry = NULL; + uint32_t skb_size = sizeof(struct iphdr) + sizeof(struct udphdr) + infoSize; + size_t size = (skb_size > usbNet->usbnetInfo.rxUrbSize ? usbNet->usbnetInfo.rxUrbSize : skb_size ); HARCH_NET_INFO_PRINT("size = %d", size); if (test_bit(EVENT_NO_IP_ALIGN, &usbNet->flags)) - skb = __netdev_alloc_skb(usbNet->net, size, flags); - else - skb = __netdev_alloc_skb_ip_align(usbNet->net, size, flags); - - if (!skb) { - HARCH_NET_INFO_PRINT("no rx skb\n"); - UsbnetAdapter_defer_kevent(usbNet, EVENT_RX_MEMORY); - return HDF_DEV_ERR_NO_MEMORY; - } + skb = __netdev_alloc_skb(usbNet->net, size, flags); + else + skb = __netdev_alloc_skb_ip_align(usbNet->net, size, flags); + + if (!skb) { + HARCH_NET_INFO_PRINT("no rx skb\n"); + UsbnetAdapter_defer_kevent(usbNet, EVENT_RX_MEMORY); + return HDF_DEV_ERR_NO_MEMORY; + } entry = (struct skb_data *) skb->cb; - entry->length = 0; - skb_put (skb, infoSize); + entry->length = 0; + skb_put (skb, infoSize); if (memcpy_s(skb->data, infoSize, buff, infoSize) != EOK) { HARCH_NET_INFO_PRINT("memcpy_s error "); return HDF_ERR_INVALID_PARAM; @@ -951,33 +959,33 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd HARCH_NET_INFO_PRINT("recv msg skbBuff"); printf_char_buffer(skb->data, skb->len, false); - // success recv - unsigned long lockflags = 0; - spin_lock_irqsave (&usbNet->rxq.lock, lockflags); + // success recv + unsigned long lockflags = 0; + spin_lock_irqsave (&usbNet->rxq.lock, lockflags); UsbnetAdapterQueueSkb(&usbNet->rxq, skb, rx_start); - spin_unlock_irqrestore (&usbNet->rxq.lock, lockflags); + spin_unlock_irqrestore (&usbNet->rxq.lock, lockflags); - struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); - HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); - // rx complete - enum skb_state state = rx_done; - /* stop rx if packet error rate is high */ + // rx complete + enum skb_state state = rx_done; + /* stop rx if packet error rate is high */ if (++usbNet->pkt_cnt > 30) { - HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); - usbNet->pkt_cnt = 0; - usbNet->pkt_err = 0; - } else { - HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); - if (state == rx_cleanup) - usbNet->pkt_err++; - - if (usbNet->pkt_err > 20) - set_bit(EVENT_RX_KILL, &usbNet->flags); - } - HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); - state = UsbnetAdapterDeferBh(usbNet, skb, &usbNet->rxq, state); + HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); + usbNet->pkt_cnt = 0; + usbNet->pkt_err = 0; + } else { + HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); + if (state == rx_cleanup) + usbNet->pkt_err++; + + if (usbNet->pkt_err > 20) + set_bit(EVENT_RX_KILL, &usbNet->flags); + } + HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); + state = UsbnetAdapterDeferBh(usbNet, skb, &usbNet->rxq, state); HARCH_NET_INFO_PRINT("state= %d", state); HARCH_NET_INFO_PRINT("end"); @@ -986,18 +994,18 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd // precondition: never called in_interrupt static struct device_type wlanType = { - .name = "wlan", + .name = "wlan", }; static struct device_type wwanType = { - .name = "wwan", + .name = "wwan", }; int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) { HARCH_NET_INFO_PRINT("begin"); - int ret = HDF_SUCCESS; - uint32_t infoSize = 0; + int ret = HDF_SUCCESS; + uint32_t infoSize = 0; struct UsbnetTransInfo *uNetTransInfo = NULL; bool flag = HdfSbufReadBuffer(data, (const void **)(&(uNetTransInfo)), &infoSize); @@ -1015,63 +1023,63 @@ int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) device->priv = net; HARCH_NET_INFO_PRINT(); - struct UsbnetAdapter *usbNet = netdev_priv(net); + struct UsbnetAdapter *usbNet = netdev_priv(net); usbNet->deviceObject = device; //info from usb if (memcpy_s(&(usbNet->usbnetInfo), sizeof(struct UsbnetTransInfo), - uNetTransInfo, sizeof(struct UsbnetTransInfo)) != EOK) { + uNetTransInfo, sizeof(struct UsbnetTransInfo)) != EOK) { HARCH_NET_INFO_PRINT("memcpy_s error "); goto out0; } HARCH_NET_INFO_PRINT("name = %s, \ - flags = %d, \ - usbFlags = %x, \ - mtu = %d, \ - hardHeaderLen = %d, \ - link = %d, \ - needReset = %d, \ - hardMtu = %d, \ - rxUrbSize = %d, \ - maxpacket = %d", - usbNet->usbnetInfo.name, - usbNet->usbnetInfo.flags, - usbNet->usbnetInfo.usbFlags, - usbNet->usbnetInfo.mtu, - usbNet->usbnetInfo.hardHeaderLen, - usbNet->usbnetInfo.link, - usbNet->usbnetInfo.needReset, - usbNet->usbnetInfo.hardMtu, - usbNet->usbnetInfo.rxUrbSize, - usbNet->usbnetInfo.maxpacket); - + flags = %d, \ + usbFlags = %x, \ + mtu = %d, \ + hardHeaderLen = %d, \ + link = %d, \ + needReset = %d, \ + hardMtu = %d, \ + rxUrbSize = %d, \ + maxpacket = %d", + usbNet->usbnetInfo.name, + usbNet->usbnetInfo.flags, + usbNet->usbnetInfo.usbFlags, + usbNet->usbnetInfo.mtu, + usbNet->usbnetInfo.hardHeaderLen, + usbNet->usbnetInfo.link, + usbNet->usbnetInfo.needReset, + usbNet->usbnetInfo.hardMtu, + usbNet->usbnetInfo.rxUrbSize, + usbNet->usbnetInfo.maxpacket); + usbNet->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); - if (!usbNet->stats64) - goto out0; + if (!usbNet->stats64) + goto out0; usbNet->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK| NETIF_MSG_RX_ERR|NETIF_MSG_TX_ERR); - + OsalMutexInit(&usbNet->sendSkbClock); - init_waitqueue_head(&usbNet->wait); - skb_queue_head_init (&usbNet->rxq); - skb_queue_head_init (&usbNet->txq); - skb_queue_head_init (&usbNet->done); - skb_queue_head_init(&usbNet->rxq_pause); + init_waitqueue_head(&usbNet->wait); + skb_queue_head_init (&usbNet->rxq); + skb_queue_head_init (&usbNet->txq); + skb_queue_head_init (&usbNet->done); + skb_queue_head_init(&usbNet->rxq_pause); - // init work for tx_complete rx_complete - INIT_WORK(&usbNet->TxCompleteWorkqueue, tx_complete); - INIT_WORK(&usbNet->RxCompleteWorkqueue, rx_complete); + // init work for tx_complete rx_complete + INIT_WORK(&usbNet->TxCompleteWorkqueue, tx_complete); + INIT_WORK(&usbNet->RxCompleteWorkqueue, rx_complete); - usbNet->bh.func = (void (*)(unsigned long))UsbnetAdapterBhTasklet; - usbNet->bh.data = (unsigned long)&usbNet->delay; //struct timer_list delay; + usbNet->bh.func = (void (*)(unsigned long))UsbnetAdapterBhTasklet; + usbNet->bh.data = (unsigned long)&usbNet->delay; //struct timer_list delay; timer_setup(&usbNet->delay, UsbnetAdapterBh, 0); - usbNet->net = net; - // 1.addr + usbNet->net = net; + // 1.addr static u8 node_id[ETH_ALEN]; if (usbNet->usbnetInfo.isGetmacAddr) { @@ -1082,24 +1090,24 @@ int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) { eth_random_addr(node_id); } - memcpy(net->dev_addr, node_id, sizeof(node_id)); + memcpy(net->dev_addr, node_id, sizeof(node_id)); HARCH_NET_INFO_PRINT("macAddr addr %pM", net->dev_addr); - // 2. mtu + // 2. mtu net->min_mtu = 0; - net->max_mtu = ETH_MAX_MTU; + net->max_mtu = ETH_MAX_MTU; net->netdev_ops = &g_UsbnetAdapterDeviceOps; net->watchdog_timeo = TX_TIMEOUT_JIFFIES; - net->ethtool_ops = &g_UsbnetAdapterEthtoolOps; + net->ethtool_ops = &g_UsbnetAdapterEthtoolOps; - //3. name and mtu + //3. name and mtu strcpy (net->name, "usb%d"); if (usbNet->usbnetInfo.isBindDevice) { /* heuristic: "usb%d" for links we know are two-host, - else "eth%d" when there's reasonable doubt. userspace - can rename the link if it knows better. + else "eth%d" when there's reasonable doubt. userspace + can rename the link if it knows better. */ if ((usbNet->usbnetInfo.usbFlags & FLAG_ETHER) != 0 && ((usbNet->usbnetInfo.usbFlags & FLAG_POINTTOPOINT) == 0 || @@ -1138,38 +1146,38 @@ int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) HARCH_NET_INFO_PRINT("net->name= %s",net->name); /* let userspace know we have a random address */ - if (ether_addr_equal(net->dev_addr, node_id)) - net->addr_assign_type = NET_ADDR_RANDOM; + if (ether_addr_equal(net->dev_addr, node_id)) + net->addr_assign_type = NET_ADDR_RANDOM; if ((usbNet->usbnetInfo.usbFlags & FLAG_WLAN) != 0) - SET_NETDEV_DEVTYPE(net, &wlanType); + SET_NETDEV_DEVTYPE(net, &wlanType); - if (usbNet->usbnetInfo.usbFlags & FLAG_WWAN != 0) - SET_NETDEV_DEVTYPE(net, &wwanType); + if (usbNet->usbnetInfo.usbFlags & FLAG_WWAN != 0) + SET_NETDEV_DEVTYPE(net, &wwanType); - ret = register_netdev(net); - if (ret) - goto out0; + ret = register_netdev(net); + if (ret) + goto out0; - HARCH_NET_INFO_PRINT( "register net %pM\n", net->dev_addr); + HARCH_NET_INFO_PRINT( "register net %pM\n", net->dev_addr); netif_device_attach(net); - HARCH_NET_INFO_PRINT( "netif_device_attach net %pM\n", net->dev_addr); + HARCH_NET_INFO_PRINT( "netif_device_attach net %pM\n", net->dev_addr); - if (usbNet->usbnetInfo.usbFlags & FLAG_LINK_INTR) - { - HARCH_NET_INFO_PRINT(); - UsbnetAdapterLinkChange(usbNet, 0, 0); - } + if (usbNet->usbnetInfo.usbFlags & FLAG_LINK_INTR) + { + HARCH_NET_INFO_PRINT(); + UsbnetAdapterLinkChange(usbNet, 0, 0); + } return HDF_SUCCESS; out0: - cancel_work_sync(&usbNet->TxCompleteWorkqueue); - cancel_work_sync(&usbNet->RxCompleteWorkqueue); - free_netdev(net); + cancel_work_sync(&usbNet->TxCompleteWorkqueue); + cancel_work_sync(&usbNet->RxCompleteWorkqueue); + free_netdev(net); out: - return ret; + return ret; } static int32_t UsbnetAdapterDisconnect(struct HdfDeviceObject *device) @@ -1180,7 +1188,7 @@ static int32_t UsbnetAdapterDisconnect(struct HdfDeviceObject *device) return HDF_ERR_INVALID_OBJECT; } - //free net + //free net struct net_device *net = (struct net_device *)device->priv; unregister_netdev (net); @@ -1189,9 +1197,9 @@ static int32_t UsbnetAdapterDisconnect(struct HdfDeviceObject *device) { free_percpu(usbNet->stats64); } - - UsbnetAdapterTerminateUrbs(usbNet); - skb_queue_purge(&usbNet->rxq_pause); + + UsbnetAdapterTerminateUrbs(usbNet); + skb_queue_purge(&usbNet->rxq_pause); OsalMutexDestroy(&usbNet->sendSkbClock); free_netdev(net); @@ -1206,25 +1214,25 @@ static int32_t UsbnetAdapterDispatch( int32_t ret = HDF_ERR_INVALID_PARAM; switch (cmd) { - case USB_NET_REGISTER_NET: - { - //add new usbnet device - ret = UsbnetAdapterProbe(client->device, data); - } - break; - case USB_NET_CLOSE_NET: - { - ret = UsbnetAdapterDisconnect(client->device); - } - break; - case USB_NET_RECIVE_DATA_FROM_USB: - { - ret = UsbnetAdapterRxComplete(client->device, data, GFP_ATOMIC); - } - break; - default: - HDF_LOGI("%s: no this cmd: %d", __func__, cmd); - break; + case USB_NET_REGISTER_NET: + { + //add new usbnet device + ret = UsbnetAdapterProbe(client->device, data); + } + break; + case USB_NET_CLOSE_NET: + { + ret = UsbnetAdapterDisconnect(client->device); + } + break; + case USB_NET_RECIVE_DATA_FROM_USB: + { + ret = UsbnetAdapterRxComplete(client->device, data, GFP_ATOMIC); + } + break; + default: + HDF_LOGI("%s: no this cmd: %d", __func__, cmd); + break; } if (!HdfSbufWriteInt32(reply, ret)) { diff --git a/framework/model/usb/include/hdf_usb_net_manager.h b/framework/model/usb/include/hdf_usb_net_manager.h index 870a8694c..e6aff01f0 100755 --- a/framework/model/usb/include/hdf_usb_net_manager.h +++ b/framework/model/usb/include/hdf_usb_net_manager.h @@ -1,3 +1,11 @@ +/* + * Copyright (c) 2023-2024 ArcherMind Technology (Nanjing) Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + #ifndef HDF_USB_NET_MANAGE_H #define HDF_USB_NET_MANAGE_H @@ -9,30 +17,30 @@ #define IFNAMSIZ 16 /* framing is CDC Ethernet, not writing ZLPs (hw issues), or optionally: */ -#define FLAG_FRAMING_NC 0x0001 /* guard against device dropouts */ -#define FLAG_FRAMING_GL 0x0002 /* genelink batches packets */ -#define FLAG_FRAMING_Z 0x0004 /* zaurus adds a trailer */ -#define FLAG_FRAMING_RN 0x0008 /* RNDIS batches, plus huge header */ +#define FLAG_FRAMING_NC 0x0001 /* guard against device dropouts */ +#define FLAG_FRAMING_GL 0x0002 /* genelink batches packets */ +#define FLAG_FRAMING_Z 0x0004 /* zaurus adds a trailer */ +#define FLAG_FRAMING_RN 0x0008 /* RNDIS batches, plus huge header */ -#define FLAG_NO_SETINT 0x0010 /* device can't set_interface() */ -#define FLAG_ETHER 0x0020 /* maybe use "eth%d" names */ +#define FLAG_NO_SETINT 0x0010 /* device can't set_interface() */ +#define FLAG_ETHER 0x0020 /* maybe use "eth%d" names */ -#define FLAG_FRAMING_AX 0x0040 /* AX88772/178 packets */ -#define FLAG_WLAN 0x0080 /* use "wlan%d" names */ -#define FLAG_AVOID_UNLINK_URBS 0x0100 /* don't unlink urbs at usbnet_stop() */ -#define FLAG_SEND_ZLP 0x0200 /* hw requires ZLPs are sent */ -#define FLAG_WWAN 0x0400 /* use "wwan%d" names */ +#define FLAG_FRAMING_AX 0x0040 /* AX88772/178 packets */ +#define FLAG_WLAN 0x0080 /* use "wlan%d" names */ +#define FLAG_AVOID_UNLINK_URBS 0x0100 /* don't unlink urbs at usbnet_stop() */ +#define FLAG_SEND_ZLP 0x0200 /* hw requires ZLPs are sent */ +#define FLAG_WWAN 0x0400 /* use "wwan%d" names */ -#define FLAG_LINK_INTR 0x0800 /* updates link (carrier) status */ -#define FLAG_POINTTOPOINT 0x1000 /* possibly use "usb%d" names */ +#define FLAG_LINK_INTR 0x0800 /* updates link (carrier) status */ +#define FLAG_POINTTOPOINT 0x1000 /* possibly use "usb%d" names */ /* * Indicates to usbnet, that USB driver accumulates multiple IP packets. * Affects statistic (counters) and short packet handling. */ -#define FLAG_MULTI_PACKET 0x2000 -#define FLAG_RX_ASSEMBLE 0x4000 /* rx packets may span >1 frames */ -#define FLAG_NOARP 0x8000 /* device can't do ARP */ +#define FLAG_MULTI_PACKET 0x2000 +#define FLAG_RX_ASSEMBLE 0x4000 /* rx packets may span >1 frames */ +#define FLAG_NOARP 0x8000 /* device can't do ARP */ enum UsbnetServiceCmd { USB_NET_REGISTER_NET, @@ -56,9 +64,9 @@ struct UsbnetTransInfo { uint8_t link; uint8_t needReset; uint32_t usbFlags; /**< usb device match flags */ - uint32_t rxUrbSize; /* size for rx urbs */ - uint32_t hardMtu; /* count any extra framing */ - uint32_t maxpacket; + uint32_t rxUrbSize; /* size for rx urbs */ + uint32_t hardMtu; /* count any extra framing */ + uint32_t maxpacket; int txQlen; }; -- Gitee From 7cbb2ba527e3b19c2e9769ad8c12668592a76b1f Mon Sep 17 00:00:00 2001 From: n028372 Date: Tue, 16 Jan 2024 18:09:30 +0800 Subject: [PATCH 3/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: n028372 --- .../model/usb/host/include/usb_net_adapter.h | 108 +++++++++--------- .../model/usb/host/src/usb_net_adapter.c | 103 ++++++----------- .../model/usb/include/hdf_usb_net_manager.h | 16 +-- .../model/usb/include/hdf_usb_pnp_manage.h | 2 +- 4 files changed, 100 insertions(+), 129 deletions(-) diff --git a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h index a8db860f3..7bf6f3902 100755 --- a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h +++ b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024 ArcherMind Technology (Nanjing) Co., Ltd. + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. * * HDF is dual licensed: you can use it either under the terms of * the GPL, or the BSD license, at your option. @@ -21,80 +21,80 @@ do{ \ }while(0) struct rndis_data_hdr { - __le32 msg_type; /* RNDIS_MSG_PACKET */ - __le32 msg_len; /* rndis_data_hdr + data_len + pad */ - __le32 data_offset; /* 36 -- right after header */ - __le32 data_len; /* ... real packet size */ - - __le32 oob_data_offset; /* zero */ - __le32 oob_data_len; /* zero */ - __le32 num_oob; /* zero */ - __le32 packet_data_offset; /* zero */ - - __le32 packet_data_len; /* zero */ - __le32 vc_handle; /* zero */ - __le32 reserved; /* zero */ + __le32 msg_type; /* RNDIS_MSG_PACKET */ + __le32 msg_len; /* rndis_data_hdr + data_len + pad */ + __le32 data_offset; /* 36 -- right after header */ + __le32 data_len; /* ... real packet size */ + + __le32 oob_data_offset; /* zero */ + __le32 oob_data_len; /* zero */ + __le32 num_oob; /* zero */ + __le32 packet_data_offset; /* zero */ + + __le32 packet_data_len; /* zero */ + __le32 vc_handle; /* zero */ + __le32 reserved; /* zero */ } __attribute__ ((packed)); struct UsbnetAdapter{ struct IDeviceIoService service; struct HdfDeviceObject *deviceObject; - unsigned can_dma_sg:1; + unsigned can_dma_sg:1; struct net_device *net; int32_t msg_enable; struct UsbnetTransInfo usbnetInfo; - struct OsalMutex sendSkbClock; + struct OsalMutex sendSkbClock; - unsigned char pkt_cnt, pkt_err; + unsigned char pkt_cnt, pkt_err; - /* various kinds of pending driver work */ - wait_queue_head_t wait; - struct timer_list delay; + /* various kinds of pending driver work */ + wait_queue_head_t wait; + struct timer_list delay; - struct sk_buff_head rxq; - struct sk_buff_head txq; + struct sk_buff_head rxq; + struct sk_buff_head txq; - struct sk_buff_head done; - struct sk_buff_head rxq_pause; - struct tasklet_struct bh; + struct sk_buff_head done; + struct sk_buff_head rxq_pause; + struct tasklet_struct bh; struct pcpu_sw_netstats __percpu *stats64; - - struct work_struct kevent; - struct work_struct TxCompleteWorkqueue; - struct work_struct RxCompleteWorkqueue; - unsigned int TxLen; - unsigned int RxLen; - unsigned long flags; -# define EVENT_TX_HALT 0 -# define EVENT_RX_HALT 1 -# define EVENT_RX_MEMORY 2 -# define EVENT_STS_SPLIT 3 -# define EVENT_LINK_RESET 4 -# define EVENT_RX_PAUSED 5 -# define EVENT_DEV_ASLEEP 6 -# define EVENT_DEV_OPEN 7 -# define EVENT_DEVICE_REPORT_IDLE 8 -# define EVENT_NO_RUNTIME_PM 9 -# define EVENT_RX_KILL 10 -# define EVENT_LINK_CHANGE 11 -# define EVENT_SET_RX_MODE 12 -# define EVENT_NO_IP_ALIGN 13 + + struct work_struct kevent; + struct work_struct TxCompleteWorkqueue; + struct work_struct RxCompleteWorkqueue; + unsigned int TxLen; + unsigned int RxLen; + unsigned long flags; +# define EVENT_TX_HALT 0 +# define EVENT_RX_HALT 1 +# define EVENT_RX_MEMORY 2 +# define EVENT_STS_SPLIT 3 +# define EVENT_LINK_RESET 4 +# define EVENT_RX_PAUSED 5 +# define EVENT_DEV_ASLEEP 6 +# define EVENT_DEV_OPEN 7 +# define EVENT_DEVICE_REPORT_IDLE 8 +# define EVENT_NO_RUNTIME_PM 9 +# define EVENT_RX_KILL 10 +# define EVENT_LINK_CHANGE 11 +# define EVENT_SET_RX_MODE 12 +# define EVENT_NO_IP_ALIGN 13 }; /* we record the state for each of our queued skbs */ enum skb_state { - illegal = 0, - tx_start, tx_done, - rx_start, rx_done, rx_cleanup, - unlink_start + illegal = 0, + tx_start, tx_done, + rx_start, rx_done, rx_cleanup, + unlink_start }; -struct skb_data { /* skb->cb is one of these */ - enum skb_state state; - long length; - unsigned long packets; +struct skb_data { /* skb->cb is one of these */ + enum skb_state state; + long length; + unsigned long packets; }; #endif diff --git a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c index 77ab64436..ae6c0b650 100755 --- a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c +++ b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c @@ -1,11 +1,17 @@ /* - * Copyright (c) 2023-2024 ArcherMind Technology (Nanjing) Co., Ltd. + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at * - * HDF is dual licensed: you can use it either under the terms of - * the GPL, or the BSD license, at your option. - * See the LICENSE file in the root of this repository for complete details. + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. */ - #include #include #include @@ -34,6 +40,10 @@ #define UNLINK_TIMEOUT_MS 3 #define TX_QLEN(dev) ((dev)->usbnetInfo.txQlen) +#define PKT_COUNT_CLEAR 30 +#define PKT_COUNT_RXKILL 20 +#define SHIFT_LINE_NUM 32 + /* use ethtool to change the level for any given device */ static int msg_level = -1; module_param (msg_level, int, 0); @@ -48,7 +58,7 @@ static int printf_char_buffer(char *buff, int size, bool isPrint) for (i = 0; i < size; i++) { printk(KERN_CONT"%02x ", buff[i]); - if ((i+1) % 32 == 0) + if ((i+1) % SHIFT_LINE_NUM == 0) { printk(KERN_CONT"\n"); } @@ -58,25 +68,6 @@ static int printf_char_buffer(char *buff, int size, bool isPrint) return 0; } -static void analysis_skb(struct sk_buff *skb) { - - struct net_device *dev = skb->dev; - struct ethhdr *ethh = eth_hdr(skb); - struct iphdr *ip = ip_hdr(skb); - - unsigned int *src_ip = &ip->saddr; - unsigned int *dst_ip = &ip->daddr; - unsigned char *src_mac = ethh->h_source; - unsigned char *dst_mac = ethh->h_dest; - - printk(" source ip:%pI4\n",src_ip); - printk(" dest ip:%pI4\n",dst_ip); - printk(" destination eth addr:%x:%x:%x:%x:%x:%x\n", - ethh->h_dest[0],ethh->h_dest[1],ethh->h_dest[2],ethh->h_dest[3],ethh->h_dest[4],ethh->h_dest[5]); - printk(" source eth addr:%x:%x:%x:%x:%x:%x\n", - ethh->h_source[0],ethh->h_source[1],ethh->h_source[2],ethh->h_source[3],ethh->h_source[4],ethh->h_source[5]); -} - int32_t UsbnetAdapterSendBufToUsb(const struct HdfDeviceObject *device, uint32_t id, const void *buf, uint32_t writeSize) { @@ -202,7 +193,8 @@ static int rndisRxFixup(struct UsbnetAdapter *usbNet, struct sk_buff *skb) msg_len, data_offset, data_len, skb->len); return 0; } - skb_pull(skb, 8 + data_offset); + unsigned int offset = 8 + data_offset; + skb_pull(skb, offset); /* at most one packet left? */ if (likely((data_len - skb->len) <= sizeof *hdr)) { @@ -458,9 +450,9 @@ int32_t UsbnetAdapterStop(struct net_device *net) HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", stats64->tx_packets,stats64->tx_bytes); - /* 1. clear_bit(EVENT_DEV_OPEN, &dev->flags); */ + /* 1. clear_bit EVENT_DEV_OPEN dev->flags */ clear_bit(EVENT_DEV_OPEN, &usbNet->flags); - /* 2. netif_stop_queue (net); */ + /* 2. netif_stop_queue net */ netif_stop_queue (net); HARCH_NET_INFO_PRINT("stop stats: rx/tx %lu/%lu, errs %lu/%lu\n", net->stats.rx_packets, net->stats.tx_packets, @@ -473,12 +465,11 @@ int32_t UsbnetAdapterStop(struct net_device *net) UsbnetAdapterTerminateUrbs(usbNet); } - /* 6. usbnet_status_stop(dev); none */ - /* 7. usbnet_purge_paused_rxq(dev); none */ + /* 6. usbnet_status_stop none */ + /* 7. usbnet_purge_paused_rxq none */ skb_queue_purge(&usbNet->rxq_pause); - /* 8. mpn = !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags); if (info->manage_power && mpn) - no manage_power interface impl in rndis driver info*/ - /* 9. dev->flags = 0; */ + /* 8. test_and_clear_bit and no manage_power interface impl in rndis driver info*/ + /* 9. dev flags */ usbNet->flags = 0; OsalMutexLock(&usbNet->sendSkbClock); int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_CLOSE_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); @@ -489,12 +480,11 @@ int32_t UsbnetAdapterStop(struct net_device *net) return HDF_FAILURE; } OsalMutexUnlock(&usbNet->sendSkbClock); - /* 10. del_timer_sync (&dev->delay); */ + /* 10. del_timer_sync */ del_timer_sync (&usbNet->delay); - /* 11. tasklet_kill (&dev->bh); */ + /* 11. tasklet_kill */ tasklet_kill (&usbNet->bh); - /* 12. cancel_work_sync(&dev->kevent); no kevent, do nothing */ - //cancel_work_sync(&usbNet->kevent); + /* 12. cancel_work_sync dev->kevent */ cancel_work_sync(&usbNet->TxCompleteWorkqueue); cancel_work_sync(&usbNet->RxCompleteWorkqueue); return HDF_SUCCESS; @@ -539,7 +529,8 @@ fill: memset(hdr, 0, sizeof *hdr); hdr->msg_type = cpu_to_le32(RNDIS_MSG_PACKET); hdr->msg_len = cpu_to_le32(skb->len); - hdr->data_offset = cpu_to_le32(sizeof(*hdr) - 8); + unsigned int offset = sizeof(*hdr) - 8; + hdr->data_offset = cpu_to_le32(offset); hdr->data_len = cpu_to_le32(len); /* FIXME make the last packet always be short ... */ @@ -576,7 +567,6 @@ static void tx_complete(struct work_struct *work) netdev_tx_t UsbnetAdapterStartXmit(struct sk_buff *skb, struct net_device *net) { - analysis_skb(skb); HARCH_NET_INFO_PRINT("netif_running = %d, netif_device_present = %d" , netif_running (net),netif_device_present (net)); HARCH_NET_INFO_PRINT("netif_carrier_ok = %d" , netif_carrier_ok (net)); @@ -704,22 +694,7 @@ void UsbnetAdapter_defer_kevent (struct UsbnetAdapter *usbNet, int work) void UsbnetAdapterSetRxMode(struct net_device *net) { - //send to device - HARCH_NET_INFO_PRINT("begin"); - return; - - if ( NULL == net) { - HDF_LOGE("%s net device object is invalid", __func__); - return; - } - struct UsbnetAdapter *usbNet = netdev_priv(net); - if ( NULL == usbNet) { - HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); - return; - } - /* usbnet_defer_kevent(dev, EVENT_SET_RX_MODE); */ - UsbnetAdapter_defer_kevent(usbNet, EVENT_SET_RX_MODE); - return; + return; } void UsbnetAdapter_pause_rx(struct UsbnetAdapter *usbNet) @@ -753,7 +728,7 @@ void UsbnetAdapter_unlink_rx_urbs(struct UsbnetAdapter *usbNet) } if (netif_running(usbNet->net)) { - /* (void) unlink_urbs (usbNet, &usbNet->rxq); */ + /* unlink_urbs usbNet usbNet->rxq */ tasklet_schedule(&usbNet->bh); } } @@ -805,10 +780,7 @@ int32_t UsbnetAdapterChangeMtu(struct net_device *net, int newMtu) return HDF_FAILURE; } - /* 1. int ll_mtu = new_mtu + net->hard_header_len; - int old_hard_mtu = dev->hard_mtu; - int old_rx_urb_size = dev->rx_urb_size; - */ + /* 1. ll_mtu old_hard_mtu old_rx_urb_size */ HARCH_NET_INFO_PRINT("newMtu:%d", newMtu); int ll_mtu = newMtu + net->hard_header_len; int old_hard_mtu = usbNet->usbnetInfo.hardMtu; @@ -842,7 +814,6 @@ int32_t UsbnetAdapterChangeMtu(struct net_device *net, int newMtu) usbNet->usbnetInfo.maxpacket ); /* 5. max qlen depend on hard_mtu and rx_urb_size */ - //UsbnetHostUpdateMaxQlen(usbNet); /* need update flags to usb_net_host */ OsalMutexLock(&usbNet->sendSkbClock); int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_MAXQLEN, (const void *)&usbNet->usbnetInfo, sizeof(usbNet->usbnetInfo)); @@ -971,8 +942,8 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd // rx complete enum skb_state state = rx_done; - /* stop rx if packet error rate is high */ - if (++usbNet->pkt_cnt > 30) { + /* stop rx if packet error rate is high */ + if (++usbNet->pkt_cnt > PKT_COUNT_CLEAR) { HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); usbNet->pkt_cnt = 0; usbNet->pkt_err = 0; @@ -981,7 +952,7 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd if (state == rx_cleanup) usbNet->pkt_err++; - if (usbNet->pkt_err > 20) + if (usbNet->pkt_err > PKT_COUNT_RXKILL) set_bit(EVENT_RX_KILL, &usbNet->flags); } HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); @@ -1109,8 +1080,8 @@ int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) else "eth%d" when there's reasonable doubt. userspace can rename the link if it knows better. */ - if ((usbNet->usbnetInfo.usbFlags & FLAG_ETHER) != 0 && - ((usbNet->usbnetInfo.usbFlags & FLAG_POINTTOPOINT) == 0 || + if ((usbNet->usbnetInfo.usbFlags & HDF_FLAG_ETHER) != 0 && + ((usbNet->usbnetInfo.usbFlags & HDF_FLAG_POINTTOPOINT) == 0 || (net->dev_addr[0] & 0x02) == 0)) { HARCH_NET_INFO_PRINT(); diff --git a/framework/model/usb/include/hdf_usb_net_manager.h b/framework/model/usb/include/hdf_usb_net_manager.h index e6aff01f0..f659a7294 100755 --- a/framework/model/usb/include/hdf_usb_net_manager.h +++ b/framework/model/usb/include/hdf_usb_net_manager.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024 ArcherMind Technology (Nanjing) Co., Ltd. + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. * * HDF is dual licensed: you can use it either under the terms of * the GPL, or the BSD license, at your option. @@ -19,11 +19,11 @@ /* framing is CDC Ethernet, not writing ZLPs (hw issues), or optionally: */ #define FLAG_FRAMING_NC 0x0001 /* guard against device dropouts */ #define FLAG_FRAMING_GL 0x0002 /* genelink batches packets */ -#define FLAG_FRAMING_Z 0x0004 /* zaurus adds a trailer */ -#define FLAG_FRAMING_RN 0x0008 /* RNDIS batches, plus huge header */ +#define FLAG_FRAMING_Z 0x0004 /* zaurus adds a trailer */ +#define HDF_FLAG_FRAMING_RN 0x0008 /* RNDIS batches, plus huge header */ -#define FLAG_NO_SETINT 0x0010 /* device can't set_interface() */ -#define FLAG_ETHER 0x0020 /* maybe use "eth%d" names */ +#define HDF_FLAG_NO_SETINT 0x0010 /* device can't set_interface() */ +#define HDF_FLAG_ETHER 0x0020 /* maybe use "eth%d" names */ #define FLAG_FRAMING_AX 0x0040 /* AX88772/178 packets */ #define FLAG_WLAN 0x0080 /* use "wlan%d" names */ @@ -32,14 +32,14 @@ #define FLAG_WWAN 0x0400 /* use "wwan%d" names */ #define FLAG_LINK_INTR 0x0800 /* updates link (carrier) status */ -#define FLAG_POINTTOPOINT 0x1000 /* possibly use "usb%d" names */ +#define HDF_FLAG_POINTTOPOINT 0x1000 /* possibly use "usb%d" names */ /* * Indicates to usbnet, that USB driver accumulates multiple IP packets. * Affects statistic (counters) and short packet handling. */ -#define FLAG_MULTI_PACKET 0x2000 -#define FLAG_RX_ASSEMBLE 0x4000 /* rx packets may span >1 frames */ +#define FLAG_MULTI_PACKET 0x2000 +#define FLAG_RX_ASSEMBLE 0x4000 /* rx packets may span >1 frames */ #define FLAG_NOARP 0x8000 /* device can't do ARP */ enum UsbnetServiceCmd { diff --git a/framework/model/usb/include/hdf_usb_pnp_manage.h b/framework/model/usb/include/hdf_usb_pnp_manage.h index 943707dda..bc0cd9d23 100644 --- a/framework/model/usb/include/hdf_usb_pnp_manage.h +++ b/framework/model/usb/include/hdf_usb_pnp_manage.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. * * HDF is dual licensed: you can use it either under the terms of * the GPL, or the BSD license, at your option. -- Gitee From aacaa579326bd507b1d52a0c054f52e3bd2cbb31 Mon Sep 17 00:00:00 2001 From: n028372 Date: Wed, 17 Jan 2024 16:08:45 +0800 Subject: [PATCH 4/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: n028372 --- .../model/usb/host/include/usb_net_adapter.h | 67 ++- .../model/usb/host/src/usb_net_adapter.c | 519 ++++++++---------- 2 files changed, 280 insertions(+), 306 deletions(-) diff --git a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h index 7bf6f3902..e84270fb7 100755 --- a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h +++ b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h @@ -13,13 +13,26 @@ #include "hdf_log.h" #include "hdf_usb_net_manager.h" +#define ModuleParam module_param #define HARCH_LOG_TAG "[-net-hdf-]" -#define HARCH_NET_INFO_PRINT(fmt,...) \ +#define HARCH_NET_INFO_PRINT(fmt,...)\ do{ \ if(1){\ - HDF_LOGI(HARCH_LOG_TAG"[%s][%d]:"fmt"\n",__FUNCTION__,__LINE__,##__VA_ARGS__);}\ + HDF_LOGI(HARCH_LOG_TAG"[%{public}s][%{public}d]:" fmt "\n",__FUNCTION__, __LINE__, ##__VA_ARGS__);}\ }while(0) +typedef struct pcpu_sw_netstats PcpuSwNetstats; +typedef struct net_device NetDevice; +typedef struct timer_list TimerList; +typedef struct work_struct WorkStruct; +typedef struct tasklet_struct TaskletStruct; +typedef struct device_type DeviceType; +typedef struct ethtool_ops EthtoolOps; +typedef struct rndis_data_hdr RndisDataHdr; +typedef struct sk_buff SkBuff; +typedef struct sk_buff_head SkBuff_Head; +typedef struct net_device_ops NetDevice_Ops; + struct rndis_data_hdr { __le32 msg_type; /* RNDIS_MSG_PACKET */ __le32 msg_len; /* rndis_data_hdr + data_len + pad */ @@ -39,32 +52,32 @@ struct rndis_data_hdr { struct UsbnetAdapter{ struct IDeviceIoService service; struct HdfDeviceObject *deviceObject; - unsigned can_dma_sg:1; - struct net_device *net; - int32_t msg_enable; + unsigned canDmaSg:1; + NetDevice *net; + int32_t msg_enable; struct UsbnetTransInfo usbnetInfo; struct OsalMutex sendSkbClock; - unsigned char pkt_cnt, pkt_err; + unsigned char pkt_Cnt, pkt_Err; /* various kinds of pending driver work */ wait_queue_head_t wait; - struct timer_list delay; + TimerList delay; - struct sk_buff_head rxq; - struct sk_buff_head txq; + SkBuff_Head rxq; + SkBuff_Head txq; - struct sk_buff_head done; - struct sk_buff_head rxq_pause; - struct tasklet_struct bh; + SkBuff_Head done; + SkBuff_Head rxq_pause; + TaskletStruct bh; struct pcpu_sw_netstats __percpu *stats64; - struct work_struct kevent; - struct work_struct TxCompleteWorkqueue; - struct work_struct RxCompleteWorkqueue; - unsigned int TxLen; - unsigned int RxLen; + WorkStruct kevent; + WorkStruct TxCompleteWorkqueue; + WorkStruct RxCompleteWorkqueue; + unsigned int txLen; + unsigned int rxLen; unsigned long flags; # define EVENT_TX_HALT 0 # define EVENT_RX_HALT 1 @@ -80,21 +93,23 @@ struct UsbnetAdapter{ # define EVENT_LINK_CHANGE 11 # define EVENT_SET_RX_MODE 12 # define EVENT_NO_IP_ALIGN 13 - }; /* we record the state for each of our queued skbs */ -enum skb_state { - illegal = 0, - tx_start, tx_done, - rx_start, rx_done, rx_cleanup, - unlink_start +enum SkbState { + ILLEGAL = 0, + TX_START, + TX_DONE, + RX_START, + RX_DONE, + RX_CLEANUP, + UNLINK_START }; -struct skb_data { /* skb->cb is one of these */ - enum skb_state state; +struct SkbData { /* skb->cb is one of these */ + enum SkbState state; long length; - unsigned long packets; + unsigned long packets; }; #endif diff --git a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c index ae6c0b650..d17ee8a9a 100755 --- a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c +++ b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c @@ -24,6 +24,7 @@ #include #include #endif + #include #include #include "osal_mem.h" @@ -45,9 +46,9 @@ #define SHIFT_LINE_NUM 32 /* use ethtool to change the level for any given device */ -static int msg_level = -1; -module_param (msg_level, int, 0); -MODULE_PARM_DESC (msg_level, "Override default message level"); +static int g_msgLevel = -1; +module_param (g_msgLevel, int, 0); +MODULE_PARM_DESC (g_msgLevel, "Override default message level"); static int printf_char_buffer(char *buff, int size, bool isPrint) { @@ -58,7 +59,7 @@ static int printf_char_buffer(char *buff, int size, bool isPrint) for (i = 0; i < size; i++) { printk(KERN_CONT"%02x ", buff[i]); - if ((i+1) % SHIFT_LINE_NUM == 0) + if ((i + 1) % SHIFT_LINE_NUM == 0) { printk(KERN_CONT"\n"); } @@ -71,7 +72,7 @@ static int printf_char_buffer(char *buff, int size, bool isPrint) int32_t UsbnetAdapterSendBufToUsb(const struct HdfDeviceObject *device, uint32_t id, const void *buf, uint32_t writeSize) { - HARCH_NET_INFO_PRINT("writeSize: %d", writeSize); + HARCH_NET_INFO_PRINT ("writeSize=%d", writeSize); int32_t ret = HDF_SUCCESS; if ((device == NULL) || (buf == NULL)) { HDF_LOGE("%s param is null", __func__); @@ -103,11 +104,11 @@ out: } -static void rx_complete(struct work_struct *work){ +static void RxComplete (WorkStruct *work) { unsigned long flags = 0; struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, RxCompleteWorkqueue); - struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", stats64->rx_packets, stats64->rx_bytes); @@ -117,7 +118,7 @@ static void rx_complete(struct work_struct *work){ flags = u64_stats_update_begin_irqsave(&stats64->syncp); stats64->rx_packets++; - stats64->rx_bytes += usbNet->RxLen; + stats64->rx_bytes += usbNet->rxLen; u64_stats_update_end_irqrestore(&stats64->syncp, flags); HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", @@ -125,33 +126,32 @@ static void rx_complete(struct work_struct *work){ HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", stats64->tx_packets,stats64->tx_bytes); - } /* Passes this packet up the stack, updating its accounting. * Some link protocols batch packets, so their rx_fixup paths * can return clones as well as just modify the original skb. */ -void UsbnetAdapterSkbReturn (struct UsbnetAdapter *usbNet, struct sk_buff *skb) -{ - +static void UsbnetAdapterSkbReturn (struct UsbnetAdapter *usbNet, SkBuff *skb) +{ if (test_bit(EVENT_RX_PAUSED, &usbNet->flags)) { skb_queue_tail(&usbNet->rxq_pause, skb); return; } /* only update if unset to allow minidriver rx_fixup override */ - if (skb->protocol == 0) + if (skb->protocol == 0) { skb->protocol = eth_type_trans (skb, usbNet->net); + } - usbNet->RxLen = skb->len; - schedule_work_on(0,&usbNet->RxCompleteWorkqueue); + usbNet->rxLen = skb->len; + schedule_work_on(0, &usbNet->RxCompleteWorkqueue); HARCH_NET_INFO_PRINT("< rx, len %zu, type 0x%x\n", skb->len + sizeof (struct ethhdr), skb->protocol); - (void)memset_s(skb->cb, sizeof (struct skb_data), 0, sizeof (struct skb_data)); + (void)memset_s(skb->cb, sizeof(struct SkbData), 0, sizeof(struct SkbData)); - if (skb_defer_rx_timestamp(skb)) + if (skb_defer_rx_timestamp(skb)) { return; - + } HARCH_NET_INFO_PRINT("-------rx before netif_rx"); printf_char_buffer(skb->data, skb->len, false); @@ -159,34 +159,36 @@ void UsbnetAdapterSkbReturn (struct UsbnetAdapter *usbNet, struct sk_buff *skb) status = netif_rx (skb); HARCH_NET_INFO_PRINT("netif_rx status %d\n", status); - if (status != NET_RX_SUCCESS) + if (status != NET_RX_SUCCESS) { HARCH_NET_INFO_PRINT("netif_rx status %d\n", status); + } } /* * DATA -- host must not write zlps */ -static int rndisRxFixup(struct UsbnetAdapter *usbNet, struct sk_buff *skb) +static int RndisRxFixup(struct UsbnetAdapter *usbNet, SkBuff *skb) { /* This check is no longer done by usbnet */ - if (skb->len < usbNet->net->hard_header_len) + if (skb->len < usbNet->net->hard_header_len) { return 0; - + } /* peripheral may have batched packets to us... */ while (likely(skb->len)) { - struct rndis_data_hdr *hdr = (void *)skb->data; - struct sk_buff *skb2; + RndisDataHdr *hdr = (void *)skb->data; + SkBuff *skb2; u32 msg_type, msg_len, data_offset, data_len; msg_type = le32_to_cpu(hdr->msg_type); msg_len = le32_to_cpu(hdr->msg_len); data_offset = le32_to_cpu(hdr->data_offset); data_len = le32_to_cpu(hdr->data_len); - + unsigned int total_len = data_offset + data_len + 8; + /* don't choke if we see oob, per-packet data, etc */ if (unlikely(msg_type != RNDIS_MSG_PACKET || skb->len < msg_len - || (data_offset + data_len + 8) > msg_len)) { + || total_len > msg_len)) { usbNet->net->stats.rx_frame_errors++; netdev_dbg(usbNet->net, "bad rndis message %d/%d/%d/%d, len %d\n", le32_to_cpu(hdr->msg_type), @@ -204,8 +206,9 @@ static int rndisRxFixup(struct UsbnetAdapter *usbNet, struct sk_buff *skb) /* try to return all the packets in the batch */ skb2 = skb_clone(skb, GFP_ATOMIC); - if (unlikely(!skb2)) + if (unlikely(!skb2)) { break; + } skb_pull(skb, msg_len - sizeof *hdr); skb_trim(skb2, data_len); UsbnetAdapterSkbReturn(usbNet, skb2); @@ -213,12 +216,12 @@ static int rndisRxFixup(struct UsbnetAdapter *usbNet, struct sk_buff *skb) return 1; } -static inline void UsbnetAdapterRxProcess (struct UsbnetAdapter *usbNet, struct sk_buff *skb) +static void UsbnetAdapterRxProcess (struct UsbnetAdapter *usbNet, SkBuff *skb) { HARCH_NET_INFO_PRINT("-------rx before fix"); printf_char_buffer(skb->data, skb->len, false); - if (!rndisRxFixup(usbNet, skb)) { + if (!RndisRxFixup(usbNet, skb)) { /* With RX_ASSEMBLE, rx_fixup() must update counters */ if (!(usbNet->usbnetInfo.usbFlags & FLAG_RX_ASSEMBLE)) usbNet->net->stats.rx_errors++; @@ -249,35 +252,35 @@ done: skb_queue_tail(&usbNet->done, skb); } -static void UsbnetAdapterBh (struct timer_list *t) +static void UsbnetAdapterBh (TimerList *t) { HARCH_NET_INFO_PRINT("begin"); struct UsbnetAdapter *usbNet = from_timer(usbNet, t, delay); - struct sk_buff *skb = NULL; - struct skb_data *entry = NULL; + SkBuff *skb = NULL; + struct SkbData *entry = NULL; while ((skb = skb_dequeue (&usbNet->done))) { - entry = (struct skb_data *) skb->cb; + entry = (struct SkbData *) skb->cb; HARCH_NET_INFO_PRINT("entry->state = %d",entry->state); switch (entry->state) { - case rx_done: - HARCH_NET_INFO_PRINT("rx_done"); - entry->state = rx_cleanup; - UsbnetAdapterRxProcess (usbNet, skb); - continue; - case tx_done: - HARCH_NET_INFO_PRINT("tx_done"); - /* fall-through */ - fallthrough; - case rx_cleanup: - HARCH_NET_INFO_PRINT("rx_cleanup"); - dev_kfree_skb (skb); - continue; - default: - HARCH_NET_INFO_PRINT("bogus skb state %d\n", entry->state); - /* fall-through */ + case RX_DONE: + HARCH_NET_INFO_PRINT("rx_done"); + entry->state = RX_CLEANUP; + UsbnetAdapterRxProcess (usbNet, skb); + continue; + case TX_DONE: + HARCH_NET_INFO_PRINT("tx_done"); + /* fall-through */ + fallthrough; + case RX_CLEANUP: + HARCH_NET_INFO_PRINT("rx_cleanup"); + dev_kfree_skb (skb); + continue; + default: + HARCH_NET_INFO_PRINT("bogus skb state %d\n", entry->state); + /* fall-through */ } } HARCH_NET_INFO_PRINT(); @@ -307,28 +310,28 @@ static void UsbnetAdapterBh (struct timer_list *t) static void UsbnetAdapterBhTasklet(unsigned long data) { HARCH_NET_INFO_PRINT("begin"); - struct timer_list *t = (struct timer_list *)data; + TimerList *t = (TimerList *)data; UsbnetAdapterBh(t); HARCH_NET_INFO_PRINT("end"); } /* The caller must hold list->lock */ -static void UsbnetAdapterQueueSkb(struct sk_buff_head *list, - struct sk_buff *newsk, enum skb_state state) +static void UsbnetAdapterQueueSkb(SkBuff_Head *list, + SkBuff *newsk, enum SkbState state) { - struct skb_data *entry = (struct skb_data *) newsk->cb; + struct SkbData *entry = (struct SkbData *) newsk->cb; __skb_queue_tail(list, newsk); entry->state = state; } -static enum skb_state UsbnetAdapterDeferBh(struct UsbnetAdapter *usbNet, struct sk_buff *skb, - struct sk_buff_head *list, enum skb_state state) +static enum SkbState UsbnetAdapterDeferBh(struct UsbnetAdapter *usbNet, SkBuff *skb, + SkBuff_Head *list, enum SkbState state) { unsigned long flags = 0; - enum skb_state old_state = illegal; - struct skb_data *entry = (struct skb_data *) skb->cb; + enum SkbState old_state = ILLEGAL; + struct SkbData *entry = (struct SkbData *) skb->cb; spin_lock_irqsave(&list->lock, flags); old_state = entry->state; @@ -342,16 +345,16 @@ static enum skb_state UsbnetAdapterDeferBh(struct UsbnetAdapter *usbNet, struct spin_lock_nested(&usbNet->done.lock, SINGLE_DEPTH_NESTING); __skb_queue_tail(&usbNet->done, skb); - if (usbNet->done.qlen == 1) + if (usbNet->done.qlen == 1) { tasklet_schedule(&usbNet->bh); + } spin_unlock(&usbNet->done.lock); spin_unlock_irqrestore(&list->lock, flags); - return old_state; } -int32_t UsbnetAdapterOpen(struct net_device *net) +static int32_t UsbnetAdapterOpen(NetDevice *net) { HARCH_NET_INFO_PRINT("begin"); if (NULL == net) @@ -359,7 +362,7 @@ int32_t UsbnetAdapterOpen(struct net_device *net) HDF_LOGE("net device object is invalid"); return HDF_FAILURE; } - struct UsbnetAdapter *usbNet = netdev_priv(net); + struct UsbnetAdapter *usbNet = netdev_priv(net); if (NULL == usbNet) { HDF_LOGE("usb net adapter object is invalid"); @@ -372,8 +375,8 @@ int32_t UsbnetAdapterOpen(struct net_device *net) /* set device param, if find usb net host need, then it should send to it */ /* reset rx error state */ - usbNet->pkt_cnt = 0; - usbNet->pkt_err = 0; + usbNet->pkt_Cnt = 0; + usbNet->pkt_Err = 0; clear_bit(EVENT_RX_KILL, &usbNet->flags); @@ -381,8 +384,7 @@ int32_t UsbnetAdapterOpen(struct net_device *net) /* need transform usb_net_host change about usbNet->driverInfo->flags and set it on usb_net_host */ OsalMutexLock(&usbNet->sendSkbClock); int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_OPEN_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); - if (ret != HDF_SUCCESS) - { + if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); return HDF_FAILURE; @@ -394,7 +396,7 @@ int32_t UsbnetAdapterOpen(struct net_device *net) return HDF_SUCCESS; } -static void waitSkbQueueEmpty(struct sk_buff_head *q) +static void WaitSkbQueueEmpty(SkBuff_Head *q) { unsigned long flags = 0; HARCH_NET_INFO_PRINT(); @@ -418,31 +420,29 @@ static void UsbnetAdapterTerminateUrbs(struct UsbnetAdapter *usbNet) add_wait_queue(&usbNet->wait, &wait); set_current_state(TASK_UNINTERRUPTIBLE); /* maybe wait for deletions to finish. */ - waitSkbQueueEmpty(&usbNet->rxq); - waitSkbQueueEmpty(&usbNet->txq); + WaitSkbQueueEmpty(&usbNet->rxq); + WaitSkbQueueEmpty(&usbNet->txq); - waitSkbQueueEmpty(&usbNet->done); + WaitSkbQueueEmpty(&usbNet->done); set_current_state(TASK_RUNNING); remove_wait_queue(&usbNet->wait, &wait); } -int32_t UsbnetAdapterStop(struct net_device *net) +static int32_t UsbnetAdapterStop(NetDevice *net) { HARCH_NET_INFO_PRINT("begin"); - if (NULL == net) - { + if (NULL == net) { HDF_LOGE("net device object is invalid"); return HDF_FAILURE; } struct UsbnetAdapter *usbNet = netdev_priv(net); - if (NULL == usbNet) - { + if (NULL == usbNet) { HDF_LOGE("usb net adapter object is invalid"); return HDF_FAILURE; } - struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", stats64->rx_packets, stats64->rx_bytes); @@ -461,7 +461,7 @@ int32_t UsbnetAdapterStop(struct net_device *net) /* 3. pm = usb_autopm_get_interface(dev->intf); do nothing */ /* 4. if (info->stop) { no stop interface impl in rndis driver info */ /* 5. if (!(info->flags & FLAG_AVOID_UNLINK_URBS)) do nothing*/ - if (!(usbNet->usbnetInfo.usbFlags & FLAG_AVOID_UNLINK_URBS)){ + if (!(usbNet->usbnetInfo.usbFlags & FLAG_AVOID_UNLINK_URBS)) { UsbnetAdapterTerminateUrbs(usbNet); } @@ -473,8 +473,7 @@ int32_t UsbnetAdapterStop(struct net_device *net) usbNet->flags = 0; OsalMutexLock(&usbNet->sendSkbClock); int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_CLOSE_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); - if (ret != HDF_SUCCESS) - { + if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); return HDF_FAILURE; @@ -490,24 +489,22 @@ int32_t UsbnetAdapterStop(struct net_device *net) return HDF_SUCCESS; } -struct sk_buff *RndisTxFixup(struct sk_buff *skb, gfp_t flags) +static SkBuff *RndisTxFixup(SkBuff *skb, gfp_t flags) { - struct rndis_data_hdr *hdr = NULL; - struct sk_buff *skb2 = NULL; + RndisDataHdr *hdr = NULL; + SkBuff *skb2 = NULL; unsigned len = skb->len; if (likely(!skb_cloned(skb))) { - int room = skb_headroom(skb); - + int room = skb_headroom(skb); /* enough head room as-is? */ - if (unlikely((sizeof *hdr) <= room)) + if (unlikely((sizeof *hdr) <= room)) { goto fill; - + } /* enough room, but needs to be readjusted? */ room += skb_tailroom(skb); if (likely((sizeof *hdr) <= room)) { - skb->data = memmove(skb->head + sizeof *hdr, - skb->data, len); + skb->data = memmove_s(skb->head + sizeof *hdr, len, skb->data, len); skb_set_tail_pointer(skb, len); goto fill; } @@ -516,8 +513,9 @@ struct sk_buff *RndisTxFixup(struct sk_buff *skb, gfp_t flags) /* create a new skb, with the correct size (and tailpad) */ skb2 = skb_copy_expand(skb, sizeof *hdr, 1, flags); dev_kfree_skb_any(skb); - if (unlikely(!skb2)) + if (unlikely(!skb2)) { return skb2; + } skb = skb2; /* fill out the RNDIS header. we won't bother trying to batch @@ -525,76 +523,71 @@ struct sk_buff *RndisTxFixup(struct sk_buff *skb, gfp_t flags) */ fill: HARCH_NET_INFO_PRINT("%s:%d fill skb by rndis host", __func__, __LINE__); - hdr = __skb_push(skb, sizeof *hdr); - memset(hdr, 0, sizeof *hdr); + hdr = __skb_push(skb, sizeof(*hdr)); + (void)memset_s(hdr, sizeof(*hdr), 0, sizeof(*hdr)); hdr->msg_type = cpu_to_le32(RNDIS_MSG_PACKET); hdr->msg_len = cpu_to_le32(skb->len); unsigned int offset = sizeof(*hdr) - 8; hdr->data_offset = cpu_to_le32(offset); hdr->data_len = cpu_to_le32(len); - - /* FIXME make the last packet always be short ... */ + return skb; } -static void tx_complete(struct work_struct *work) +static void TxComplete(WorkStruct *work) { unsigned long flags = 0; struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, TxCompleteWorkqueue); - struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); - - printk("tx_complete dump_stack start usbNet->usbnetInfo.mtu = %d\n",usbNet->usbnetInfo.mtu); - dump_stack(); - printk("tx_complete dump_stack end\n"); + PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); + HARCH_NET_INFO_PRINT ("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); - HARCH_NET_INFO_PRINT("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); - - HARCH_NET_INFO_PRINT("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + HARCH_NET_INFO_PRINT ("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); flags = u64_stats_update_begin_irqsave(&stats64->syncp); stats64->tx_packets++; - stats64->tx_bytes += usbNet->TxLen; + stats64->tx_bytes += usbNet->txLen; u64_stats_update_end_irqrestore(&stats64->syncp, flags); - HARCH_NET_INFO_PRINT("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + HARCH_NET_INFO_PRINT ("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); - HARCH_NET_INFO_PRINT("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + HARCH_NET_INFO_PRINT ("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); } -netdev_tx_t UsbnetAdapterStartXmit(struct sk_buff *skb, struct net_device *net) +static netdev_tx_t UsbnetAdapterStartXmit(SkBuff *skb, NetDevice *net) { - HARCH_NET_INFO_PRINT("netif_running = %d, netif_device_present = %d" , netif_running (net),netif_device_present (net)); - HARCH_NET_INFO_PRINT("netif_carrier_ok = %d" , netif_carrier_ok (net)); + HARCH_NET_INFO_PRINT ("netif_running = %d, netif_device_present = %d", netif_running (net), netif_device_present (net)); + HARCH_NET_INFO_PRINT ("netif_carrier_ok = %d", netif_carrier_ok (net)); /* print org skb data info */ - HARCH_NET_INFO_PRINT("UsbnetAdapterStartXmit skb->data = %x, len = %d",skb->data, skb->len); + HARCH_NET_INFO_PRINT ("UsbnetAdapterStartXmit skb->data = %x, len = %d", skb->data, skb->len); printf_char_buffer(skb->data, skb->len, false); struct UsbnetAdapter *usbNet = netdev_priv(net); //1.time tamp - if (skb) + if (skb) { skb_tx_timestamp(skb); + } //2.fix up - struct sk_buff* skb_fixup = NULL; + SkBuff* skbFixup = NULL; /* rndis fixup sk_buf */ - skb_fixup = RndisTxFixup(skb, GFP_ATOMIC); - if (NULL == skb_fixup) + skbFixup = RndisTxFixup(skb, GFP_ATOMIC); + if (NULL == skbFixup) { - if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET){ + if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) { goto not_drop; } HDF_LOGE("fail to tx fixup by rndis host"); goto drop; } - HARCH_NET_INFO_PRINT("UsbnetAdapterStartXmit skb_fixup->data = %x, len = %d",skb_fixup->data, skb_fixup->len); + HARCH_NET_INFO_PRINT("UsbnetAdapterStartXmit skb_fixup->data = %x, len = %d",skbFixup->data, skbFixup->len); /* print org skb data info */ - printf_char_buffer(skb_fixup->data, skb_fixup->len, false); + printf_char_buffer(skbFixup->data, skbFixup->len, false); //3.send to usb // send msg to usb @@ -605,33 +598,31 @@ netdev_tx_t UsbnetAdapterStartXmit(struct sk_buff *skb, struct net_device *net) } int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_SEND_DATA_TO_USB, - (unsigned char *)(skb_fixup->data), skb_fixup->len); - + (unsigned char *)(skbFixup->data), skbFixup->len); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetHost SendEvent!"); drop: net->stats.tx_dropped++; not_drop: spin_unlock_irqrestore(&usbNet->txq.lock, flags); - if (skb_fixup) { - dev_kfree_skb_any (skb_fixup); + if (skbFixup) { + dev_kfree_skb_any (skbFixup); } } else { netif_trans_update(usbNet->net); - UsbnetAdapterQueueSkb(&usbNet->txq, skb_fixup, tx_start); + UsbnetAdapterQueueSkb(&usbNet->txq, skbFixup, TX_START); - if (usbNet->txq.qlen >= TX_QLEN (usbNet)) - { - HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",usbNet->txq.qlen,TX_QLEN (usbNet)); + if (usbNet->txq.qlen >= TX_QLEN (usbNet)) { + HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d", usbNet->txq.qlen, TX_QLEN (usbNet)); netif_stop_queue (usbNet->net); } spin_unlock_irqrestore(&usbNet->txq.lock, flags); - usbNet->TxLen = skb_fixup->len; - schedule_work_on(0,&usbNet->TxCompleteWorkqueue); + usbNet->txLen = skbFixup->len; + schedule_work_on(0, &usbNet->TxCompleteWorkqueue); - enum skb_state state = UsbnetAdapterDeferBh(usbNet, skb_fixup, &usbNet->txq, tx_done); + enum SkbState state = UsbnetAdapterDeferBh(usbNet, skbFixup, &usbNet->txq, TX_DONE); HARCH_NET_INFO_PRINT("state= %d", state); HARCH_NET_INFO_PRINT("========print tosend skb data info========"); @@ -639,7 +630,7 @@ not_drop: return NETDEV_TX_OK; } -static void UsbnetAdapterTXTimeout(struct net_device *net, unsigned int txqueue) +static void UsbnetAdapterTXTimeout(NetDevice *net, unsigned int txqueue) { //send to device HARCH_NET_INFO_PRINT("begin"); @@ -667,7 +658,7 @@ static void UsbnetAdapterTXTimeout(struct net_device *net, unsigned int txqueue) * NOTE: annoying asymmetry: if it's active, schedule_work() fails, * but tasklet_schedule() doesn't. hope the failure is rare. */ -void UsbnetAdapter_defer_kevent (struct UsbnetAdapter *usbNet, int work) +void UsbnetAdapterDeferKevent (struct UsbnetAdapter *usbNet, int work) { HARCH_NET_INFO_PRINT("begin"); if ( NULL == usbNet) { @@ -677,27 +668,28 @@ void UsbnetAdapter_defer_kevent (struct UsbnetAdapter *usbNet, int work) set_bit (work, &usbNet->flags); /* need update flags to usb_net_host */ OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); - if (ret != HDF_SUCCESS) - { + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, + (const void *)&usbNet->flags, sizeof(usbNet->flags)); + if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); return; } OsalMutexUnlock(&usbNet->sendSkbClock); - if (!schedule_work (&usbNet->kevent)) + if (!schedule_work (&usbNet->kevent)) { HARCH_NET_INFO_PRINT("kevent %d may have been dropped\n", work); - else + } else { HARCH_NET_INFO_PRINT("kevent %d scheduled\n", work); + } } -void UsbnetAdapterSetRxMode(struct net_device *net) +void UsbnetAdapterSetRxMode(NetDevice *net) { return; } -void UsbnetAdapter_pause_rx(struct UsbnetAdapter *usbNet) +void UsbnetAdapterPauseRx(struct UsbnetAdapter *usbNet) { HARCH_NET_INFO_PRINT("begin"); if ( NULL == usbNet) { @@ -719,7 +711,7 @@ void UsbnetAdapter_pause_rx(struct UsbnetAdapter *usbNet) HARCH_NET_INFO_PRINT("paused rx queue enabled\n"); } -void UsbnetAdapter_unlink_rx_urbs(struct UsbnetAdapter *usbNet) +static void UsbnetAdapterUnlinkRxUrbs(struct UsbnetAdapter *usbNet) { HARCH_NET_INFO_PRINT("begin"); if ( NULL == usbNet) { @@ -733,11 +725,11 @@ void UsbnetAdapter_unlink_rx_urbs(struct UsbnetAdapter *usbNet) } } -void UsbnetAdapter_resume_rx(struct UsbnetAdapter *usbNet) +static void UsbnetAdapterResumeRx(struct UsbnetAdapter *usbNet) { HARCH_NET_INFO_PRINT("begin"); int num = 0; - struct sk_buff *skb = NULL; + SkBuff *skb = NULL; if ( NULL == usbNet) { HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); return; @@ -746,9 +738,9 @@ void UsbnetAdapter_resume_rx(struct UsbnetAdapter *usbNet) clear_bit(EVENT_RX_PAUSED, &usbNet->flags); /* need update flags to usb_net_host */ OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); - if (ret != HDF_SUCCESS) - { + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, + (const void *)&usbNet->flags, sizeof(usbNet->flags)); + if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); return; @@ -765,7 +757,7 @@ void UsbnetAdapter_resume_rx(struct UsbnetAdapter *usbNet) } -int32_t UsbnetAdapterChangeMtu(struct net_device *net, int newMtu) +int32_t UsbnetAdapterChangeMtu(NetDevice *net, int newMtu) { //send to device HARCH_NET_INFO_PRINT("begin"); @@ -782,12 +774,12 @@ int32_t UsbnetAdapterChangeMtu(struct net_device *net, int newMtu) /* 1. ll_mtu old_hard_mtu old_rx_urb_size */ HARCH_NET_INFO_PRINT("newMtu:%d", newMtu); - int ll_mtu = newMtu + net->hard_header_len; - int old_hard_mtu = usbNet->usbnetInfo.hardMtu; - int old_rx_urb_size = usbNet->usbnetInfo.rxUrbSize; + int ll_Mtu = newMtu + net->hard_header_len; + int oldHardMtu = usbNet->usbnetInfo.hardMtu; + int oldRxUrbSize = usbNet->usbnetInfo.rxUrbSize; /* 2. no second zero-length packet read wanted after mtu-sized packets */ - if ((ll_mtu % usbNet->usbnetInfo.maxpacket) == 0) { + if ((ll_Mtu % usbNet->usbnetInfo.maxpacket) == 0) { HARCH_NET_INFO_PRINT(""); return -EDOM; } @@ -797,28 +789,26 @@ int32_t UsbnetAdapterChangeMtu(struct net_device *net, int newMtu) usbNet->usbnetInfo.hardMtu = net->mtu + net->hard_header_len; /* 4. pause and resume usbnet */ - if (usbNet->usbnetInfo.rxUrbSize == old_hard_mtu) { + if (usbNet->usbnetInfo.rxUrbSize == oldHardMtu) { usbNet->usbnetInfo.rxUrbSize = usbNet->usbnetInfo.hardMtu; - if (usbNet->usbnetInfo.rxUrbSize > old_rx_urb_size) { - UsbnetAdapter_pause_rx(usbNet); - UsbnetAdapter_unlink_rx_urbs(usbNet); - UsbnetAdapter_resume_rx(usbNet); + if (usbNet->usbnetInfo.rxUrbSize > oldRxUrbSize) { + UsbnetAdapterPauseRx(usbNet); + UsbnetAdapterUnlinkRxUrbs(usbNet); + UsbnetAdapterResumeRx(usbNet); } } /* need transmit hard_mtu to usb net host, UsbnetHostUpdateMaxQlen need this param */ HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x mtu = %d, hardHeaderLen = %d, link = %d needReset = %d, hardMtu = %d, rxUrbSize = %d, maxpacket =%d", - usbNet->usbnetInfo.name,usbNet->usbnetInfo.flags, usbNet->usbnetInfo.usbFlags, - usbNet->usbnetInfo.mtu, usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, - usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu, usbNet->usbnetInfo.rxUrbSize, - usbNet->usbnetInfo.maxpacket - ); + usbNet->usbnetInfo.name,usbNet->usbnetInfo.flags, usbNet->usbnetInfo.usbFlags,usbNet->usbnetInfo.mtu, + usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link,usbNet->usbnetInfo.needReset, + usbNet->usbnetInfo.hardMtu, usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket); /* 5. max qlen depend on hard_mtu and rx_urb_size */ /* need update flags to usb_net_host */ OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_MAXQLEN, (const void *)&usbNet->usbnetInfo, sizeof(usbNet->usbnetInfo)); - if (ret != HDF_SUCCESS) - { + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_MAXQLEN, + (const void *)&usbNet->usbnetInfo, sizeof(usbNet->usbnetInfo)); + if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); return ret; @@ -827,7 +817,7 @@ int32_t UsbnetAdapterChangeMtu(struct net_device *net, int newMtu) return HDF_SUCCESS; } -void UsbnetAdapterGetStats64(struct net_device *net, struct rtnl_link_stats64 *stats) +static void UsbnetAdapterGetStats64 (NetDevice *net, struct rtnl_link_stats64 *stats) { //send to device HARCH_NET_INFO_PRINT("begin"); @@ -836,43 +826,43 @@ void UsbnetAdapterGetStats64(struct net_device *net, struct rtnl_link_stats64 * netdev_stats_to_stats64(stats, &net->stats); dev_fetch_sw_netstats(stats, usbNet->stats64); - struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); - HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + HARCH_NET_INFO_PRINT ("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); - HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + HARCH_NET_INFO_PRINT ("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", + stats64->tx_packets,stats64->tx_bytes); HARCH_NET_INFO_PRINT("end"); - return; } -static struct net_device_ops g_UsbnetAdapterDeviceOps = { - .ndo_open = UsbnetAdapterOpen, - .ndo_stop = UsbnetAdapterStop, - .ndo_start_xmit = UsbnetAdapterStartXmit, - .ndo_tx_timeout = UsbnetAdapterTXTimeout, - .ndo_set_rx_mode = UsbnetAdapterSetRxMode, - .ndo_change_mtu = UsbnetAdapterChangeMtu, - .ndo_get_stats64 = UsbnetAdapterGetStats64, - .ndo_set_mac_address = eth_mac_addr, - .ndo_validate_addr = eth_validate_addr, +static NetDevice_Ops g_UsbnetAdapterDeviceOps = { + .ndo_open = UsbnetAdapterOpen, + .ndo_stop = UsbnetAdapterStop, + .ndo_start_xmit = UsbnetAdapterStartXmit, + .ndo_tx_timeout = UsbnetAdapterTXTimeout, + .ndo_set_rx_mode = UsbnetAdapterSetRxMode, + .ndo_change_mtu = UsbnetAdapterChangeMtu, + .ndo_get_stats64 = UsbnetAdapterGetStats64, + .ndo_set_mac_address = eth_mac_addr, + .ndo_validate_addr = eth_validate_addr, }; /* drivers may override default ethtool_ops in their bind() routine */ -static const struct ethtool_ops g_UsbnetAdapterEthtoolOps = { +static const EthtoolOps g_UsbnetAdapterEthtoolOps = { }; void UsbnetAdapterLinkChange(struct UsbnetAdapter *usbNet, bool link, bool need_reset) { HARCH_NET_INFO_PRINT("begin"); /* update link after link is reseted */ - if (link && !need_reset) + if (link && !need_reset) { netif_carrier_on(usbNet->net); - else + } else { netif_carrier_off(usbNet->net); + } } static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct HdfSBuf *data, gfp_t flags) @@ -887,38 +877,35 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag); return HDF_ERR_INVALID_PARAM; } - - HARCH_NET_INFO_PRINT("infoSize= %d", infoSize); - struct net_device *net = (struct net_device *)device->priv; - if (net == NULL) + + NetDevice *net = (NetDevice *)device->priv; + if (net == NULL) { return HDF_ERR_INVALID_PARAM; - - HARCH_NET_INFO_PRINT("recv msg buff"); + } printf_char_buffer(buff, infoSize, false); - - struct UsbnetAdapter *usbNet = netdev_priv(net); - if (usbNet == NULL) + if (usbNet == NULL) { return HDF_ERR_INVALID_PARAM; - - struct sk_buff *skb = NULL; - struct skb_data *entry = NULL; + } + SkBuff *skb = NULL; + struct SkbData *entry = NULL; uint32_t skb_size = sizeof(struct iphdr) + sizeof(struct udphdr) + infoSize; - size_t size = (skb_size > usbNet->usbnetInfo.rxUrbSize ? usbNet->usbnetInfo.rxUrbSize : skb_size ); - HARCH_NET_INFO_PRINT("size = %d", size); + size_t size = skb_size > usbNet->usbnetInfo.rxUrbSize ? usbNet->usbnetInfo.rxUrbSize : skb_size; + HARCH_NET_INFO_PRINT("infoSize= %d, size = %d", infoSize, size); - if (test_bit(EVENT_NO_IP_ALIGN, &usbNet->flags)) + if (test_bit(EVENT_NO_IP_ALIGN, &usbNet->flags)) { skb = __netdev_alloc_skb(usbNet->net, size, flags); - else + } else { skb = __netdev_alloc_skb_ip_align(usbNet->net, size, flags); - + } + if (!skb) { HARCH_NET_INFO_PRINT("no rx skb\n"); - UsbnetAdapter_defer_kevent(usbNet, EVENT_RX_MEMORY); + UsbnetAdapterDeferKevent(usbNet, EVENT_RX_MEMORY); return HDF_DEV_ERR_NO_MEMORY; } - entry = (struct skb_data *) skb->cb; + entry = (struct SkbData *) skb->cb; entry->length = 0; skb_put (skb, infoSize); if (memcpy_s(skb->data, infoSize, buff, infoSize) != EOK) { @@ -926,53 +913,49 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd return HDF_ERR_INVALID_PARAM; } - HARCH_NET_INFO_PRINT("skb->len = %d",skb->len); - HARCH_NET_INFO_PRINT("recv msg skbBuff"); + HARCH_NET_INFO_PRINT("skb->len = %d", skb->len); printf_char_buffer(skb->data, skb->len, false); - - // success recv + //success recv unsigned long lockflags = 0; spin_lock_irqsave (&usbNet->rxq.lock, lockflags); - UsbnetAdapterQueueSkb(&usbNet->rxq, skb, rx_start); + UsbnetAdapterQueueSkb(&usbNet->rxq, skb, RX_START); spin_unlock_irqrestore (&usbNet->rxq.lock, lockflags); - struct pcpu_sw_netstats *stats64 = this_cpu_ptr(usbNet->stats64); + PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); - - // rx complete - enum skb_state state = rx_done; - /* stop rx if packet error rate is high */ - if (++usbNet->pkt_cnt > PKT_COUNT_CLEAR) { - HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); - usbNet->pkt_cnt = 0; - usbNet->pkt_err = 0; + stats64->rx_packets, stats64->rx_bytes); + + enum SkbState state = RX_DONE; + if (++usbNet->pkt_Cnt > PKT_COUNT_CLEAR) { + HARCH_NET_INFO_PRINT("usbNet->pkt_Cnt = %d, pkt_Err = %d", usbNet->pkt_Cnt, usbNet->pkt_Err); + usbNet->pkt_Cnt = 0; + usbNet->pkt_Err = 0; } else { - HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); - if (state == rx_cleanup) - usbNet->pkt_err++; + HARCH_NET_INFO_PRINT("usbNet->pkt_Cnt = %d,pkt_Err = %d", usbNet->pkt_Cnt, usbNet->pkt_Err); + if (state == RX_CLEANUP) { + usbNet->pkt_Err++; + } - if (usbNet->pkt_err > PKT_COUNT_RXKILL) + if (usbNet->pkt_Err > PKT_COUNT_RXKILL) { set_bit(EVENT_RX_KILL, &usbNet->flags); + } } - HARCH_NET_INFO_PRINT("usbNet->pkt_cnt = %d,pkt_err = %d",usbNet->pkt_cnt,usbNet->pkt_err); + state = UsbnetAdapterDeferBh(usbNet, skb, &usbNet->rxq, state); - HARCH_NET_INFO_PRINT("state= %d", state); - - HARCH_NET_INFO_PRINT("end"); + HARCH_NET_INFO_PRINT("usbNet->pkt_Cnt = %d, pkt_Err = %d, state = %d",usbNet->pkt_Cnt, usbNet->pkt_Err, state); return HDF_SUCCESS; } // precondition: never called in_interrupt -static struct device_type wlanType = { +static DeviceType wlanType = { .name = "wlan", }; -static struct device_type wwanType = { +static DeviceType wwanType = { .name = "wwan", }; -int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) +static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) { HARCH_NET_INFO_PRINT("begin"); int ret = HDF_SUCCESS; @@ -986,7 +969,7 @@ int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) return ret; } - struct net_device *net = alloc_etherdev(sizeof(struct UsbnetAdapter)); + NetDevice *net = alloc_etherdev(sizeof(struct UsbnetAdapter)); if (net == NULL) { HARCH_NET_INFO_PRINT(); goto out; @@ -999,37 +982,25 @@ int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) //info from usb if (memcpy_s(&(usbNet->usbnetInfo), sizeof(struct UsbnetTransInfo), - uNetTransInfo, sizeof(struct UsbnetTransInfo)) != EOK) { + uNetTransInfo, sizeof(struct UsbnetTransInfo)) != EOK) { HARCH_NET_INFO_PRINT("memcpy_s error "); goto out0; } - HARCH_NET_INFO_PRINT("name = %s, \ - flags = %d, \ - usbFlags = %x, \ - mtu = %d, \ - hardHeaderLen = %d, \ - link = %d, \ - needReset = %d, \ - hardMtu = %d, \ - rxUrbSize = %d, \ - maxpacket = %d", - usbNet->usbnetInfo.name, - usbNet->usbnetInfo.flags, - usbNet->usbnetInfo.usbFlags, - usbNet->usbnetInfo.mtu, - usbNet->usbnetInfo.hardHeaderLen, - usbNet->usbnetInfo.link, - usbNet->usbnetInfo.needReset, - usbNet->usbnetInfo.hardMtu, - usbNet->usbnetInfo.rxUrbSize, - usbNet->usbnetInfo.maxpacket); + HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x, mtu = %d, \ + hardHeaderLen = %d, link = %d, needReset = %d, \ + hardMtu = %d, rxUrbSize = %d, maxpacket = %d", + usbNet->usbnetInfo.name, usbNet->usbnetInfo.flags, + usbNet->usbnetInfo.usbFlags, usbNet->usbnetInfo.mtu, + usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, + usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu, + usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket); - usbNet->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); + usbNet->stats64 = netdev_alloc_pcpu_stats(PcpuSwNetstats); if (!usbNet->stats64) goto out0; - usbNet->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV + usbNet->msg_enable = netif_msg_init (g_msgLevel, NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK| NETIF_MSG_RX_ERR|NETIF_MSG_TX_ERR); OsalMutexInit(&usbNet->sendSkbClock); @@ -1041,27 +1012,25 @@ int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) skb_queue_head_init(&usbNet->rxq_pause); // init work for tx_complete rx_complete - INIT_WORK(&usbNet->TxCompleteWorkqueue, tx_complete); - INIT_WORK(&usbNet->RxCompleteWorkqueue, rx_complete); + INIT_WORK(&usbNet->TxCompleteWorkqueue, TxComplete); + INIT_WORK(&usbNet->RxCompleteWorkqueue, RxComplete); usbNet->bh.func = (void (*)(unsigned long))UsbnetAdapterBhTasklet; - usbNet->bh.data = (unsigned long)&usbNet->delay; //struct timer_list delay; + usbNet->bh.data = (unsigned long)&usbNet->delay; //TimerList delay; timer_setup(&usbNet->delay, UsbnetAdapterBh, 0); usbNet->net = net; // 1.addr static u8 node_id[ETH_ALEN]; - if (usbNet->usbnetInfo.isGetmacAddr) - { + if (usbNet->usbnetInfo.isGetmacAddr) { if (memcpy_s(node_id, ETH_ALEN, usbNet->usbnetInfo.macAddr, ETH_ALEN) != EOK) { goto out0; } - }else - { + } else { eth_random_addr(node_id); } - memcpy(net->dev_addr, node_id, sizeof(node_id)); + memcpy_s(net->dev_addr, sizeof(node_id), node_id, sizeof(node_id)); HARCH_NET_INFO_PRINT("macAddr addr %pM", net->dev_addr); // 2. mtu @@ -1073,7 +1042,7 @@ int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) net->ethtool_ops = &g_UsbnetAdapterEthtoolOps; //3. name and mtu - strcpy (net->name, "usb%d"); + strcpy_s (net->name, sizeof(net->name)/sizeof(net->name[0]), "usb%d"); if (usbNet->usbnetInfo.isBindDevice) { /* heuristic: "usb%d" for links we know are two-host, @@ -1085,20 +1054,20 @@ int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) (net->dev_addr[0] & 0x02) == 0)) { HARCH_NET_INFO_PRINT(); - strcpy (net->name, "eth%d"); + strcpy_s (net->name, sizeof(net->name)/sizeof(net->name[0]), "eth%d"); } /* WLAN devices should always be named "wlan%d" */ if ((usbNet->usbnetInfo.usbFlags & FLAG_WLAN) != 0) { HARCH_NET_INFO_PRINT(); - strcpy(net->name, "wlan%d"); + strcpy_s(net->name, sizeof(net->name)/sizeof(net->name[0]), "wlan%d"); } /* WWAN devices should always be named "wwan%d" */ if ((usbNet->usbnetInfo.usbFlags & FLAG_WWAN) != 0) { HARCH_NET_INFO_PRINT(); - strcpy(net->name, "wwan%d"); + strcpy_s(net->name, sizeof(net->name)/sizeof(net->name[0]), "wwan%d"); } /* devices that cannot do ARP */ @@ -1127,17 +1096,14 @@ int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) SET_NETDEV_DEVTYPE(net, &wwanType); ret = register_netdev(net); - if (ret) + if (ret) { goto out0; - + } HARCH_NET_INFO_PRINT( "register net %pM\n", net->dev_addr); - netif_device_attach(net); - HARCH_NET_INFO_PRINT( "netif_device_attach net %pM\n", net->dev_addr); - if (usbNet->usbnetInfo.usbFlags & FLAG_LINK_INTR) - { + if (usbNet->usbnetInfo.usbFlags & FLAG_LINK_INTR) { HARCH_NET_INFO_PRINT(); UsbnetAdapterLinkChange(usbNet, 0, 0); } @@ -1160,7 +1126,7 @@ static int32_t UsbnetAdapterDisconnect(struct HdfDeviceObject *device) } //free net - struct net_device *net = (struct net_device *)device->priv; + NetDevice *net = (NetDevice *)device->priv; unregister_netdev (net); struct UsbnetAdapter *usbNet = netdev_priv(net); @@ -1183,23 +1149,16 @@ static int32_t UsbnetAdapterDispatch( HARCH_NET_INFO_PRINT("begin, received cmd = %d", cmd); int32_t ret = HDF_ERR_INVALID_PARAM; - switch (cmd) - { + switch (cmd) { case USB_NET_REGISTER_NET: - { //add new usbnet device ret = UsbnetAdapterProbe(client->device, data); - } break; case USB_NET_CLOSE_NET: - { ret = UsbnetAdapterDisconnect(client->device); - } - break; + break; case USB_NET_RECIVE_DATA_FROM_USB: - { ret = UsbnetAdapterRxComplete(client->device, data, GFP_ATOMIC); - } break; default: HDF_LOGI("%s: no this cmd: %d", __func__, cmd); -- Gitee From 982c158976f563d8acf746cc1bd8cd04c201d445 Mon Sep 17 00:00:00 2001 From: n028372 Date: Thu, 18 Jan 2024 10:41:49 +0800 Subject: [PATCH 5/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: n028372 --- .../model/usb/host/include/usb_net_adapter.h | 20 +- .../model/usb/host/src/usb_net_adapter.c | 386 +++++++++--------- .../model/usb/include/hdf_usb_net_manager.h | 18 +- 3 files changed, 212 insertions(+), 212 deletions(-) diff --git a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h index e84270fb7..1e1620605 100755 --- a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h +++ b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Copyright (c) 2024 Archermind Technology (Nanjing) Co. Ltd. * * HDF is dual licensed: you can use it either under the terms of * the GPL, or the BSD license, at your option. @@ -13,13 +13,13 @@ #include "hdf_log.h" #include "hdf_usb_net_manager.h" -#define ModuleParam module_param +#define MODULE_PARAM module_param #define HARCH_LOG_TAG "[-net-hdf-]" -#define HARCH_NET_INFO_PRINT(fmt,...)\ -do{ \ - if(1){\ - HDF_LOGI(HARCH_LOG_TAG"[%{public}s][%{public}d]:" fmt "\n",__FUNCTION__, __LINE__, ##__VA_ARGS__);}\ -}while(0) +#define HARCH_NET_INFO_PRINT(fmt, ...) \ +do { \ + if(1){ \ + HDF_LOGI(HARCH_LOG_TAG"[%{public}s][%{public}d]:" fmt "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__);} \ +} while(0) typedef struct pcpu_sw_netstats PcpuSwNetstats; typedef struct net_device NetDevice; @@ -49,16 +49,16 @@ struct rndis_data_hdr { __le32 reserved; /* zero */ } __attribute__ ((packed)); -struct UsbnetAdapter{ +struct UsbnetAdapter { struct IDeviceIoService service; struct HdfDeviceObject *deviceObject; - unsigned canDmaSg:1; + unsigned canDmaSg: 1; NetDevice *net; int32_t msg_enable; struct UsbnetTransInfo usbnetInfo; struct OsalMutex sendSkbClock; - unsigned char pkt_Cnt, pkt_Err; + unsigned char pktCnt, pktErr; /* various kinds of pending driver work */ wait_queue_head_t wait; diff --git a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c index d17ee8a9a..6bcf2ad53 100755 --- a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c +++ b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2024 Archermind Technology (Nanjing) Co. Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -25,7 +25,7 @@ #include #endif -#include +#include #include #include "osal_mem.h" #include "securec.h" @@ -39,28 +39,26 @@ // between wakeups #define UNLINK_TIMEOUT_MS 3 -#define TX_QLEN(dev) ((dev)->usbnetInfo.txQlen) - #define PKT_COUNT_CLEAR 30 #define PKT_COUNT_RXKILL 20 #define SHIFT_LINE_NUM 32 /* use ethtool to change the level for any given device */ static int g_msgLevel = -1; -module_param (g_msgLevel, int, 0); -MODULE_PARM_DESC (g_msgLevel, "Override default message level"); +MODULE_PARAM(g_msgLevel, int, 0); +MODULE_PARM_DESC(g_msgLevel, "Override default message level"); -static int printf_char_buffer(char *buff, int size, bool isPrint) -{ - if (isPrint) - { +static inline int UsbnetAdapterGetTxQlen(struct UsbnetAdapter *usbNet) { + return usbNet->usbnetInfo.txQlen; +} + +static int printf_char_buffer(char *buff, int size, bool isPrint) { + if (isPrint) { int i = 0; printk("===-harch-=== printf_char_buffer begin\n"); - for (i = 0; i < size; i++) - { + for (i = 0; i < size; i++) { printk(KERN_CONT"%02x ", buff[i]); - if ((i + 1) % SHIFT_LINE_NUM == 0) - { + if ((i + 1) % SHIFT_LINE_NUM == 0) { printk(KERN_CONT"\n"); } } @@ -69,10 +67,10 @@ static int printf_char_buffer(char *buff, int size, bool isPrint) return 0; } -int32_t UsbnetAdapterSendBufToUsb(const struct HdfDeviceObject *device, uint32_t id, - const void *buf, uint32_t writeSize) +static int32_t UsbnetAdapterSendBufToUsb(const struct HdfDeviceObject *device, uint32_t id, + const void *buf, uint32_t writeSize) { - HARCH_NET_INFO_PRINT ("writeSize=%d", writeSize); + HARCH_NET_INFO_PRINT("writeSize=%d", writeSize); int32_t ret = HDF_SUCCESS; if ((device == NULL) || (buf == NULL)) { HDF_LOGE("%s param is null", __func__); @@ -103,8 +101,7 @@ out: return ret; } - -static void RxComplete (WorkStruct *work) { +static void RxComplete(WorkStruct *work) { unsigned long flags = 0; struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, RxCompleteWorkqueue); @@ -114,7 +111,7 @@ static void RxComplete (WorkStruct *work) { stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + stats64->tx_packets, stats64->tx_bytes); flags = u64_stats_update_begin_irqsave(&stats64->syncp); stats64->rx_packets++; @@ -122,18 +119,18 @@ static void RxComplete (WorkStruct *work) { u64_stats_update_end_irqrestore(&stats64->syncp, flags); HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + stats64->tx_packets,stats64->tx_bytes); } /* Passes this packet up the stack, updating its accounting. * Some link protocols batch packets, so their rx_fixup paths * can return clones as well as just modify the original skb. */ -static void UsbnetAdapterSkbReturn (struct UsbnetAdapter *usbNet, SkBuff *skb) -{ +static void UsbnetAdapterSkbReturn(struct UsbnetAdapter *usbNet, SkBuff *skb) +{ if (test_bit(EVENT_RX_PAUSED, &usbNet->flags)) { skb_queue_tail(&usbNet->rxq_pause, skb); return; @@ -176,30 +173,32 @@ static int RndisRxFixup(struct UsbnetAdapter *usbNet, SkBuff *skb) } /* peripheral may have batched packets to us... */ while (likely(skb->len)) { - RndisDataHdr *hdr = (void *)skb->data; - SkBuff *skb2; - u32 msg_type, msg_len, data_offset, data_len; + RndisDataHdr *hdr = (void *)skb->data; + SkBuff *skb2 = NULL; + u32 msg_type = 0; + u32 msg_len = 0; + u32 data_len = 0; + u32 data_offset = 0; msg_type = le32_to_cpu(hdr->msg_type); msg_len = le32_to_cpu(hdr->msg_len); data_offset = le32_to_cpu(hdr->data_offset); data_len = le32_to_cpu(hdr->data_len); - unsigned int total_len = data_offset + data_len + 8; + unsigned int totalLen = data_offset + data_len + 8; /* don't choke if we see oob, per-packet data, etc */ if (unlikely(msg_type != RNDIS_MSG_PACKET || skb->len < msg_len - || total_len > msg_len)) { + || totalLen > msg_len)) { usbNet->net->stats.rx_frame_errors++; netdev_dbg(usbNet->net, "bad rndis message %d/%d/%d/%d, len %d\n", - le32_to_cpu(hdr->msg_type), - msg_len, data_offset, data_len, skb->len); + le32_to_cpu(hdr->msg_type), msg_len, data_offset, data_len, skb->len); return 0; } unsigned int offset = 8 + data_offset; skb_pull(skb, offset); /* at most one packet left? */ - if (likely((data_len - skb->len) <= sizeof *hdr)) { + if (likely((data_len - skb->len) <= sizeof(RndisDataHdr))) { skb_trim(skb, data_len); break; } @@ -209,22 +208,23 @@ static int RndisRxFixup(struct UsbnetAdapter *usbNet, SkBuff *skb) if (unlikely(!skb2)) { break; } - skb_pull(skb, msg_len - sizeof *hdr); + skb_pull(skb, msg_len - sizeof(RndisDataHdr)); skb_trim(skb2, data_len); UsbnetAdapterSkbReturn(usbNet, skb2); } return 1; } -static void UsbnetAdapterRxProcess (struct UsbnetAdapter *usbNet, SkBuff *skb) +static void UsbnetAdapterRxProcess(struct UsbnetAdapter *usbNet, SkBuff *skb) { HARCH_NET_INFO_PRINT("-------rx before fix"); printf_char_buffer(skb->data, skb->len, false); if (!RndisRxFixup(usbNet, skb)) { /* With RX_ASSEMBLE, rx_fixup() must update counters */ - if (!(usbNet->usbnetInfo.usbFlags & FLAG_RX_ASSEMBLE)) + if (!(usbNet->usbnetInfo.usbFlags & FLAG_RX_ASSEMBLE)) { usbNet->net->stats.rx_errors++; + } goto done; } // else network stack removes extra byte if we forced a short packet @@ -232,8 +232,7 @@ static void UsbnetAdapterRxProcess (struct UsbnetAdapter *usbNet, SkBuff *skb) printf_char_buffer(skb->data, skb->len, false); /* all data was already cloned from skb inside the driver */ - if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) - { + if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) { HARCH_NET_INFO_PRINT("usbNet->driver_info->flags = %d",usbNet->usbnetInfo.usbFlags); goto done; } @@ -252,7 +251,7 @@ done: skb_queue_tail(&usbNet->done, skb); } -static void UsbnetAdapterBh (TimerList *t) +static void UsbnetAdapterBh(TimerList *t) { HARCH_NET_INFO_PRINT("begin"); struct UsbnetAdapter *usbNet = from_timer(usbNet, t, delay); @@ -262,10 +261,10 @@ static void UsbnetAdapterBh (TimerList *t) while ((skb = skb_dequeue (&usbNet->done))) { entry = (struct SkbData *) skb->cb; - HARCH_NET_INFO_PRINT("entry->state = %d",entry->state); + HARCH_NET_INFO_PRINT("entry->state = %d", entry->state); switch (entry->state) { - case RX_DONE: + case RX_DONE: HARCH_NET_INFO_PRINT("rx_done"); entry->state = RX_CLEANUP; UsbnetAdapterRxProcess (usbNet, skb); @@ -299,10 +298,9 @@ static void UsbnetAdapterBh (TimerList *t) } } - if (usbNet->txq.qlen < TX_QLEN (usbNet)) - { + if (usbNet->txq.qlen < UsbnetAdapterGetTxQlen(usbNet)) { netif_wake_queue (usbNet->net); - HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",usbNet->txq.qlen,TX_QLEN (usbNet)); + HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",usbNet->txq.qlen,UsbnetAdapterGetTxQlen(usbNet)); } HARCH_NET_INFO_PRINT("end"); } @@ -318,7 +316,7 @@ static void UsbnetAdapterBhTasklet(unsigned long data) /* The caller must hold list->lock */ static void UsbnetAdapterQueueSkb(SkBuff_Head *list, - SkBuff *newsk, enum SkbState state) + SkBuff *newsk, enum SkbState state) { struct SkbData *entry = (struct SkbData *) newsk->cb; @@ -327,7 +325,7 @@ static void UsbnetAdapterQueueSkb(SkBuff_Head *list, } static enum SkbState UsbnetAdapterDeferBh(struct UsbnetAdapter *usbNet, SkBuff *skb, - SkBuff_Head *list, enum SkbState state) + SkBuff_Head *list, enum SkbState state) { unsigned long flags = 0; enum SkbState old_state = ILLEGAL; @@ -357,14 +355,12 @@ static enum SkbState UsbnetAdapterDeferBh(struct UsbnetAdapter *usbNet, SkBuff * static int32_t UsbnetAdapterOpen(NetDevice *net) { HARCH_NET_INFO_PRINT("begin"); - if (NULL == net) - { + if (NULL == net) { HDF_LOGE("net device object is invalid"); return HDF_FAILURE; } struct UsbnetAdapter *usbNet = netdev_priv(net); - if (NULL == usbNet) - { + if (NULL == usbNet) { HDF_LOGE("usb net adapter object is invalid"); return HDF_FAILURE; } @@ -375,15 +371,15 @@ static int32_t UsbnetAdapterOpen(NetDevice *net) /* set device param, if find usb net host need, then it should send to it */ /* reset rx error state */ - usbNet->pkt_Cnt = 0; - usbNet->pkt_Err = 0; - + usbNet->pktCnt = 0; + usbNet->pktErr = 0; clear_bit(EVENT_RX_KILL, &usbNet->flags); /* send info to usb start usb function */ /* need transform usb_net_host change about usbNet->driverInfo->flags and set it on usb_net_host */ OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_OPEN_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_OPEN_USB, + (const void *)&usbNet->flags, sizeof(usbNet->flags)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); @@ -392,7 +388,6 @@ static int32_t UsbnetAdapterOpen(NetDevice *net) OsalMutexUnlock(&usbNet->sendSkbClock); tasklet_schedule (&usbNet->bh); - return HDF_SUCCESS; } @@ -445,18 +440,18 @@ static int32_t UsbnetAdapterStop(NetDevice *net) PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + stats64->tx_packets,stats64->tx_bytes); /* 1. clear_bit EVENT_DEV_OPEN dev->flags */ clear_bit(EVENT_DEV_OPEN, &usbNet->flags); /* 2. netif_stop_queue net */ netif_stop_queue (net); HARCH_NET_INFO_PRINT("stop stats: rx/tx %lu/%lu, errs %lu/%lu\n", - net->stats.rx_packets, net->stats.tx_packets, - net->stats.rx_errors, net->stats.tx_errors); + net->stats.rx_packets, net->stats.tx_packets, + net->stats.rx_errors, net->stats.tx_errors); /* 3. pm = usb_autopm_get_interface(dev->intf); do nothing */ /* 4. if (info->stop) { no stop interface impl in rndis driver info */ @@ -472,7 +467,8 @@ static int32_t UsbnetAdapterStop(NetDevice *net) /* 9. dev flags */ usbNet->flags = 0; OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_CLOSE_USB, (const void *)&usbNet->flags, sizeof(usbNet->flags)); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_CLOSE_USB, + (const void *)&usbNet->flags, sizeof(usbNet->flags)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); @@ -503,7 +499,7 @@ static SkBuff *RndisTxFixup(SkBuff *skb, gfp_t flags) } /* enough room, but needs to be readjusted? */ room += skb_tailroom(skb); - if (likely((sizeof *hdr) <= room)) { + if (likely((sizeof(RndisDataHdr)) <= room)) { skb->data = memmove_s(skb->head + sizeof *hdr, len, skb->data, len); skb_set_tail_pointer(skb, len); goto fill; @@ -540,10 +536,10 @@ static void TxComplete(WorkStruct *work) struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, TxCompleteWorkqueue); PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); HARCH_NET_INFO_PRINT ("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT ("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + stats64->tx_packets,stats64->tx_bytes); flags = u64_stats_update_begin_irqsave(&stats64->syncp); stats64->tx_packets++; @@ -551,54 +547,44 @@ static void TxComplete(WorkStruct *work) u64_stats_update_end_irqrestore(&stats64->syncp, flags); HARCH_NET_INFO_PRINT ("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT ("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + stats64->tx_packets,stats64->tx_bytes); } static netdev_tx_t UsbnetAdapterStartXmit(SkBuff *skb, NetDevice *net) { - HARCH_NET_INFO_PRINT ("netif_running = %d, netif_device_present = %d", netif_running (net), netif_device_present (net)); - HARCH_NET_INFO_PRINT ("netif_carrier_ok = %d", netif_carrier_ok (net)); - - /* print org skb data info */ - HARCH_NET_INFO_PRINT ("UsbnetAdapterStartXmit skb->data = %x, len = %d", skb->data, skb->len); + HARCH_NET_INFO_PRINT ("netif_running=%d, netif_device_present=%d, netif_carrier_ok=%d", netif_running(net), + netif_device_present(net), netif_carrier_ok(net)); + HARCH_NET_INFO_PRINT ("skb->data = %x, len = %d", skb->data, skb->len); printf_char_buffer(skb->data, skb->len, false); - struct UsbnetAdapter *usbNet = netdev_priv(net); - + struct UsbnetAdapter *usbNet = netdev_priv(net); //1.time tamp if (skb) { skb_tx_timestamp(skb); } - //2.fix up - SkBuff* skbFixup = NULL; - - /* rndis fixup sk_buf */ - skbFixup = RndisTxFixup(skb, GFP_ATOMIC); - if (NULL == skbFixup) - { + //2.fix up + SkBuff* skbFixup = RndisTxFixup(skb, GFP_ATOMIC); + if (NULL == skbFixup) { if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) { goto not_drop; } HDF_LOGE("fail to tx fixup by rndis host"); goto drop; } - - HARCH_NET_INFO_PRINT("UsbnetAdapterStartXmit skb_fixup->data = %x, len = %d",skbFixup->data, skbFixup->len); + HARCH_NET_INFO_PRINT("skb_fixup->data = %x, len = %d", skbFixup->data, skbFixup->len); /* print org skb data info */ printf_char_buffer(skbFixup->data, skbFixup->len, false); - //3.send to usb - - // send msg to usb + //3.send msg to usb unsigned long flags = 0; spin_lock_irqsave(&usbNet->txq.lock, flags); - if (netif_queue_stopped(usbNet->net)) { + if (netif_queue_stopped(usbNet->net)) { goto drop; } - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_SEND_DATA_TO_USB, - (unsigned char *)(skbFixup->data), skbFixup->len); + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_SEND_DATA_TO_USB, + (unsigned char *)(skbFixup->data), skbFixup->len); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetHost SendEvent!"); drop: @@ -612,20 +598,16 @@ not_drop: netif_trans_update(usbNet->net); UsbnetAdapterQueueSkb(&usbNet->txq, skbFixup, TX_START); - if (usbNet->txq.qlen >= TX_QLEN (usbNet)) { - HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d", usbNet->txq.qlen, TX_QLEN (usbNet)); + if (usbNet->txq.qlen >= UsbnetAdapterGetTxQlen(usbNet)) { + HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d", usbNet->txq.qlen, UsbnetAdapterGetTxQlen(usbNet)); netif_stop_queue (usbNet->net); } - spin_unlock_irqrestore(&usbNet->txq.lock, flags); - usbNet->txLen = skbFixup->len; schedule_work_on(0, &usbNet->TxCompleteWorkqueue); enum SkbState state = UsbnetAdapterDeferBh(usbNet, skbFixup, &usbNet->txq, TX_DONE); HARCH_NET_INFO_PRINT("state= %d", state); - - HARCH_NET_INFO_PRINT("========print tosend skb data info========"); } return NETDEV_TX_OK; } @@ -634,12 +616,12 @@ static void UsbnetAdapterTXTimeout(NetDevice *net, unsigned int txqueue) { //send to device HARCH_NET_INFO_PRINT("begin"); - if ( NULL == net) { + if (NULL == net) { HDF_LOGE("%s net device object is invalid", __func__); return; } struct UsbnetAdapter *usbNet = netdev_priv(net); - if ( NULL == usbNet) { + if (NULL == usbNet) { HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); return; } @@ -658,10 +640,10 @@ static void UsbnetAdapterTXTimeout(NetDevice *net, unsigned int txqueue) * NOTE: annoying asymmetry: if it's active, schedule_work() fails, * but tasklet_schedule() doesn't. hope the failure is rare. */ -void UsbnetAdapterDeferKevent (struct UsbnetAdapter *usbNet, int work) +static void UsbnetAdapterDeferKevent(struct UsbnetAdapter *usbNet, int work) { HARCH_NET_INFO_PRINT("begin"); - if ( NULL == usbNet) { + if (NULL == usbNet) { HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); return; } @@ -684,15 +666,14 @@ void UsbnetAdapterDeferKevent (struct UsbnetAdapter *usbNet, int work) } } -void UsbnetAdapterSetRxMode(NetDevice *net) -{ - return; +static void UsbnetAdapterSetRxMode(NetDevice *net) { + return; } -void UsbnetAdapterPauseRx(struct UsbnetAdapter *usbNet) +static void UsbnetAdapterPauseRx(struct UsbnetAdapter *usbNet) { HARCH_NET_INFO_PRINT("begin"); - if ( NULL == usbNet) { + if (NULL == usbNet) { HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); return; } @@ -714,7 +695,7 @@ void UsbnetAdapterPauseRx(struct UsbnetAdapter *usbNet) static void UsbnetAdapterUnlinkRxUrbs(struct UsbnetAdapter *usbNet) { HARCH_NET_INFO_PRINT("begin"); - if ( NULL == usbNet) { + if (NULL == usbNet) { HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); return; } @@ -730,7 +711,7 @@ static void UsbnetAdapterResumeRx(struct UsbnetAdapter *usbNet) HARCH_NET_INFO_PRINT("begin"); int num = 0; SkBuff *skb = NULL; - if ( NULL == usbNet) { + if (NULL == usbNet) { HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); return; } @@ -739,7 +720,7 @@ static void UsbnetAdapterResumeRx(struct UsbnetAdapter *usbNet) /* need update flags to usb_net_host */ OsalMutexLock(&usbNet->sendSkbClock); int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, - (const void *)&usbNet->flags, sizeof(usbNet->flags)); + (const void *)&usbNet->flags, sizeof(usbNet->flags)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); @@ -757,29 +738,28 @@ static void UsbnetAdapterResumeRx(struct UsbnetAdapter *usbNet) } -int32_t UsbnetAdapterChangeMtu(NetDevice *net, int newMtu) -{ +static int32_t UsbnetAdapterChangeMtu(NetDevice *net, int newMtu) { //send to device HARCH_NET_INFO_PRINT("begin"); - if ( NULL == net) { + if (NULL == net) { HDF_LOGE("%s net device object is invalid", __func__); return HDF_FAILURE; } struct UsbnetAdapter *usbNet = netdev_priv(net); - if ( NULL == usbNet) { + if (NULL == usbNet) { HDF_LOGE("%s UsbnetAdapter object is invalid", __func__); return HDF_FAILURE; } /* 1. ll_mtu old_hard_mtu old_rx_urb_size */ HARCH_NET_INFO_PRINT("newMtu:%d", newMtu); - int ll_Mtu = newMtu + net->hard_header_len; + int llMtu = newMtu + net->hard_header_len; int oldHardMtu = usbNet->usbnetInfo.hardMtu; int oldRxUrbSize = usbNet->usbnetInfo.rxUrbSize; /* 2. no second zero-length packet read wanted after mtu-sized packets */ - if ((ll_Mtu % usbNet->usbnetInfo.maxpacket) == 0) { + if ((llMtu % usbNet->usbnetInfo.maxpacket) == 0) { HARCH_NET_INFO_PRINT(""); return -EDOM; } @@ -799,15 +779,17 @@ int32_t UsbnetAdapterChangeMtu(NetDevice *net, int newMtu) } /* need transmit hard_mtu to usb net host, UsbnetHostUpdateMaxQlen need this param */ - HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x mtu = %d, hardHeaderLen = %d, link = %d needReset = %d, hardMtu = %d, rxUrbSize = %d, maxpacket =%d", - usbNet->usbnetInfo.name,usbNet->usbnetInfo.flags, usbNet->usbnetInfo.usbFlags,usbNet->usbnetInfo.mtu, - usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link,usbNet->usbnetInfo.needReset, - usbNet->usbnetInfo.hardMtu, usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket); + HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x mtu = %d, hardHeaderLen = %d,\ + link = %d needReset = %d, hardMtu = %d, rxUrbSize = %d, maxpacket =%d", + usbNet->usbnetInfo.name,usbNet->usbnetInfo.flags, usbNet->usbnetInfo.usbFlags, + usbNet->usbnetInfo.mtu,usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, + usbNet->usbnetInfo.needReset,usbNet->usbnetInfo.hardMtu, usbNet->usbnetInfo.rxUrbSize, + usbNet->usbnetInfo.maxpacket); /* 5. max qlen depend on hard_mtu and rx_urb_size */ /* need update flags to usb_net_host */ OsalMutexLock(&usbNet->sendSkbClock); int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_MAXQLEN, - (const void *)&usbNet->usbnetInfo, sizeof(usbNet->usbnetInfo)); + (const void *)&usbNet->usbnetInfo, sizeof(usbNet->usbnetInfo)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); @@ -817,7 +799,7 @@ int32_t UsbnetAdapterChangeMtu(NetDevice *net, int newMtu) return HDF_SUCCESS; } -static void UsbnetAdapterGetStats64 (NetDevice *net, struct rtnl_link_stats64 *stats) +static void UsbnetAdapterGetStats64(NetDevice *net, struct rtnl_link_stats64 *stats) { //send to device HARCH_NET_INFO_PRINT("begin"); @@ -829,10 +811,10 @@ static void UsbnetAdapterGetStats64 (NetDevice *net, struct rtnl_link_stats64 * PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); HARCH_NET_INFO_PRINT ("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT ("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + stats64->tx_packets, stats64->tx_bytes); HARCH_NET_INFO_PRINT("end"); return; @@ -854,7 +836,7 @@ static NetDevice_Ops g_UsbnetAdapterDeviceOps = { static const EthtoolOps g_UsbnetAdapterEthtoolOps = { }; -void UsbnetAdapterLinkChange(struct UsbnetAdapter *usbNet, bool link, bool need_reset) +static void UsbnetAdapterLinkChange(struct UsbnetAdapter *usbNet, bool link, bool need_reset) { HARCH_NET_INFO_PRINT("begin"); /* update link after link is reseted */ @@ -865,33 +847,12 @@ void UsbnetAdapterLinkChange(struct UsbnetAdapter *usbNet, bool link, bool need_ } } -static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct HdfSBuf *data, gfp_t flags) -{ - HARCH_NET_INFO_PRINT("begin"); - unsigned char *buff = NULL; - uint32_t infoSize = 0; - int ret = HDF_SUCCESS; - - bool flag = HdfSbufReadBuffer(data, (const void **)(&(buff)), &infoSize); - if ((!flag) || buff == NULL) { - HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag); - return HDF_ERR_INVALID_PARAM; - } +static int32_t UsbnetAdapterSetSkb(struct UsbnetAdapter *usbNet, gfp_t flags, + uint32_t infoSize, unsigned char *buff, SkBuff **ppSkb) { + SkBuff *skb = NULL; - NetDevice *net = (NetDevice *)device->priv; - if (net == NULL) { - return HDF_ERR_INVALID_PARAM; - } - printf_char_buffer(buff, infoSize, false); - struct UsbnetAdapter *usbNet = netdev_priv(net); - if (usbNet == NULL) { - return HDF_ERR_INVALID_PARAM; - } - SkBuff *skb = NULL; - struct SkbData *entry = NULL; - uint32_t skb_size = sizeof(struct iphdr) + sizeof(struct udphdr) + infoSize; + uint32_t skb_size = sizeof(struct iphdr) + sizeof(struct udphdr) + infoSize; size_t size = skb_size > usbNet->usbnetInfo.rxUrbSize ? usbNet->usbnetInfo.rxUrbSize : skb_size; - HARCH_NET_INFO_PRINT("infoSize= %d, size = %d", infoSize, size); if (test_bit(EVENT_NO_IP_ALIGN, &usbNet->flags)) { skb = __netdev_alloc_skb(usbNet->net, size, flags); @@ -905,16 +866,46 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd return HDF_DEV_ERR_NO_MEMORY; } - entry = (struct SkbData *) skb->cb; - entry->length = 0; - skb_put (skb, infoSize); + skb_put(skb, infoSize); if (memcpy_s(skb->data, infoSize, buff, infoSize) != EOK) { HARCH_NET_INFO_PRINT("memcpy_s error "); - return HDF_ERR_INVALID_PARAM; + return HDF_ERR_INVALID_PARAM; } - - HARCH_NET_INFO_PRINT("skb->len = %d", skb->len); + HARCH_NET_INFO_PRINT("infoSize= %d, size = %d, skb->len = %d", infoSize, size, skb->len); printf_char_buffer(skb->data, skb->len, false); + + *ppSkb = skb; + return HDF_SUCCESS; +} +static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct HdfSBuf *data, gfp_t flags) +{ + HARCH_NET_INFO_PRINT("begin"); + unsigned char *buff = NULL; + uint32_t infoSize = 0; + bool flag = HdfSbufReadBuffer(data, (const void **)(&(buff)), &infoSize); + if ((!flag) || buff == NULL) { + HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag); + return HDF_ERR_INVALID_PARAM; + } + + NetDevice *net = (NetDevice *)device->priv; + if (net == NULL) { + return HDF_ERR_INVALID_PARAM; + } + printf_char_buffer(buff, infoSize, false); + struct UsbnetAdapter *usbNet = netdev_priv(net); + if (usbNet == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + SkBuff *skb = NULL; + flag = UsbnetAdapterSetSkb(usbNet, flags, infoSize, buff, &skb); + if ((!flag) || skb == NULL) { + HDF_LOGE("%s: fail to set skb, flag = %d", __func__, flag); + return flag; + } + struct SkbData *entry = (struct SkbData *)skb->cb; + entry->length = 0; //success recv unsigned long lockflags = 0; spin_lock_irqsave (&usbNet->rxq.lock, lockflags); @@ -923,26 +914,26 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + stats64->rx_packets, stats64->rx_bytes); enum SkbState state = RX_DONE; - if (++usbNet->pkt_Cnt > PKT_COUNT_CLEAR) { - HARCH_NET_INFO_PRINT("usbNet->pkt_Cnt = %d, pkt_Err = %d", usbNet->pkt_Cnt, usbNet->pkt_Err); - usbNet->pkt_Cnt = 0; - usbNet->pkt_Err = 0; + if (++usbNet->pktCnt > PKT_COUNT_CLEAR) { + HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d, pktErr = %d", usbNet->pktCnt, usbNet->pktErr); + usbNet->pktCnt = 0; + usbNet->pktErr = 0; } else { - HARCH_NET_INFO_PRINT("usbNet->pkt_Cnt = %d,pkt_Err = %d", usbNet->pkt_Cnt, usbNet->pkt_Err); + HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d,pktErr = %d", usbNet->pktCnt, usbNet->pktErr); if (state == RX_CLEANUP) { - usbNet->pkt_Err++; + usbNet->pktErr++; } - if (usbNet->pkt_Err > PKT_COUNT_RXKILL) { + if (usbNet->pktErr > PKT_COUNT_RXKILL) { set_bit(EVENT_RX_KILL, &usbNet->flags); } } state = UsbnetAdapterDeferBh(usbNet, skb, &usbNet->rxq, state); - HARCH_NET_INFO_PRINT("usbNet->pkt_Cnt = %d, pkt_Err = %d, state = %d",usbNet->pkt_Cnt, usbNet->pkt_Err, state); + HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d, pktErr = %d, state = %d",usbNet->pktCnt, usbNet->pktErr, state); return HDF_SUCCESS; } @@ -955,18 +946,16 @@ static DeviceType wwanType = { .name = "wwan", }; -static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) -{ - HARCH_NET_INFO_PRINT("begin"); +static void UsbnetAdapterGetObject(struct HdfDeviceObject *device, struct HdfSBuf *data, + struct UsbnetAdapter **ppusbNet) { int ret = HDF_SUCCESS; uint32_t infoSize = 0; - struct UsbnetTransInfo *uNetTransInfo = NULL; + struct UsbnetTransInfo *uNetTransInfo = NULL; bool flag = HdfSbufReadBuffer(data, (const void **)(&(uNetTransInfo)), &infoSize); if ((!flag) || uNetTransInfo == NULL) { - ret = HDF_ERR_INVALID_PARAM; HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag); - return ret; + return; } NetDevice *net = alloc_etherdev(sizeof(struct UsbnetAdapter)); @@ -981,28 +970,27 @@ static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf usbNet->deviceObject = device; //info from usb - if (memcpy_s(&(usbNet->usbnetInfo), sizeof(struct UsbnetTransInfo), + if (memcpy_s(&(usbNet->usbnetInfo), sizeof(struct UsbnetTransInfo), uNetTransInfo, sizeof(struct UsbnetTransInfo)) != EOK) { HARCH_NET_INFO_PRINT("memcpy_s error "); goto out0; } HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x, mtu = %d, \ - hardHeaderLen = %d, link = %d, needReset = %d, \ - hardMtu = %d, rxUrbSize = %d, maxpacket = %d", - usbNet->usbnetInfo.name, usbNet->usbnetInfo.flags, - usbNet->usbnetInfo.usbFlags, usbNet->usbnetInfo.mtu, - usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, - usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu, - usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket); + hardHeaderLen = %d, link = %d, needReset = %d, \ + hardMtu = %d, rxUrbSize = %d, maxpacket = %d", + usbNet->usbnetInfo.name, usbNet->usbnetInfo.flags, + usbNet->usbnetInfo.usbFlags, usbNet->usbnetInfo.mtu, + usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, + usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu, + usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket); usbNet->stats64 = netdev_alloc_pcpu_stats(PcpuSwNetstats); - if (!usbNet->stats64) + if (!usbNet->stats64) { goto out0; - + } usbNet->msg_enable = netif_msg_init (g_msgLevel, NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK| NETIF_MSG_RX_ERR|NETIF_MSG_TX_ERR); - OsalMutexInit(&usbNet->sendSkbClock); init_waitqueue_head(&usbNet->wait); @@ -1021,6 +1009,25 @@ static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf timer_setup(&usbNet->delay, UsbnetAdapterBh, 0); usbNet->net = net; + *ppusbNet = usbNet; +out0: + cancel_work_sync(&usbNet->TxCompleteWorkqueue); + cancel_work_sync(&usbNet->RxCompleteWorkqueue); + free_netdev(net); +out: + return; +} +static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) +{ + HARCH_NET_INFO_PRINT("begin"); + struct UsbnetAdapter *usbNet = NULL; + int ret = HDF_SUCCESS; + UsbnetAdapterGetObject(device, data, &usbNet); + if (NULL == usbNet || NULL == usbNet->net) { + HDF_LOGE("%s: get object fail", __func__); + return HDF_FAILURE; + } + NetDevice *net = usbNet->net; // 1.addr static u8 node_id[ETH_ALEN]; if (usbNet->usbnetInfo.isGetmacAddr) { @@ -1043,36 +1050,31 @@ static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf //3. name and mtu strcpy_s (net->name, sizeof(net->name)/sizeof(net->name[0]), "usb%d"); - if (usbNet->usbnetInfo.isBindDevice) - { + if (usbNet->usbnetInfo.isBindDevice) { /* heuristic: "usb%d" for links we know are two-host, else "eth%d" when there's reasonable doubt. userspace can rename the link if it knows better. */ if ((usbNet->usbnetInfo.usbFlags & HDF_FLAG_ETHER) != 0 && ((usbNet->usbnetInfo.usbFlags & HDF_FLAG_POINTTOPOINT) == 0 || - (net->dev_addr[0] & 0x02) == 0)) - { + (net->dev_addr[0] & 0x02) == 0)) { HARCH_NET_INFO_PRINT(); strcpy_s (net->name, sizeof(net->name)/sizeof(net->name[0]), "eth%d"); } /* WLAN devices should always be named "wlan%d" */ - if ((usbNet->usbnetInfo.usbFlags & FLAG_WLAN) != 0) - { + if ((usbNet->usbnetInfo.usbFlags & FLAG_WLAN) != 0) { HARCH_NET_INFO_PRINT(); strcpy_s(net->name, sizeof(net->name)/sizeof(net->name[0]), "wlan%d"); } /* WWAN devices should always be named "wwan%d" */ - if ((usbNet->usbnetInfo.usbFlags & FLAG_WWAN) != 0) - { + if ((usbNet->usbnetInfo.usbFlags & FLAG_WWAN) != 0) { HARCH_NET_INFO_PRINT(); strcpy_s(net->name, sizeof(net->name)/sizeof(net->name[0]), "wwan%d"); } /* devices that cannot do ARP */ - if ((usbNet->usbnetInfo.usbFlags & FLAG_NOARP) != 0) - { + if ((usbNet->usbnetInfo.usbFlags & FLAG_NOARP) != 0) { net->flags |= IFF_NOARP; } @@ -1080,11 +1082,10 @@ static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf /* maybe the remote can't receive an Ethernet MTU */ net->mtu = usbNet->usbnetInfo.mtu; net->hard_header_len = usbNet->usbnetInfo.hardHeaderLen; - - HARCH_NET_INFO_PRINT("net->mtu= %d",net->mtu); + HARCH_NET_INFO_PRINT("net->mtu= %d", net->mtu); } - HARCH_NET_INFO_PRINT("net->name= %s",net->name); + HARCH_NET_INFO_PRINT("net->name= %s", net->name); /* let userspace know we have a random address */ if (ether_addr_equal(net->dev_addr, node_id)) net->addr_assign_type = NET_ADDR_RANDOM; @@ -1099,9 +1100,9 @@ static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf if (ret) { goto out0; } - HARCH_NET_INFO_PRINT( "register net %pM\n", net->dev_addr); + HARCH_NET_INFO_PRINT("register net %pM\n", net->dev_addr); netif_device_attach(net); - HARCH_NET_INFO_PRINT( "netif_device_attach net %pM\n", net->dev_addr); + HARCH_NET_INFO_PRINT("netif_device_attach net %pM\n", net->dev_addr); if (usbNet->usbnetInfo.usbFlags & FLAG_LINK_INTR) { HARCH_NET_INFO_PRINT(); @@ -1130,8 +1131,7 @@ static int32_t UsbnetAdapterDisconnect(struct HdfDeviceObject *device) unregister_netdev (net); struct UsbnetAdapter *usbNet = netdev_priv(net); - if (usbNet->stats64) - { + if (usbNet->stats64) { free_percpu(usbNet->stats64); } diff --git a/framework/model/usb/include/hdf_usb_net_manager.h b/framework/model/usb/include/hdf_usb_net_manager.h index f659a7294..243e79afa 100755 --- a/framework/model/usb/include/hdf_usb_net_manager.h +++ b/framework/model/usb/include/hdf_usb_net_manager.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Copyright (c) 2024 Archermind Technology (Nanjing) Co. Ltd. * * HDF is dual licensed: you can use it either under the terms of * the GPL, or the BSD license, at your option. @@ -20,7 +20,7 @@ #define FLAG_FRAMING_NC 0x0001 /* guard against device dropouts */ #define FLAG_FRAMING_GL 0x0002 /* genelink batches packets */ #define FLAG_FRAMING_Z 0x0004 /* zaurus adds a trailer */ -#define HDF_FLAG_FRAMING_RN 0x0008 /* RNDIS batches, plus huge header */ +#define HDF_FLAG_FRAMING_RN 0x0008 /* plus huge header */ #define HDF_FLAG_NO_SETINT 0x0010 /* device can't set_interface() */ #define HDF_FLAG_ETHER 0x0020 /* maybe use "eth%d" names */ @@ -54,13 +54,13 @@ enum UsbnetServiceCmd { }; struct UsbnetTransInfo { - uint8_t isBindDevice; - char name[IFNAMSIZ]; /**< Network device name {@link IFNAMSIZ} */ - uint8_t isGetmacAddr; - uint8_t macAddr[MAC_ADDR_SIZE]; /**< MAC address {@link MAC_ADDR_SIZE} */ - uint32_t flags; /**< Network port status */ - uint32_t mtu; /**< Maximum transmission unit */ - uint16_t hardHeaderLen; /**< Header length */ + uint8_t isBindDevice; + char name[IFNAMSIZ]; /**< Network device name {@link IFNAMSIZ} */ + uint8_t isGetmacAddr; + uint8_t macAddr[MAC_ADDR_SIZE]; /**< MAC address {@link MAC_ADDR_SIZE} */ + uint32_t flags; /**< Network port status */ + uint32_t mtu; /**< Maximum transmission unit */ + uint16_t hardHeaderLen; /**< Header length */ uint8_t link; uint8_t needReset; uint32_t usbFlags; /**< usb device match flags */ -- Gitee From c00e2f1c68995e86f1c5d4925a43aa82169c5903 Mon Sep 17 00:00:00 2001 From: n028372 Date: Mon, 22 Jan 2024 09:36:00 +0800 Subject: [PATCH 6/8] =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: n028372 --- OAT.xml | 1 + .../model/usb/host/include/usb_net_adapter.h | 4 +- .../model/usb/host/src/usb_net_adapter.c | 236 +++++++++--------- .../model/usb/include/hdf_usb_net_manager.h | 8 +- 4 files changed, 119 insertions(+), 130 deletions(-) diff --git a/OAT.xml b/OAT.xml index 00f6be915..560bf567b 100644 --- a/OAT.xml +++ b/OAT.xml @@ -67,6 +67,7 @@ Note:If the text contains special characters, please escape them according to th + diff --git a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h index 1e1620605..5a04a0c06 100755 --- a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h +++ b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h @@ -17,7 +17,7 @@ #define HARCH_LOG_TAG "[-net-hdf-]" #define HARCH_NET_INFO_PRINT(fmt, ...) \ do { \ - if(1){ \ + if (1) { \ HDF_LOGI(HARCH_LOG_TAG"[%{public}s][%{public}d]:" fmt "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__);} \ } while(0) @@ -52,7 +52,7 @@ struct rndis_data_hdr { struct UsbnetAdapter { struct IDeviceIoService service; struct HdfDeviceObject *deviceObject; - unsigned canDmaSg: 1; + unsigned canDmaSg : 1; NetDevice *net; int32_t msg_enable; struct UsbnetTransInfo usbnetInfo; diff --git a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c index 6bcf2ad53..3e761dc32 100755 --- a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c +++ b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c @@ -48,11 +48,14 @@ static int g_msgLevel = -1; MODULE_PARAM(g_msgLevel, int, 0); MODULE_PARM_DESC(g_msgLevel, "Override default message level"); -static inline int UsbnetAdapterGetTxQlen(struct UsbnetAdapter *usbNet) { +static inline int UsbnetAdapterGetTxQlen(struct UsbnetAdapter *usbNet) +{ + return usbNet->usbnetInfo.txQlen; } -static int printf_char_buffer(char *buff, int size, bool isPrint) { +static int printf_char_buffer(char *buff, int size, bool isPrint) +{ if (isPrint) { int i = 0; printk("===-harch-=== printf_char_buffer begin\n"); @@ -101,8 +104,8 @@ out: return ret; } -static void RxComplete(WorkStruct *work) { - +static void RxComplete(WorkStruct *work) +{ unsigned long flags = 0; struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, RxCompleteWorkqueue); PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); @@ -300,7 +303,8 @@ static void UsbnetAdapterBh(TimerList *t) if (usbNet->txq.qlen < UsbnetAdapterGetTxQlen(usbNet)) { netif_wake_queue (usbNet->net); - HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",usbNet->txq.qlen,UsbnetAdapterGetTxQlen(usbNet)); + HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d", + usbNet->txq.qlen,UsbnetAdapterGetTxQlen(usbNet)); } HARCH_NET_INFO_PRINT("end"); } @@ -443,7 +447,7 @@ static int32_t UsbnetAdapterStop(NetDevice *net) stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + stats64->tx_packets, stats64->tx_bytes); /* 1. clear_bit EVENT_DEV_OPEN dev->flags */ clear_bit(EVENT_DEV_OPEN, &usbNet->flags); @@ -507,7 +511,7 @@ static SkBuff *RndisTxFixup(SkBuff *skb, gfp_t flags) } /* create a new skb, with the correct size (and tailpad) */ - skb2 = skb_copy_expand(skb, sizeof *hdr, 1, flags); + skb2 = skb_copy_expand(skb, sizeof(RndisDataHdr), 1, flags); dev_kfree_skb_any(skb); if (unlikely(!skb2)) { return skb2; @@ -559,7 +563,7 @@ static netdev_tx_t UsbnetAdapterStartXmit(SkBuff *skb, NetDevice *net) netif_device_present(net), netif_carrier_ok(net)); HARCH_NET_INFO_PRINT ("skb->data = %x, len = %d", skb->data, skb->len); printf_char_buffer(skb->data, skb->len, false); - struct UsbnetAdapter *usbNet = netdev_priv(net); + struct UsbnetAdapter *usbNet = netdev_priv(net); //1.time tamp if (skb) { skb_tx_timestamp(skb); @@ -576,7 +580,7 @@ static netdev_tx_t UsbnetAdapterStartXmit(SkBuff *skb, NetDevice *net) HARCH_NET_INFO_PRINT("skb_fixup->data = %x, len = %d", skbFixup->data, skbFixup->len); /* print org skb data info */ printf_char_buffer(skbFixup->data, skbFixup->len, false); - //3.send msg to usb + //3.send msg to usb unsigned long flags = 0; spin_lock_irqsave(&usbNet->txq.lock, flags); if (netif_queue_stopped(usbNet->net)) { @@ -781,9 +785,9 @@ static int32_t UsbnetAdapterChangeMtu(NetDevice *net, int newMtu) { /* need transmit hard_mtu to usb net host, UsbnetHostUpdateMaxQlen need this param */ HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x mtu = %d, hardHeaderLen = %d,\ link = %d needReset = %d, hardMtu = %d, rxUrbSize = %d, maxpacket =%d", - usbNet->usbnetInfo.name,usbNet->usbnetInfo.flags, usbNet->usbnetInfo.usbFlags, - usbNet->usbnetInfo.mtu,usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, - usbNet->usbnetInfo.needReset,usbNet->usbnetInfo.hardMtu, usbNet->usbnetInfo.rxUrbSize, + usbNet->usbnetInfo.name,usbNet->usbnetInfo.flags,usbNet->usbnetInfo.usbFlags,\ + usbNet->usbnetInfo.mtu,usbNet->usbnetInfo.hardHeaderLen,usbNet->usbnetInfo.link,\ + usbNet->usbnetInfo.needReset,usbNet->usbnetInfo.hardMtu,usbNet->usbnetInfo.rxUrbSize,\ usbNet->usbnetInfo.maxpacket); /* 5. max qlen depend on hard_mtu and rx_urb_size */ /* need update flags to usb_net_host */ @@ -824,7 +828,7 @@ static NetDevice_Ops g_UsbnetAdapterDeviceOps = { .ndo_open = UsbnetAdapterOpen, .ndo_stop = UsbnetAdapterStop, .ndo_start_xmit = UsbnetAdapterStartXmit, - .ndo_tx_timeout = UsbnetAdapterTXTimeout, + .ndo_tx_timeout = UsbnetAdapterTXTimeout, .ndo_set_rx_mode = UsbnetAdapterSetRxMode, .ndo_change_mtu = UsbnetAdapterChangeMtu, .ndo_get_stats64 = UsbnetAdapterGetStats64, @@ -848,18 +852,8 @@ static void UsbnetAdapterLinkChange(struct UsbnetAdapter *usbNet, bool link, boo } static int32_t UsbnetAdapterSetSkb(struct UsbnetAdapter *usbNet, gfp_t flags, - uint32_t infoSize, unsigned char *buff, SkBuff **ppSkb) { - SkBuff *skb = NULL; - - uint32_t skb_size = sizeof(struct iphdr) + sizeof(struct udphdr) + infoSize; - size_t size = skb_size > usbNet->usbnetInfo.rxUrbSize ? usbNet->usbnetInfo.rxUrbSize : skb_size; - - if (test_bit(EVENT_NO_IP_ALIGN, &usbNet->flags)) { - skb = __netdev_alloc_skb(usbNet->net, size, flags); - } else { - skb = __netdev_alloc_skb_ip_align(usbNet->net, size, flags); - } - + uint32_t infoSize, unsigned char *buff, SkBuff *skb) +{ if (!skb) { HARCH_NET_INFO_PRINT("no rx skb\n"); UsbnetAdapterDeferKevent(usbNet, EVENT_RX_MEMORY); @@ -871,17 +865,43 @@ static int32_t UsbnetAdapterSetSkb(struct UsbnetAdapter *usbNet, gfp_t flags, HARCH_NET_INFO_PRINT("memcpy_s error "); return HDF_ERR_INVALID_PARAM; } - HARCH_NET_INFO_PRINT("infoSize= %d, size = %d, skb->len = %d", infoSize, size, skb->len); + printf_char_buffer(skb->data, skb->len, false); - - *ppSkb = skb; return HDF_SUCCESS; } + +static void UsbnetAdapterSetUsbNetInfo(struct UsbnetAdapter *usbNet, SkBuff *skb, enum SkbState state) +{ + unsigned long lockflags = 0; + spin_lock_irqsave (&usbNet->rxq.lock, lockflags); + UsbnetAdapterQueueSkb(&usbNet->rxq, skb, RX_START); + spin_unlock_irqrestore (&usbNet->rxq.lock, lockflags); + + PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); + HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", + stats64->rx_packets, stats64->rx_bytes); + + if (++usbNet->pktCnt > PKT_COUNT_CLEAR) { + HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d, pktErr = %d", usbNet->pktCnt, usbNet->pktErr); + usbNet->pktCnt = 0; + usbNet->pktErr = 0; + } else { + HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d,pktErr = %d", usbNet->pktCnt, usbNet->pktErr); + if (state == RX_CLEANUP) { + usbNet->pktErr++; + } + + if (usbNet->pktErr > PKT_COUNT_RXKILL) { + set_bit(EVENT_RX_KILL, &usbNet->flags); + } + } +} + static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct HdfSBuf *data, gfp_t flags) { HARCH_NET_INFO_PRINT("begin"); unsigned char *buff = NULL; - uint32_t infoSize = 0; + uint32_t infoSize = 0; bool flag = HdfSbufReadBuffer(data, (const void **)(&(buff)), &infoSize); if ((!flag) || buff == NULL) { HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag); @@ -899,38 +919,26 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd } SkBuff *skb = NULL; - flag = UsbnetAdapterSetSkb(usbNet, flags, infoSize, buff, &skb); - if ((!flag) || skb == NULL) { + uint32_t skb_size = sizeof(struct iphdr) + sizeof(struct udphdr) + infoSize; + size_t size = skb_size > usbNet->usbnetInfo.rxUrbSize ? usbNet->usbnetInfo.rxUrbSize : skb_size; + if (test_bit(EVENT_NO_IP_ALIGN, &usbNet->flags)) { + skb = __netdev_alloc_skb(usbNet->net, size, flags); + } else { + skb = __netdev_alloc_skb_ip_align(usbNet->net, size, flags); + } + int32_t ret = UsbnetAdapterSetSkb(usbNet, flags, infoSize, buff, skb); + if (ret != HDF_SUCCESS || skb == NULL) { HDF_LOGE("%s: fail to set skb, flag = %d", __func__, flag); - return flag; + return ret; } + HARCH_NET_INFO_PRINT("infoSize= %d, size = %d, skb->len = %d", infoSize, size, skb->len); + struct SkbData *entry = (struct SkbData *)skb->cb; entry->length = 0; - //success recv - unsigned long lockflags = 0; - spin_lock_irqsave (&usbNet->rxq.lock, lockflags); - UsbnetAdapterQueueSkb(&usbNet->rxq, skb, RX_START); - spin_unlock_irqrestore (&usbNet->rxq.lock, lockflags); - - PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); - HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + //success recv enum SkbState state = RX_DONE; - if (++usbNet->pktCnt > PKT_COUNT_CLEAR) { - HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d, pktErr = %d", usbNet->pktCnt, usbNet->pktErr); - usbNet->pktCnt = 0; - usbNet->pktErr = 0; - } else { - HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d,pktErr = %d", usbNet->pktCnt, usbNet->pktErr); - if (state == RX_CLEANUP) { - usbNet->pktErr++; - } - - if (usbNet->pktErr > PKT_COUNT_RXKILL) { - set_bit(EVENT_RX_KILL, &usbNet->flags); - } - } + UsbnetAdapterSetUsbNetInfo(usbNet, skb, state); state = UsbnetAdapterDeferBh(usbNet, skb, &usbNet->rxq, state); HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d, pktErr = %d, state = %d",usbNet->pktCnt, usbNet->pktErr, state); @@ -946,51 +954,33 @@ static DeviceType wwanType = { .name = "wwan", }; -static void UsbnetAdapterGetObject(struct HdfDeviceObject *device, struct HdfSBuf *data, - struct UsbnetAdapter **ppusbNet) { - int ret = HDF_SUCCESS; - uint32_t infoSize = 0; - struct UsbnetTransInfo *uNetTransInfo = NULL; - - bool flag = HdfSbufReadBuffer(data, (const void **)(&(uNetTransInfo)), &infoSize); - if ((!flag) || uNetTransInfo == NULL) { - HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag); - return; - } - - NetDevice *net = alloc_etherdev(sizeof(struct UsbnetAdapter)); - if (net == NULL) { - HARCH_NET_INFO_PRINT(); - goto out; - } - - device->priv = net; - HARCH_NET_INFO_PRINT(); +static void UsbnetAdapterSetUsbNet(struct HdfDeviceObject *device, NetDevice *net, struct UsbnetTransInfo *uNetTransInfo) +{ struct UsbnetAdapter *usbNet = netdev_priv(net); usbNet->deviceObject = device; - + //info from usb - if (memcpy_s(&(usbNet->usbnetInfo), sizeof(struct UsbnetTransInfo), + if (memcpy_s(&(usbNet->usbnetInfo), sizeof(struct UsbnetTransInfo), uNetTransInfo, sizeof(struct UsbnetTransInfo)) != EOK) { HARCH_NET_INFO_PRINT("memcpy_s error "); - goto out0; } HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x, mtu = %d, \ - hardHeaderLen = %d, link = %d, needReset = %d, \ - hardMtu = %d, rxUrbSize = %d, maxpacket = %d", - usbNet->usbnetInfo.name, usbNet->usbnetInfo.flags, - usbNet->usbnetInfo.usbFlags, usbNet->usbnetInfo.mtu, - usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, - usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu, - usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket); + hardHeaderLen = %d, link = %d, needReset = %d, \ + hardMtu = %d, rxUrbSize = %d, maxpacket = %d", + usbNet->usbnetInfo.name, usbNet->usbnetInfo.flags, + usbNet->usbnetInfo.usbFlags, usbNet->usbnetInfo.mtu, + usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, + usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu, + usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket); usbNet->stats64 = netdev_alloc_pcpu_stats(PcpuSwNetstats); - if (!usbNet->stats64) { - goto out0; - } + if (!usbNet->stats64) + return; + usbNet->msg_enable = netif_msg_init (g_msgLevel, NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK| NETIF_MSG_RX_ERR|NETIF_MSG_TX_ERR); + OsalMutexInit(&usbNet->sendSkbClock); init_waitqueue_head(&usbNet->wait); @@ -1009,41 +999,25 @@ static void UsbnetAdapterGetObject(struct HdfDeviceObject *device, struct HdfSBu timer_setup(&usbNet->delay, UsbnetAdapterBh, 0); usbNet->net = net; - *ppusbNet = usbNet; -out0: - cancel_work_sync(&usbNet->TxCompleteWorkqueue); - cancel_work_sync(&usbNet->RxCompleteWorkqueue); - free_netdev(net); -out: - return; } -static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) + + +static void UsbnetAdapterSetNetDevice(struct UsbnetAdapter *usbNet, NetDevice *net) { - HARCH_NET_INFO_PRINT("begin"); - struct UsbnetAdapter *usbNet = NULL; - int ret = HDF_SUCCESS; - UsbnetAdapterGetObject(device, data, &usbNet); - if (NULL == usbNet || NULL == usbNet->net) { - HDF_LOGE("%s: get object fail", __func__); - return HDF_FAILURE; - } - NetDevice *net = usbNet->net; // 1.addr static u8 node_id[ETH_ALEN]; if (usbNet->usbnetInfo.isGetmacAddr) { if (memcpy_s(node_id, ETH_ALEN, usbNet->usbnetInfo.macAddr, ETH_ALEN) != EOK) { - goto out0; + return; } } else { eth_random_addr(node_id); } - memcpy_s(net->dev_addr, sizeof(node_id), node_id, sizeof(node_id)); - HARCH_NET_INFO_PRINT("macAddr addr %pM", net->dev_addr); - + memcpy_s(net->dev_addr, sizeof(node_id)/sizeof(node_id[0]), node_id, sizeof(node_id)/sizeof(node_id[0])); + HARCH_NET_INFO_PRINT("macAddr addr %pM", net->dev_addr); // 2. mtu net->min_mtu = 0; net->max_mtu = ETH_MAX_MTU; - net->netdev_ops = &g_UsbnetAdapterDeviceOps; net->watchdog_timeo = TX_TIMEOUT_JIFFIES; net->ethtool_ops = &g_UsbnetAdapterEthtoolOps; @@ -1051,10 +1025,6 @@ static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf //3. name and mtu strcpy_s (net->name, sizeof(net->name)/sizeof(net->name[0]), "usb%d"); if (usbNet->usbnetInfo.isBindDevice) { - /* heuristic: "usb%d" for links we know are two-host, - else "eth%d" when there's reasonable doubt. userspace - can rename the link if it knows better. - */ if ((usbNet->usbnetInfo.usbFlags & HDF_FLAG_ETHER) != 0 && ((usbNet->usbnetInfo.usbFlags & HDF_FLAG_POINTTOPOINT) == 0 || (net->dev_addr[0] & 0x02) == 0)) { @@ -1078,24 +1048,41 @@ static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf net->flags |= IFF_NOARP; } - HARCH_NET_INFO_PRINT("usbNet->usbnetInfo.mtu = %d",usbNet->usbnetInfo.mtu); + HARCH_NET_INFO_PRINT("usbNet->usbnetInfo.mtu = %d, net->name= %s", usbNet->usbnetInfo.mtu, net->name); /* maybe the remote can't receive an Ethernet MTU */ net->mtu = usbNet->usbnetInfo.mtu; net->hard_header_len = usbNet->usbnetInfo.hardHeaderLen; - HARCH_NET_INFO_PRINT("net->mtu= %d", net->mtu); } - HARCH_NET_INFO_PRINT("net->name= %s", net->name); /* let userspace know we have a random address */ - if (ether_addr_equal(net->dev_addr, node_id)) + if (ether_addr_equal(net->dev_addr, node_id)) { net->addr_assign_type = NET_ADDR_RANDOM; + } +} - if ((usbNet->usbnetInfo.usbFlags & FLAG_WLAN) != 0) - SET_NETDEV_DEVTYPE(net, &wlanType); - - if (usbNet->usbnetInfo.usbFlags & FLAG_WWAN != 0) - SET_NETDEV_DEVTYPE(net, &wwanType); - +static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data) +{ + HARCH_NET_INFO_PRINT("begin"); + int ret = HDF_SUCCESS; + uint32_t infoSize = 0; + struct UsbnetTransInfo *uNetTransInfo = NULL; + + bool flag = HdfSbufReadBuffer(data, (const void **)(&(uNetTransInfo)), &infoSize); + if ((!flag) || uNetTransInfo == NULL) { + ret = HDF_ERR_INVALID_PARAM; + HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag); + return ret; + } + NetDevice *net = alloc_etherdev(sizeof(struct UsbnetAdapter)); + if (net == NULL) { + HARCH_NET_INFO_PRINT(); + goto out; + } + device->priv = net; + struct UsbnetAdapter *usbNet = netdev_priv(net); + UsbnetAdapterSetUsbNet(device, net, uNetTransInfo); + UsbnetAdapterSetNetDevice(usbNet, net); + HARCH_NET_INFO_PRINT("after usbNet->usbnetInfo.mtu = %d, net->name= %s", usbNet->usbnetInfo.mtu, net->name); ret = register_netdev(net); if (ret) { goto out0; @@ -1118,6 +1105,7 @@ out: return ret; } + static int32_t UsbnetAdapterDisconnect(struct HdfDeviceObject *device) { HARCH_NET_INFO_PRINT("begin"); diff --git a/framework/model/usb/include/hdf_usb_net_manager.h b/framework/model/usb/include/hdf_usb_net_manager.h index 243e79afa..0c2eaaaec 100755 --- a/framework/model/usb/include/hdf_usb_net_manager.h +++ b/framework/model/usb/include/hdf_usb_net_manager.h @@ -17,10 +17,10 @@ #define IFNAMSIZ 16 /* framing is CDC Ethernet, not writing ZLPs (hw issues), or optionally: */ -#define FLAG_FRAMING_NC 0x0001 /* guard against device dropouts */ -#define FLAG_FRAMING_GL 0x0002 /* genelink batches packets */ -#define FLAG_FRAMING_Z 0x0004 /* zaurus adds a trailer */ -#define HDF_FLAG_FRAMING_RN 0x0008 /* plus huge header */ +#define FLAG_FRAMING_NC 0x0001 /* guard against device dropouts */ +#define FLAG_FRAMING_GL 0x0002 /* genelink batches packets */ +#define FLAG_FRAMING_Z 0x0004 /* zaurus adds a trailer */ +#define HDF_FLAG_FRAMING_RN 0x0008 /* huge header */ #define HDF_FLAG_NO_SETINT 0x0010 /* device can't set_interface() */ #define HDF_FLAG_ETHER 0x0020 /* maybe use "eth%d" names */ -- Gitee From 601b9214f6f400cfef37b8e9ca2ee10a174ed3d2 Mon Sep 17 00:00:00 2001 From: n028372 Date: Mon, 22 Jan 2024 10:17:31 +0800 Subject: [PATCH 7/8] =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: n028372 --- .../model/usb/host/include/usb_net_adapter.h | 4 +- .../model/usb/host/src/usb_net_adapter.c | 65 ++++++++++--------- .../model/usb/include/hdf_usb_net_manager.h | 2 +- 3 files changed, 37 insertions(+), 34 deletions(-) diff --git a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h index 5a04a0c06..983b37167 100755 --- a/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h +++ b/adapter/khdf/linux/model/usb/host/include/usb_net_adapter.h @@ -19,10 +19,10 @@ do { \ if (1) { \ HDF_LOGI(HARCH_LOG_TAG"[%{public}s][%{public}d]:" fmt "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__);} \ -} while(0) +} while (0) typedef struct pcpu_sw_netstats PcpuSwNetstats; -typedef struct net_device NetDevice; +typedef struct net_device NetDevice; typedef struct timer_list TimerList; typedef struct work_struct WorkStruct; typedef struct tasklet_struct TaskletStruct; diff --git a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c index 3e761dc32..53c186bb3 100755 --- a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c +++ b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c @@ -50,7 +50,6 @@ MODULE_PARM_DESC(g_msgLevel, "Override default message level"); static inline int UsbnetAdapterGetTxQlen(struct UsbnetAdapter *usbNet) { - return usbNet->usbnetInfo.txQlen; } @@ -111,10 +110,10 @@ static void RxComplete(WorkStruct *work) PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64); HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu", - stats64->rx_packets, stats64->rx_bytes); + stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets, stats64->tx_bytes); + stats64->tx_packets, stats64->tx_bytes); flags = u64_stats_update_begin_irqsave(&stats64->syncp); stats64->rx_packets++; @@ -125,7 +124,7 @@ static void RxComplete(WorkStruct *work) stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + stats64->tx_packets, stats64->tx_bytes); } /* Passes this packet up the stack, updating its accounting. @@ -236,7 +235,7 @@ static void UsbnetAdapterRxProcess(struct UsbnetAdapter *usbNet, SkBuff *skb) /* all data was already cloned from skb inside the driver */ if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) { - HARCH_NET_INFO_PRINT("usbNet->driver_info->flags = %d",usbNet->usbnetInfo.usbFlags); + HARCH_NET_INFO_PRINT("usbNet->driver_info->flags = %d", usbNet->usbnetInfo.usbFlags); goto done; } @@ -294,8 +293,7 @@ static void UsbnetAdapterBh(TimerList *t) */ if (waitqueue_active(&usbNet->wait)) { HARCH_NET_INFO_PRINT("waitqueue_active"); - if (usbNet->rxq.qlen + usbNet->txq.qlen + usbNet->done.qlen == 0) - { + if (usbNet->rxq.qlen + usbNet->txq.qlen + usbNet->done.qlen == 0) { HARCH_NET_INFO_PRINT(); wake_up_all(&usbNet->wait); } @@ -329,7 +327,7 @@ static void UsbnetAdapterQueueSkb(SkBuff_Head *list, } static enum SkbState UsbnetAdapterDeferBh(struct UsbnetAdapter *usbNet, SkBuff *skb, - SkBuff_Head *list, enum SkbState state) + SkBuff_Head *list, enum SkbState state) { unsigned long flags = 0; enum SkbState old_state = ILLEGAL; @@ -498,7 +496,7 @@ static SkBuff *RndisTxFixup(SkBuff *skb, gfp_t flags) if (likely(!skb_cloned(skb))) { int room = skb_headroom(skb); /* enough head room as-is? */ - if (unlikely((sizeof *hdr) <= room)) { + if (unlikely((sizeof(RndisDataHdr)) <= room)) { goto fill; } /* enough room, but needs to be readjusted? */ @@ -554,7 +552,7 @@ static void TxComplete(WorkStruct *work) stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT ("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + stats64->tx_packets, stats64->tx_bytes); } static netdev_tx_t UsbnetAdapterStartXmit(SkBuff *skb, NetDevice *net) @@ -568,7 +566,7 @@ static netdev_tx_t UsbnetAdapterStartXmit(SkBuff *skb, NetDevice *net) if (skb) { skb_tx_timestamp(skb); } - //2.fix up + //2.fix up SkBuff* skbFixup = RndisTxFixup(skb, GFP_ATOMIC); if (NULL == skbFixup) { if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) { @@ -603,7 +601,8 @@ not_drop: UsbnetAdapterQueueSkb(&usbNet->txq, skbFixup, TX_START); if (usbNet->txq.qlen >= UsbnetAdapterGetTxQlen(usbNet)) { - HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d", usbNet->txq.qlen, UsbnetAdapterGetTxQlen(usbNet)); + HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d", + usbNet->txq.qlen, UsbnetAdapterGetTxQlen(usbNet)); netif_stop_queue (usbNet->net); } spin_unlock_irqrestore(&usbNet->txq.lock, flags); @@ -655,7 +654,7 @@ static void UsbnetAdapterDeferKevent(struct UsbnetAdapter *usbNet, int work) /* need update flags to usb_net_host */ OsalMutexLock(&usbNet->sendSkbClock); int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, - (const void *)&usbNet->flags, sizeof(usbNet->flags)); + (const void *)&usbNet->flags, sizeof(usbNet->flags)); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); @@ -670,7 +669,8 @@ static void UsbnetAdapterDeferKevent(struct UsbnetAdapter *usbNet, int work) } } -static void UsbnetAdapterSetRxMode(NetDevice *net) { +static void UsbnetAdapterSetRxMode(NetDevice *net) +{ return; } @@ -684,9 +684,9 @@ static void UsbnetAdapterPauseRx(struct UsbnetAdapter *usbNet) set_bit(EVENT_RX_PAUSED, &usbNet->flags); /* need update flags to usb_net_host */ OsalMutexLock(&usbNet->sendSkbClock); - int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, (const void *)&usbNet->flags, sizeof(usbNet->flags)); - if (ret != HDF_SUCCESS) - { + int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS, + (const void *)&usbNet->flags, sizeof(usbNet->flags)); + if (ret != HDF_SUCCESS) { HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!"); OsalMutexUnlock(&usbNet->sendSkbClock); return; @@ -742,7 +742,8 @@ static void UsbnetAdapterResumeRx(struct UsbnetAdapter *usbNet) } -static int32_t UsbnetAdapterChangeMtu(NetDevice *net, int newMtu) { +static int32_t UsbnetAdapterChangeMtu(NetDevice *net, int newMtu) +{ //send to device HARCH_NET_INFO_PRINT("begin"); if (NULL == net) { @@ -852,7 +853,7 @@ static void UsbnetAdapterLinkChange(struct UsbnetAdapter *usbNet, bool link, boo } static int32_t UsbnetAdapterSetSkb(struct UsbnetAdapter *usbNet, gfp_t flags, - uint32_t infoSize, unsigned char *buff, SkBuff *skb) + uint32_t infoSize, unsigned char *buff, SkBuff *skb) { if (!skb) { HARCH_NET_INFO_PRINT("no rx skb\n"); @@ -941,7 +942,7 @@ static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct Hd UsbnetAdapterSetUsbNetInfo(usbNet, skb, state); state = UsbnetAdapterDeferBh(usbNet, skb, &usbNet->rxq, state); - HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d, pktErr = %d, state = %d",usbNet->pktCnt, usbNet->pktErr, state); + HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d, pktErr = %d, state = %d", usbNet->pktCnt, usbNet->pktErr, state); return HDF_SUCCESS; } @@ -954,29 +955,31 @@ static DeviceType wwanType = { .name = "wwan", }; -static void UsbnetAdapterSetUsbNet(struct HdfDeviceObject *device, NetDevice *net, struct UsbnetTransInfo *uNetTransInfo) +static void UsbnetAdapterSetUsbNet(struct HdfDeviceObject *device, + NetDevice *net, struct UsbnetTransInfo *uNetTransInfo) { struct UsbnetAdapter *usbNet = netdev_priv(net); usbNet->deviceObject = device; //info from usb - if (memcpy_s(&(usbNet->usbnetInfo), sizeof(struct UsbnetTransInfo), + if (memcpy_s(&(usbNet->usbnetInfo), sizeof(struct UsbnetTransInfo), uNetTransInfo, sizeof(struct UsbnetTransInfo)) != EOK) { HARCH_NET_INFO_PRINT("memcpy_s error "); } HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x, mtu = %d, \ - hardHeaderLen = %d, link = %d, needReset = %d, \ - hardMtu = %d, rxUrbSize = %d, maxpacket = %d", - usbNet->usbnetInfo.name, usbNet->usbnetInfo.flags, - usbNet->usbnetInfo.usbFlags, usbNet->usbnetInfo.mtu, - usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, - usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu, - usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket); + hardHeaderLen = %d, link = %d, needReset = %d, \ + hardMtu = %d, rxUrbSize = %d, maxpacket = %d", + usbNet->usbnetInfo.name, usbNet->usbnetInfo.flags, + usbNet->usbnetInfo.usbFlags, usbNet->usbnetInfo.mtu, + usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link, + usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu, + usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket); usbNet->stats64 = netdev_alloc_pcpu_stats(PcpuSwNetstats); - if (!usbNet->stats64) + if (!usbNet->stats64) { return; + } usbNet->msg_enable = netif_msg_init (g_msgLevel, NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK| NETIF_MSG_RX_ERR|NETIF_MSG_TX_ERR); @@ -1065,7 +1068,7 @@ static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf HARCH_NET_INFO_PRINT("begin"); int ret = HDF_SUCCESS; uint32_t infoSize = 0; - struct UsbnetTransInfo *uNetTransInfo = NULL; + struct UsbnetTransInfo *uNetTransInfo = NULL; bool flag = HdfSbufReadBuffer(data, (const void **)(&(uNetTransInfo)), &infoSize); if ((!flag) || uNetTransInfo == NULL) { diff --git a/framework/model/usb/include/hdf_usb_net_manager.h b/framework/model/usb/include/hdf_usb_net_manager.h index 0c2eaaaec..840b37e29 100755 --- a/framework/model/usb/include/hdf_usb_net_manager.h +++ b/framework/model/usb/include/hdf_usb_net_manager.h @@ -20,7 +20,7 @@ #define FLAG_FRAMING_NC 0x0001 /* guard against device dropouts */ #define FLAG_FRAMING_GL 0x0002 /* genelink batches packets */ #define FLAG_FRAMING_Z 0x0004 /* zaurus adds a trailer */ -#define HDF_FLAG_FRAMING_RN 0x0008 /* huge header */ +#define FLAG_FRAMING_RN 0x0008 /* huge header */ #define HDF_FLAG_NO_SETINT 0x0010 /* device can't set_interface() */ #define HDF_FLAG_ETHER 0x0020 /* maybe use "eth%d" names */ -- Gitee From 9b575ee394dd086c3d84a3c6fcc23c985090a622 Mon Sep 17 00:00:00 2001 From: n028372 Date: Mon, 22 Jan 2024 10:36:20 +0800 Subject: [PATCH 8/8] =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: n028372 --- adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c | 7 +++---- framework/model/usb/include/hdf_usb_net_manager.h | 1 - 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c index 53c186bb3..f2c12f958 100755 --- a/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c +++ b/adapter/khdf/linux/model/usb/host/src/usb_net_adapter.c @@ -302,7 +302,7 @@ static void UsbnetAdapterBh(TimerList *t) if (usbNet->txq.qlen < UsbnetAdapterGetTxQlen(usbNet)) { netif_wake_queue (usbNet->net); HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d", - usbNet->txq.qlen,UsbnetAdapterGetTxQlen(usbNet)); + usbNet->txq.qlen, UsbnetAdapterGetTxQlen(usbNet)); } HARCH_NET_INFO_PRINT("end"); } @@ -502,7 +502,7 @@ static SkBuff *RndisTxFixup(SkBuff *skb, gfp_t flags) /* enough room, but needs to be readjusted? */ room += skb_tailroom(skb); if (likely((sizeof(RndisDataHdr)) <= room)) { - skb->data = memmove_s(skb->head + sizeof *hdr, len, skb->data, len); + skb->data = memmove_s(skb->head + sizeof(RndisDataHdr), len, skb->data, len); skb_set_tail_pointer(skb, len); goto fill; } @@ -541,7 +541,7 @@ static void TxComplete(WorkStruct *work) stats64->rx_packets, stats64->rx_bytes); HARCH_NET_INFO_PRINT ("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu", - stats64->tx_packets,stats64->tx_bytes); + stats64->tx_packets, stats64->tx_bytes); flags = u64_stats_update_begin_irqsave(&stats64->syncp); stats64->tx_packets++; @@ -560,7 +560,6 @@ static netdev_tx_t UsbnetAdapterStartXmit(SkBuff *skb, NetDevice *net) HARCH_NET_INFO_PRINT ("netif_running=%d, netif_device_present=%d, netif_carrier_ok=%d", netif_running(net), netif_device_present(net), netif_carrier_ok(net)); HARCH_NET_INFO_PRINT ("skb->data = %x, len = %d", skb->data, skb->len); - printf_char_buffer(skb->data, skb->len, false); struct UsbnetAdapter *usbNet = netdev_priv(net); //1.time tamp if (skb) { diff --git a/framework/model/usb/include/hdf_usb_net_manager.h b/framework/model/usb/include/hdf_usb_net_manager.h index 840b37e29..652b57915 100755 --- a/framework/model/usb/include/hdf_usb_net_manager.h +++ b/framework/model/usb/include/hdf_usb_net_manager.h @@ -20,7 +20,6 @@ #define FLAG_FRAMING_NC 0x0001 /* guard against device dropouts */ #define FLAG_FRAMING_GL 0x0002 /* genelink batches packets */ #define FLAG_FRAMING_Z 0x0004 /* zaurus adds a trailer */ -#define FLAG_FRAMING_RN 0x0008 /* huge header */ #define HDF_FLAG_NO_SETINT 0x0010 /* device can't set_interface() */ #define HDF_FLAG_ETHER 0x0020 /* maybe use "eth%d" names */ -- Gitee