1 /*
2 * Copyright (c) 2024 Archermind Technology (Nanjing) Co. Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <linux/etherdevice.h>
16 #include <linux/netdevice.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/etherdevice.h>
19
20 #include <linux/ethtool.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/version.h>
23 #if defined(CONFIG_DRIVERS_HDF_IMX8MM_ETHERNET)
24 #include <linux/phy.h>
25 #include <linux/of_mdio.h>
26 #endif
27
28 #include <net/ip.h>
29 #if LINUX_VERSION_CODE < KERNEL_VERSION(6, 6, 0)
30 #include <stddef.h>
31 #else
32 #include <linux/stddef.h>
33 #endif
34 #include "osal_mem.h"
35 #include "securec.h"
36
37 #include "hdf_device_desc.h"
38 #include "usb_net_adapter.h"
39
40 #define HDF_LOG_TAG UsbnetAdapter
41 #define TX_TIMEOUT_JIFFIES (5*HZ)
42 #define RNDIS_MSG_PACKET 0x00000001 /* 1-N packets */
43
44 // between wakeups
45 #define UNLINK_TIMEOUT_MS 3
46 #define PKT_COUNT_CLEAR 30
47 #define PKT_COUNT_RXKILL 20
48 #define SHIFT_LINE_NUM 32
49
50 /* use ethtool to change the level for any given device */
51 static int g_msgLevel = -1;
52 MODULE_PARAM(g_msgLevel, int, 0);
53 MODULE_PARM_DESC(g_msgLevel, "Override default message level");
54
UsbnetAdapterGetTxQlen(struct UsbnetAdapter * usbNet)55 static inline int UsbnetAdapterGetTxQlen(struct UsbnetAdapter *usbNet)
56 {
57 return usbNet->usbnetInfo.txQlen;
58 }
59
printf_char_buffer(char * buff,int size,bool isPrint)60 static int printf_char_buffer(char *buff, int size, bool isPrint)
61 {
62 if (isPrint) {
63 int i = 0;
64 printk("===-harch-=== printf_char_buffer begin\n");
65 for (i = 0; i < size; i++) {
66 printk(KERN_CONT"%02x ", buff[i]);
67 if ((i + 1) % SHIFT_LINE_NUM == 0) {
68 printk(KERN_CONT"\n");
69 }
70 }
71 printk("===-harch-=== printf_char_buffer end\n");
72 }
73 return 0;
74 }
75
UsbnetAdapterSendBufToUsb(const struct HdfDeviceObject * device,uint32_t id,const void * buf,uint32_t writeSize)76 static int32_t UsbnetAdapterSendBufToUsb(const struct HdfDeviceObject *device, uint32_t id,
77 const void *buf, uint32_t writeSize)
78 {
79 HARCH_NET_INFO_PRINT("writeSize=%d", writeSize);
80 int32_t ret = HDF_SUCCESS;
81 if ((device == NULL) || (buf == NULL)) {
82 HDF_LOGE("%s param is null", __func__);
83 return HDF_ERR_INVALID_PARAM;
84 }
85
86 struct HdfSBuf *data = HdfSbufObtainDefaultSize();
87 if (data == NULL) {
88 HDF_LOGE("fail to obtain sbuf data");
89 return HDF_FAILURE;
90 }
91
92 if (!HdfSbufWriteBuffer(data, buf, writeSize)) {
93 HDF_LOGE("fail to write sbuf");
94 ret = HDF_FAILURE;
95 goto out;
96 }
97
98 if (HdfDeviceSendEvent(device, id, data) != HDF_SUCCESS) {
99 HDF_LOGE("%s: send sensor data event failed", __func__);
100 ret = HDF_FAILURE;
101 goto out;
102 }
103 ret = HDF_SUCCESS;
104
105 out:
106 HdfSbufRecycle(data);
107 return ret;
108 }
109
RxComplete(WorkStruct * work)110 static void RxComplete(WorkStruct *work)
111 {
112 unsigned long flags = 0;
113 struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, RxCompleteWorkqueue);
114 PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64);
115
116 HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu",
117 stats64->rx_packets, stats64->rx_bytes);
118
119 HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu",
120 stats64->tx_packets, stats64->tx_bytes);
121
122 flags = u64_stats_update_begin_irqsave(&stats64->syncp);
123 #if LINUX_VERSION_CODE < KERNEL_VERSION(6, 6, 0)
124 stats64->rx_packets++;
125 stats64->rx_bytes += usbNet->rxLen;
126 #else
127 u64_stats_inc(&stats64->rx_packets);
128 u64_stats_add(&stats64->rx_bytes, usbNet->rxLen);
129 #endif
130 u64_stats_update_end_irqrestore(&stats64->syncp, flags);
131
132 HARCH_NET_INFO_PRINT("rx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu",
133 stats64->rx_packets, stats64->rx_bytes);
134
135 HARCH_NET_INFO_PRINT("rx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu",
136 stats64->tx_packets, stats64->tx_bytes);
137 }
138
139 /* Passes this packet up the stack, updating its accounting.
140 * Some link protocols batch packets, so their rx_fixup paths
141 * can return clones as well as just modify the original skb.
142 */
UsbnetAdapterSkbReturn(struct UsbnetAdapter * usbNet,SkBuff * skb)143 static void UsbnetAdapterSkbReturn(struct UsbnetAdapter *usbNet, SkBuff *skb)
144 {
145 if (test_bit(EVENT_RX_PAUSED, &usbNet->flags)) {
146 skb_queue_tail(&usbNet->rxqPause, skb);
147 return;
148 }
149
150 /* only update if unset to allow minidriver rx_fixup override */
151 if (skb->protocol == 0) {
152 skb->protocol = eth_type_trans (skb, usbNet->net);
153 }
154
155 usbNet->rxLen = skb->len;
156 schedule_work_on(0, &usbNet->RxCompleteWorkqueue);
157 HARCH_NET_INFO_PRINT("< rx, len %zu, type 0x%x\n", skb->len + sizeof (struct ethhdr), skb->protocol);
158 (void)memset_s(skb->cb, sizeof(struct SkbData), 0, sizeof(struct SkbData));
159
160 if (skb_defer_rx_timestamp(skb)) {
161 return;
162 }
163 HARCH_NET_INFO_PRINT("-------rx before netif_rx");
164 printf_char_buffer(skb->data, skb->len, false);
165
166 int status = NET_RX_SUCCESS;
167 status = netif_rx (skb);
168
169 HARCH_NET_INFO_PRINT("netif_rx status %d\n", status);
170 if (status != NET_RX_SUCCESS) {
171 HARCH_NET_INFO_PRINT("netif_rx status %d\n", status);
172 }
173 }
174
175
176 /*
177 * DATA -- host must not write zlps
178 */
RndisRxFixup(struct UsbnetAdapter * usbNet,SkBuff * skb)179 static int RndisRxFixup(struct UsbnetAdapter *usbNet, SkBuff *skb)
180 {
181 /* This check is no longer done by usbnet */
182 if (skb->len < usbNet->net->hard_header_len) {
183 return 0;
184 }
185 /* peripheral may have batched packets to us... */
186 while (likely(skb->len)) {
187 RndisDataHdr *hdr = (void *)skb->data;
188 SkBuff *skb2 = NULL;
189 u32 msg_type = 0;
190 u32 msg_len = 0;
191 u32 data_len = 0;
192 u32 data_offset = 0;
193
194 msg_type = le32_to_cpu(hdr->msg_type);
195 msg_len = le32_to_cpu(hdr->msg_len);
196 data_offset = le32_to_cpu(hdr->data_offset);
197 data_len = le32_to_cpu(hdr->data_len);
198 unsigned int totalLen = data_offset + data_len + 8;
199
200 /* don't choke if we see oob, per-packet data, etc */
201 if (unlikely(msg_type != RNDIS_MSG_PACKET || skb->len < msg_len
202 || totalLen > msg_len)) {
203 usbNet->net->stats.rx_frame_errors++;
204 netdev_dbg(usbNet->net, "bad rndis message %d/%d/%d/%d, len %d\n",
205 le32_to_cpu(hdr->msg_type), msg_len, data_offset, data_len, skb->len);
206 return 0;
207 }
208 unsigned int offset = 8 + data_offset;
209 skb_pull(skb, offset);
210
211 /* at most one packet left? */
212 if (likely((data_len - skb->len) <= sizeof(RndisDataHdr))) {
213 skb_trim(skb, data_len);
214 break;
215 }
216
217 /* try to return all the packets in the batch */
218 skb2 = skb_clone(skb, GFP_ATOMIC);
219 if (unlikely(!skb2)) {
220 break;
221 }
222 skb_pull(skb, msg_len - sizeof(RndisDataHdr));
223 skb_trim(skb2, data_len);
224 UsbnetAdapterSkbReturn(usbNet, skb2);
225 }
226 return 1;
227 }
228
UsbnetAdapterRxProcess(struct UsbnetAdapter * usbNet,SkBuff * skb)229 static void UsbnetAdapterRxProcess(struct UsbnetAdapter *usbNet, SkBuff *skb)
230 {
231 HARCH_NET_INFO_PRINT("-------rx before fix");
232 printf_char_buffer(skb->data, skb->len, false);
233
234 if (!RndisRxFixup(usbNet, skb)) {
235 /* With RX_ASSEMBLE, rx_fixup() must update counters */
236 if (!(usbNet->usbnetInfo.usbFlags & FLAG_RX_ASSEMBLE)) {
237 usbNet->net->stats.rx_errors++;
238 }
239 goto done;
240 }
241 // else network stack removes extra byte if we forced a short packet
242 HARCH_NET_INFO_PRINT("--------rx after fix");
243 printf_char_buffer(skb->data, skb->len, false);
244
245 /* all data was already cloned from skb inside the driver */
246 if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) {
247 HARCH_NET_INFO_PRINT("usbNet->driver_info->flags = %d", usbNet->usbnetInfo.usbFlags);
248 goto done;
249 }
250
251 if (skb->len < ETH_HLEN) {
252 usbNet->net->stats.rx_errors++;
253 usbNet->net->stats.rx_length_errors++;
254 HARCH_NET_INFO_PRINT("rx length %d\n", skb->len);
255 } else {
256 HARCH_NET_INFO_PRINT("UsbnetAdapterSkbReturn");
257 UsbnetAdapterSkbReturn(usbNet, skb);
258 return;
259 }
260
261 done:
262 skb_queue_tail(&usbNet->done, skb);
263 }
264
UsbnetAdapterBh(TimerList * t)265 static void UsbnetAdapterBh(TimerList *t)
266 {
267 HARCH_NET_INFO_PRINT("begin");
268 struct UsbnetAdapter *usbNet = from_timer(usbNet, t, delay);
269
270 SkBuff *skb = NULL;
271 struct SkbData *entry = NULL;
272
273 while ((skb = skb_dequeue (&usbNet->done))) {
274 entry = (struct SkbData *) skb->cb;
275 HARCH_NET_INFO_PRINT("entry->state = %d", entry->state);
276
277 switch (entry->state) {
278 case RX_DONE:
279 HARCH_NET_INFO_PRINT("rx_done");
280 entry->state = RX_CLEANUP;
281 UsbnetAdapterRxProcess (usbNet, skb);
282 continue;
283 case TX_DONE:
284 HARCH_NET_INFO_PRINT("tx_done");
285 /* fall-through */
286 fallthrough;
287 case RX_CLEANUP:
288 HARCH_NET_INFO_PRINT("rx_cleanup");
289 dev_kfree_skb (skb);
290 continue;
291 default:
292 HARCH_NET_INFO_PRINT("bogus skb state %d\n", entry->state);
293 /* fall-through */
294 }
295 }
296 HARCH_NET_INFO_PRINT();
297 /* restart RX again after disabling due to high error rate */
298 clear_bit(EVENT_RX_KILL, &usbNet->flags);
299
300 /* waiting for all pending urbs to complete?
301 * only then can we forgo submitting anew
302 */
303 if (waitqueue_active(&usbNet->wait)) {
304 HARCH_NET_INFO_PRINT("waitqueue_active");
305 if (usbNet->rxq.qlen + usbNet->txq.qlen + usbNet->done.qlen == 0) {
306 HARCH_NET_INFO_PRINT();
307 wake_up_all(&usbNet->wait);
308 }
309 }
310
311 if (usbNet->txq.qlen < UsbnetAdapterGetTxQlen(usbNet)) {
312 netif_wake_queue (usbNet->net);
313 HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",
314 usbNet->txq.qlen, UsbnetAdapterGetTxQlen(usbNet));
315 }
316 HARCH_NET_INFO_PRINT("end");
317 }
318
UsbnetAdapterBhTasklet(unsigned long data)319 static void UsbnetAdapterBhTasklet(unsigned long data)
320 {
321 HARCH_NET_INFO_PRINT("begin");
322 TimerList *t = (TimerList *)data;
323
324 UsbnetAdapterBh(t);
325 HARCH_NET_INFO_PRINT("end");
326 }
327
328 /* The caller must hold list->lock */
UsbnetAdapterQueueSkb(SkBuffHead * list,SkBuff * newsk,enum SkbState state)329 static void UsbnetAdapterQueueSkb(SkBuffHead *list,
330 SkBuff *newsk, enum SkbState state)
331 {
332 struct SkbData *entry = (struct SkbData *) newsk->cb;
333
334 __skb_queue_tail(list, newsk);
335 entry->state = state;
336 }
337
UsbnetAdapterDeferBh(struct UsbnetAdapter * usbNet,SkBuff * skb,SkBuffHead * list,enum SkbState state)338 static enum SkbState UsbnetAdapterDeferBh(struct UsbnetAdapter *usbNet, SkBuff *skb,
339 SkBuffHead *list, enum SkbState state)
340 {
341 unsigned long flags = 0;
342 enum SkbState old_state = ILLEGAL;
343 struct SkbData *entry = (struct SkbData *) skb->cb;
344
345 spin_lock_irqsave(&list->lock, flags);
346 old_state = entry->state;
347 entry->state = state;
348 __skb_unlink(skb, list);
349
350 /* UsbnetAdapterDeferBh() is never called with list == &usbNet->done.
351 * spin_lock_nested() tells lockdep that it is OK to take
352 * usbNet->done.lock here with list->lock held.
353 */
354 spin_lock_nested(&usbNet->done.lock, SINGLE_DEPTH_NESTING);
355
356 __skb_queue_tail(&usbNet->done, skb);
357 if (usbNet->done.qlen == 1) {
358 tasklet_schedule(&usbNet->bh);
359 }
360
361 spin_unlock(&usbNet->done.lock);
362 spin_unlock_irqrestore(&list->lock, flags);
363 return old_state;
364 }
365
UsbnetAdapterOpen(NetDevice * net)366 static int32_t UsbnetAdapterOpen(NetDevice *net)
367 {
368 HARCH_NET_INFO_PRINT("begin");
369 if (NULL == net) {
370 HDF_LOGE("net device object is invalid");
371 return HDF_FAILURE;
372 }
373 struct UsbnetAdapter *usbNet = netdev_priv(net);
374 if (NULL == usbNet) {
375 HDF_LOGE("usb net adapter object is invalid");
376 return HDF_FAILURE;
377 }
378
379 set_bit(EVENT_DEV_OPEN, &usbNet->flags);
380
381 netif_start_queue (net);
382
383 /* set device param, if find usb net host need, then it should send to it */
384 /* reset rx error state */
385 usbNet->pktCnt = 0;
386 usbNet->pktErr = 0;
387 clear_bit(EVENT_RX_KILL, &usbNet->flags);
388
389 /* send info to usb start usb function */
390 /* need transform usb_net_host change about usbNet->driverInfo->flags and set it on usb_net_host */
391 OsalMutexLock(&usbNet->sendSkbClock);
392 int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_OPEN_USB,
393 (const void *)&usbNet->flags, sizeof(usbNet->flags));
394 if (ret != HDF_SUCCESS) {
395 HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!");
396 OsalMutexUnlock(&usbNet->sendSkbClock);
397 return HDF_FAILURE;
398 }
399 OsalMutexUnlock(&usbNet->sendSkbClock);
400
401 tasklet_schedule (&usbNet->bh);
402 return HDF_SUCCESS;
403 }
404
WaitSkbQueueEmpty(SkBuffHead * q)405 static void WaitSkbQueueEmpty(SkBuffHead *q)
406 {
407 unsigned long flags = 0;
408 HARCH_NET_INFO_PRINT();
409 spin_lock_irqsave(&q->lock, flags);
410 while (!skb_queue_empty(q)) {
411 spin_unlock_irqrestore(&q->lock, flags);
412 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
413 set_current_state(TASK_UNINTERRUPTIBLE);
414 spin_lock_irqsave(&q->lock, flags);
415 }
416 spin_unlock_irqrestore(&q->lock, flags);
417 }
418
419 // precondition: never called in_interrupt
UsbnetAdapterTerminateUrbs(struct UsbnetAdapter * usbNet)420 static void UsbnetAdapterTerminateUrbs(struct UsbnetAdapter *usbNet)
421 {
422 HARCH_NET_INFO_PRINT();
423
424 DECLARE_WAITQUEUE(wait, current);
425 /* ensure there are no more active urbs */
426 add_wait_queue(&usbNet->wait, &wait);
427 set_current_state(TASK_UNINTERRUPTIBLE);
428 /* maybe wait for deletions to finish. */
429 WaitSkbQueueEmpty(&usbNet->rxq);
430 WaitSkbQueueEmpty(&usbNet->txq);
431
432 WaitSkbQueueEmpty(&usbNet->done);
433 set_current_state(TASK_RUNNING);
434 remove_wait_queue(&usbNet->wait, &wait);
435 }
436
UsbnetAdapterStop(NetDevice * net)437 static int32_t UsbnetAdapterStop(NetDevice *net)
438 {
439 HARCH_NET_INFO_PRINT("begin");
440 if (NULL == net) {
441 HDF_LOGE("net device object is invalid");
442 return HDF_FAILURE;
443 }
444
445 struct UsbnetAdapter *usbNet = netdev_priv(net);
446 if (NULL == usbNet) {
447 HDF_LOGE("usb net adapter object is invalid");
448 return HDF_FAILURE;
449 }
450
451 PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64);
452
453 HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu",
454 stats64->rx_packets, stats64->rx_bytes);
455
456 HARCH_NET_INFO_PRINT("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu",
457 stats64->tx_packets, stats64->tx_bytes);
458
459 /* 1. clear_bit EVENT_DEV_OPEN dev->flags */
460 clear_bit(EVENT_DEV_OPEN, &usbNet->flags);
461 /* 2. netif_stop_queue net */
462 netif_stop_queue (net);
463 HARCH_NET_INFO_PRINT("stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
464 net->stats.rx_packets, net->stats.tx_packets,
465 net->stats.rx_errors, net->stats.tx_errors);
466
467 /* 3. pm = usb_autopm_get_interface(dev->intf); do nothing */
468 /* 4. if (info->stop) { no stop interface impl in rndis driver info */
469 /* 5. if (!(info->flags & FLAG_AVOID_UNLINK_URBS)) do nothing*/
470 if (!(usbNet->usbnetInfo.usbFlags & FLAG_AVOID_UNLINK_URBS)) {
471 UsbnetAdapterTerminateUrbs(usbNet);
472 }
473
474 /* 6. usbnet_status_stop none */
475 /* 7. usbnet_purge_paused_rxq none */
476 skb_queue_purge(&usbNet->rxqPause);
477 /* 8. test_and_clear_bit and no manage_power interface impl in rndis driver info*/
478 /* 9. dev flags */
479 usbNet->flags = 0;
480 OsalMutexLock(&usbNet->sendSkbClock);
481 int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_CLOSE_USB,
482 (const void *)&usbNet->flags, sizeof(usbNet->flags));
483 if (ret != HDF_SUCCESS) {
484 HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!");
485 OsalMutexUnlock(&usbNet->sendSkbClock);
486 return HDF_FAILURE;
487 }
488 OsalMutexUnlock(&usbNet->sendSkbClock);
489 /* 10. del_timer_sync */
490 del_timer_sync (&usbNet->delay);
491 /* 11. tasklet_kill */
492 tasklet_kill (&usbNet->bh);
493 /* 12. cancel_work_sync dev->kevent */
494 cancel_work_sync(&usbNet->TxCompleteWorkqueue);
495 cancel_work_sync(&usbNet->RxCompleteWorkqueue);
496 return HDF_SUCCESS;
497 }
498
RndisTxFixup(SkBuff * skb,gfp_t flags)499 static SkBuff *RndisTxFixup(SkBuff *skb, gfp_t flags)
500 {
501 RndisDataHdr *hdr = NULL;
502 SkBuff *skb2 = NULL;
503 unsigned len = skb->len;
504
505 if (likely(!skb_cloned(skb))) {
506 int room = skb_headroom(skb);
507 /* enough head room as-is? */
508 if (unlikely((sizeof(RndisDataHdr)) <= room)) {
509 goto fill;
510 }
511 /* enough room, but needs to be readjusted? */
512 room += skb_tailroom(skb);
513 if (likely((sizeof(RndisDataHdr)) <= room)) {
514 skb->data = memmove_s(skb->head + sizeof(RndisDataHdr), len, skb->data, len);
515 skb_set_tail_pointer(skb, len);
516 goto fill;
517 }
518 }
519
520 /* create a new skb, with the correct size (and tailpad) */
521 skb2 = skb_copy_expand(skb, sizeof(RndisDataHdr), 1, flags);
522 dev_kfree_skb_any(skb);
523 if (unlikely(!skb2)) {
524 return skb2;
525 }
526 skb = skb2;
527
528 /* fill out the RNDIS header. we won't bother trying to batch
529 * packets; Linux minimizes wasted bandwidth through tx queues.
530 */
531 fill:
532 HARCH_NET_INFO_PRINT("%s:%d fill skb by rndis host", __func__, __LINE__);
533 hdr = __skb_push(skb, sizeof(*hdr));
534 (void)memset_s(hdr, sizeof(*hdr), 0, sizeof(*hdr));
535 hdr->msg_type = cpu_to_le32(RNDIS_MSG_PACKET);
536 hdr->msg_len = cpu_to_le32(skb->len);
537 unsigned int offset = sizeof(*hdr) - 8;
538 hdr->data_offset = cpu_to_le32(offset);
539 hdr->data_len = cpu_to_le32(len);
540
541 return skb;
542 }
543
TxComplete(WorkStruct * work)544 static void TxComplete(WorkStruct *work)
545 {
546 unsigned long flags = 0;
547 struct UsbnetAdapter *usbNet = container_of(work, struct UsbnetAdapter, TxCompleteWorkqueue);
548 PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64);
549 HARCH_NET_INFO_PRINT ("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu",
550 stats64->rx_packets, stats64->rx_bytes);
551
552 HARCH_NET_INFO_PRINT ("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu",
553 stats64->tx_packets, stats64->tx_bytes);
554
555 flags = u64_stats_update_begin_irqsave(&stats64->syncp);
556 #if LINUX_VERSION_CODE < KERNEL_VERSION(6, 6, 0)
557 stats64->tx_packets++;
558 stats64->tx_bytes += usbNet->txLen;
559 #else
560 u64_stats_inc(&stats64->tx_packets);
561 u64_stats_add(&stats64->tx_bytes, usbNet->txLen);
562 #endif
563 u64_stats_update_end_irqrestore(&stats64->syncp, flags);
564
565 HARCH_NET_INFO_PRINT ("tx_complete stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu",
566 stats64->rx_packets, stats64->rx_bytes);
567
568 HARCH_NET_INFO_PRINT ("tx_complete stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu",
569 stats64->tx_packets, stats64->tx_bytes);
570 }
571
UsbnetAdapterStartXmit(SkBuff * skb,NetDevice * net)572 static netdev_tx_t UsbnetAdapterStartXmit(SkBuff *skb, NetDevice *net)
573 {
574 HARCH_NET_INFO_PRINT ("netif_running=%d, netif_device_present=%d, netif_carrier_ok=%d", netif_running(net),
575 netif_device_present(net), netif_carrier_ok(net));
576 HARCH_NET_INFO_PRINT ("skb->data = %x, len = %d", skb->data, skb->len);
577 struct UsbnetAdapter *usbNet = netdev_priv(net);
578 //1.time tamp
579 if (skb) {
580 skb_tx_timestamp(skb);
581 }
582 //2.fix up
583 SkBuff* skbFixup = RndisTxFixup(skb, GFP_ATOMIC);
584 if (NULL == skbFixup) {
585 if (usbNet->usbnetInfo.usbFlags & FLAG_MULTI_PACKET) {
586 goto not_drop;
587 }
588 HDF_LOGE("fail to tx fixup by rndis host");
589 goto drop;
590 }
591 HARCH_NET_INFO_PRINT("skb_fixup->data = %x, len = %d", skbFixup->data, skbFixup->len);
592 /* print org skb data info */
593 printf_char_buffer(skbFixup->data, skbFixup->len, false);
594 //3.send msg to usb
595 unsigned long flags = 0;
596 spin_lock_irqsave(&usbNet->txq.lock, flags);
597 if (netif_queue_stopped(usbNet->net)) {
598 goto drop;
599 }
600
601 int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_SEND_DATA_TO_USB,
602 (unsigned char *)(skbFixup->data), skbFixup->len);
603 if (ret != HDF_SUCCESS) {
604 HDF_LOGE("fail to UsbnetHost SendEvent!");
605 drop:
606 net->stats.tx_dropped++;
607 not_drop:
608 spin_unlock_irqrestore(&usbNet->txq.lock, flags);
609 if (skbFixup) {
610 dev_kfree_skb_any (skbFixup);
611 }
612 } else {
613 netif_trans_update(usbNet->net);
614 UsbnetAdapterQueueSkb(&usbNet->txq, skbFixup, TX_START);
615
616 if (usbNet->txq.qlen >= UsbnetAdapterGetTxQlen(usbNet)) {
617 HARCH_NET_INFO_PRINT("usbNet->txq.qlen = %d, TX_QLEN (usbNet) = %d",
618 usbNet->txq.qlen, UsbnetAdapterGetTxQlen(usbNet));
619 netif_stop_queue (usbNet->net);
620 }
621 spin_unlock_irqrestore(&usbNet->txq.lock, flags);
622 usbNet->txLen = skbFixup->len;
623 schedule_work_on(0, &usbNet->TxCompleteWorkqueue);
624
625 enum SkbState state = UsbnetAdapterDeferBh(usbNet, skbFixup, &usbNet->txq, TX_DONE);
626 HARCH_NET_INFO_PRINT("state= %d", state);
627 }
628 return NETDEV_TX_OK;
629 }
630
UsbnetAdapterTXTimeout(NetDevice * net,unsigned int txqueue)631 static void UsbnetAdapterTXTimeout(NetDevice *net, unsigned int txqueue)
632 {
633 //send to device
634 HARCH_NET_INFO_PRINT("begin");
635 if (NULL == net) {
636 HDF_LOGE("%s net device object is invalid", __func__);
637 return;
638 }
639 struct UsbnetAdapter *usbNet = netdev_priv(net);
640 if (NULL == usbNet) {
641 HDF_LOGE("%s UsbnetAdapter object is invalid", __func__);
642 return;
643 }
644 /* 1. unlink_urbs (dev, &dev->txq); maybe later be used */
645
646 /* 2. tasklet_schedule (&dev->bh) */
647 tasklet_schedule (&usbNet->bh);
648
649 /* 3. if (dev->driver_info->recover) none, rndis host no recover impl */
650
651 return;
652 }
653
654 /* some work can't be done in tasklets, so we use keventd
655 *
656 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
657 * but tasklet_schedule() doesn't. hope the failure is rare.
658 */
UsbnetAdapterDeferKevent(struct UsbnetAdapter * usbNet,int work)659 static void UsbnetAdapterDeferKevent(struct UsbnetAdapter *usbNet, int work)
660 {
661 HARCH_NET_INFO_PRINT("begin");
662 if (NULL == usbNet) {
663 HDF_LOGE("%s UsbnetAdapter object is invalid", __func__);
664 return;
665 }
666 set_bit (work, &usbNet->flags);
667 /* need update flags to usb_net_host */
668 OsalMutexLock(&usbNet->sendSkbClock);
669 int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS,
670 (const void *)&usbNet->flags, sizeof(usbNet->flags));
671 if (ret != HDF_SUCCESS) {
672 HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!");
673 OsalMutexUnlock(&usbNet->sendSkbClock);
674 return;
675 }
676 OsalMutexUnlock(&usbNet->sendSkbClock);
677
678 if (!schedule_work (&usbNet->kevent)) {
679 HARCH_NET_INFO_PRINT("kevent %d may have been dropped\n", work);
680 } else {
681 HARCH_NET_INFO_PRINT("kevent %d scheduled\n", work);
682 }
683 }
684
UsbnetAdapterSetRxMode(NetDevice * net)685 static void UsbnetAdapterSetRxMode(NetDevice *net)
686 {
687 return;
688 }
689
UsbnetAdapterPauseRx(struct UsbnetAdapter * usbNet)690 static void UsbnetAdapterPauseRx(struct UsbnetAdapter *usbNet)
691 {
692 HARCH_NET_INFO_PRINT("begin");
693 if (NULL == usbNet) {
694 HDF_LOGE("%s UsbnetAdapter object is invalid", __func__);
695 return;
696 }
697 set_bit(EVENT_RX_PAUSED, &usbNet->flags);
698 /* need update flags to usb_net_host */
699 OsalMutexLock(&usbNet->sendSkbClock);
700 int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS,
701 (const void *)&usbNet->flags, sizeof(usbNet->flags));
702 if (ret != HDF_SUCCESS) {
703 HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!");
704 OsalMutexUnlock(&usbNet->sendSkbClock);
705 return;
706 }
707 OsalMutexUnlock(&usbNet->sendSkbClock);
708
709 HARCH_NET_INFO_PRINT("paused rx queue enabled\n");
710 }
711
UsbnetAdapterUnlinkRxUrbs(struct UsbnetAdapter * usbNet)712 static void UsbnetAdapterUnlinkRxUrbs(struct UsbnetAdapter *usbNet)
713 {
714 HARCH_NET_INFO_PRINT("begin");
715 if (NULL == usbNet) {
716 HDF_LOGE("%s UsbnetAdapter object is invalid", __func__);
717 return;
718 }
719
720 if (netif_running(usbNet->net)) {
721 /* unlink_urbs usbNet usbNet->rxq */
722 tasklet_schedule(&usbNet->bh);
723 }
724 }
725
UsbnetAdapterResumeRx(struct UsbnetAdapter * usbNet)726 static void UsbnetAdapterResumeRx(struct UsbnetAdapter *usbNet)
727 {
728 HARCH_NET_INFO_PRINT("begin");
729 int num = 0;
730 SkBuff *skb = NULL;
731 if (NULL == usbNet) {
732 HDF_LOGE("%s UsbnetAdapter object is invalid", __func__);
733 return;
734 }
735
736 clear_bit(EVENT_RX_PAUSED, &usbNet->flags);
737 /* need update flags to usb_net_host */
738 OsalMutexLock(&usbNet->sendSkbClock);
739 int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_FLAGS,
740 (const void *)&usbNet->flags, sizeof(usbNet->flags));
741 if (ret != HDF_SUCCESS) {
742 HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!");
743 OsalMutexUnlock(&usbNet->sendSkbClock);
744 return;
745 }
746 OsalMutexUnlock(&usbNet->sendSkbClock);
747
748 while ((skb = skb_dequeue(&usbNet->rxqPause)) != NULL) {
749 UsbnetAdapterSkbReturn(usbNet, skb);
750 num++;
751 }
752
753 tasklet_schedule(&usbNet->bh);
754 HARCH_NET_INFO_PRINT("paused rx queue disabled, %d skbs requeued\n", num);
755 }
756
757
UsbnetAdapterChangeMtu(NetDevice * net,int newMtu)758 static int32_t UsbnetAdapterChangeMtu(NetDevice *net, int newMtu)
759 {
760 //send to device
761 HARCH_NET_INFO_PRINT("begin");
762 if (NULL == net) {
763 HDF_LOGE("%s net device object is invalid", __func__);
764 return HDF_FAILURE;
765 }
766
767 struct UsbnetAdapter *usbNet = netdev_priv(net);
768 if (NULL == usbNet) {
769 HDF_LOGE("%s UsbnetAdapter object is invalid", __func__);
770 return HDF_FAILURE;
771 }
772
773 /* 1. ll_mtu old_hard_mtu old_rx_urb_size */
774 HARCH_NET_INFO_PRINT("newMtu:%d", newMtu);
775 int llMtu = newMtu + net->hard_header_len;
776 int oldHardMtu = usbNet->usbnetInfo.hardMtu;
777 int oldRxUrbSize = usbNet->usbnetInfo.rxUrbSize;
778
779 /* 2. no second zero-length packet read wanted after mtu-sized packets */
780 if ((llMtu % usbNet->usbnetInfo.maxpacket) == 0) {
781 HARCH_NET_INFO_PRINT("");
782 return -EDOM;
783 }
784
785 /* 3. set usbNet->hard_mtu */
786 net->mtu = newMtu;
787 usbNet->usbnetInfo.hardMtu = net->mtu + net->hard_header_len;
788
789 /* 4. pause and resume usbnet */
790 if (usbNet->usbnetInfo.rxUrbSize == oldHardMtu) {
791 usbNet->usbnetInfo.rxUrbSize = usbNet->usbnetInfo.hardMtu;
792 if (usbNet->usbnetInfo.rxUrbSize > oldRxUrbSize) {
793 UsbnetAdapterPauseRx(usbNet);
794 UsbnetAdapterUnlinkRxUrbs(usbNet);
795 UsbnetAdapterResumeRx(usbNet);
796 }
797 }
798
799 /* need transmit hard_mtu to usb net host, UsbnetHostUpdateMaxQlen need this param */
800 HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x mtu = %d, hardHeaderLen = %d,\
801 link = %d needReset = %d, hardMtu = %d, rxUrbSize = %d, maxpacket =%d",
802 usbNet->usbnetInfo.name,usbNet->usbnetInfo.flags,usbNet->usbnetInfo.usbFlags,\
803 usbNet->usbnetInfo.mtu,usbNet->usbnetInfo.hardHeaderLen,usbNet->usbnetInfo.link,\
804 usbNet->usbnetInfo.needReset,usbNet->usbnetInfo.hardMtu,usbNet->usbnetInfo.rxUrbSize,\
805 usbNet->usbnetInfo.maxpacket);
806 /* 5. max qlen depend on hard_mtu and rx_urb_size */
807 /* need update flags to usb_net_host */
808 OsalMutexLock(&usbNet->sendSkbClock);
809 int32_t ret = UsbnetAdapterSendBufToUsb(usbNet->deviceObject, USB_NET_UPDATE_MAXQLEN,
810 (const void *)&usbNet->usbnetInfo, sizeof(usbNet->usbnetInfo));
811 if (ret != HDF_SUCCESS) {
812 HDF_LOGE("fail to UsbnetAdapterSendBufToUsb SendEvent!");
813 OsalMutexUnlock(&usbNet->sendSkbClock);
814 return ret;
815 }
816 OsalMutexUnlock(&usbNet->sendSkbClock);
817 return HDF_SUCCESS;
818 }
819
UsbnetAdapterGetStats64(NetDevice * net,struct rtnl_link_stats64 * stats)820 static void UsbnetAdapterGetStats64(NetDevice *net, struct rtnl_link_stats64 *stats)
821 {
822 //send to device
823 HARCH_NET_INFO_PRINT("begin");
824
825 struct UsbnetAdapter *usbNet = netdev_priv(net);
826 netdev_stats_to_stats64(stats, &net->stats);
827 dev_fetch_sw_netstats(stats, usbNet->stats64);
828
829 PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64);
830
831 HARCH_NET_INFO_PRINT ("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu",
832 stats64->rx_packets, stats64->rx_bytes);
833
834 HARCH_NET_INFO_PRINT ("usbNet stats64->tx_packets = %lu,usbNet stats64->tx_bytes = %lu",
835 stats64->tx_packets, stats64->tx_bytes);
836
837 HARCH_NET_INFO_PRINT("end");
838 return;
839 }
840
841 static NetDeviceOps g_UsbnetAdapterDeviceOps = {
842 .ndo_open = UsbnetAdapterOpen,
843 .ndo_stop = UsbnetAdapterStop,
844 .ndo_start_xmit = UsbnetAdapterStartXmit,
845 .ndo_tx_timeout = UsbnetAdapterTXTimeout,
846 .ndo_set_rx_mode = UsbnetAdapterSetRxMode,
847 .ndo_change_mtu = UsbnetAdapterChangeMtu,
848 .ndo_get_stats64 = UsbnetAdapterGetStats64,
849 .ndo_set_mac_address = eth_mac_addr,
850 .ndo_validate_addr = eth_validate_addr,
851 };
852
853 /* drivers may override default ethtool_ops in their bind() routine */
854 static const EthtoolOps g_UsbnetAdapterEthtoolOps = {
855 };
856
UsbnetAdapterLinkChange(struct UsbnetAdapter * usbNet,bool link,bool need_reset)857 static void UsbnetAdapterLinkChange(struct UsbnetAdapter *usbNet, bool link, bool need_reset)
858 {
859 HARCH_NET_INFO_PRINT("begin");
860 /* update link after link is reseted */
861 if (link && !need_reset) {
862 netif_carrier_on(usbNet->net);
863 } else {
864 netif_carrier_off(usbNet->net);
865 }
866 }
867
UsbnetAdapterSetSkb(struct UsbnetAdapter * usbNet,gfp_t flags,uint32_t infoSize,unsigned char * buff,SkBuff * skb)868 static int32_t UsbnetAdapterSetSkb(struct UsbnetAdapter *usbNet, gfp_t flags,
869 uint32_t infoSize, unsigned char *buff, SkBuff *skb)
870 {
871 if (!skb) {
872 HARCH_NET_INFO_PRINT("no rx skb\n");
873 UsbnetAdapterDeferKevent(usbNet, EVENT_RX_MEMORY);
874 return HDF_DEV_ERR_NO_MEMORY;
875 }
876
877 skb_put(skb, infoSize);
878 if (memcpy_s(skb->data, infoSize, buff, infoSize) != EOK) {
879 HARCH_NET_INFO_PRINT("memcpy_s error ");
880 return HDF_ERR_INVALID_PARAM;
881 }
882
883 printf_char_buffer(skb->data, skb->len, false);
884 return HDF_SUCCESS;
885 }
886
UsbnetAdapterSetUsbNetInfo(struct UsbnetAdapter * usbNet,SkBuff * skb,enum SkbState state)887 static void UsbnetAdapterSetUsbNetInfo(struct UsbnetAdapter *usbNet, SkBuff *skb, enum SkbState state)
888 {
889 unsigned long lockflags = 0;
890 spin_lock_irqsave (&usbNet->rxq.lock, lockflags);
891 UsbnetAdapterQueueSkb(&usbNet->rxq, skb, RX_START);
892 spin_unlock_irqrestore (&usbNet->rxq.lock, lockflags);
893
894 PcpuSwNetstats *stats64 = this_cpu_ptr(usbNet->stats64);
895 HARCH_NET_INFO_PRINT("usbNet stats64->rx_packets = %lu,usbNet stats64->rx_bytes = %lu",
896 stats64->rx_packets, stats64->rx_bytes);
897
898 if (++usbNet->pktCnt > PKT_COUNT_CLEAR) {
899 HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d, pktErr = %d", usbNet->pktCnt, usbNet->pktErr);
900 usbNet->pktCnt = 0;
901 usbNet->pktErr = 0;
902 } else {
903 HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d,pktErr = %d", usbNet->pktCnt, usbNet->pktErr);
904 if (state == RX_CLEANUP) {
905 usbNet->pktErr++;
906 }
907
908 if (usbNet->pktErr > PKT_COUNT_RXKILL) {
909 set_bit(EVENT_RX_KILL, &usbNet->flags);
910 }
911 }
912 }
913
UsbnetAdapterRxComplete(struct HdfDeviceObject * device,struct HdfSBuf * data,gfp_t flags)914 static int32_t UsbnetAdapterRxComplete(struct HdfDeviceObject *device, struct HdfSBuf *data, gfp_t flags)
915 {
916 HARCH_NET_INFO_PRINT("begin");
917 unsigned char *buff = NULL;
918 uint32_t infoSize = 0;
919 bool flag = HdfSbufReadBuffer(data, (const void **)(&(buff)), &infoSize);
920 if ((!flag) || buff == NULL) {
921 HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag);
922 return HDF_ERR_INVALID_PARAM;
923 }
924
925 NetDevice *net = (NetDevice *)device->priv;
926 if (net == NULL) {
927 return HDF_ERR_INVALID_PARAM;
928 }
929 printf_char_buffer(buff, infoSize, false);
930 struct UsbnetAdapter *usbNet = netdev_priv(net);
931 if (usbNet == NULL) {
932 return HDF_ERR_INVALID_PARAM;
933 }
934
935 SkBuff *skb = NULL;
936 uint32_t skb_size = sizeof(struct iphdr) + sizeof(struct udphdr) + infoSize;
937 size_t size = skb_size > usbNet->usbnetInfo.rxUrbSize ? usbNet->usbnetInfo.rxUrbSize : skb_size;
938 if (test_bit(EVENT_NO_IP_ALIGN, &usbNet->flags)) {
939 skb = __netdev_alloc_skb(usbNet->net, size, flags);
940 } else {
941 skb = __netdev_alloc_skb_ip_align(usbNet->net, size, flags);
942 }
943 int32_t ret = UsbnetAdapterSetSkb(usbNet, flags, infoSize, buff, skb);
944 if (ret != HDF_SUCCESS || skb == NULL) {
945 HDF_LOGE("%s: fail to set skb, flag = %d", __func__, flag);
946 return ret;
947 }
948 HARCH_NET_INFO_PRINT("infoSize= %d, size = %d, skb->len = %d", infoSize, size, skb->len);
949
950 struct SkbData *entry = (struct SkbData *)skb->cb;
951 entry->length = 0;
952
953 //success recv
954 enum SkbState state = RX_DONE;
955 UsbnetAdapterSetUsbNetInfo(usbNet, skb, state);
956
957 state = UsbnetAdapterDeferBh(usbNet, skb, &usbNet->rxq, state);
958 HARCH_NET_INFO_PRINT("usbNet->pktCnt = %d, pktErr = %d, state = %d", usbNet->pktCnt, usbNet->pktErr, state);
959 return HDF_SUCCESS;
960 }
961
962 // precondition: never called in_interrupt
963 static DeviceType wlanType = {
964 .name = "wlan",
965 };
966
967 static DeviceType wwanType = {
968 .name = "wwan",
969 };
970
UsbnetAdapterSetUsbNet(struct HdfDeviceObject * device,NetDevice * net,struct UsbnetTransInfo * uNetTransInfo)971 static void UsbnetAdapterSetUsbNet(struct HdfDeviceObject *device,
972 NetDevice *net, struct UsbnetTransInfo *uNetTransInfo)
973 {
974 struct UsbnetAdapter *usbNet = netdev_priv(net);
975 usbNet->deviceObject = device;
976
977 //info from usb
978 if (memcpy_s(&(usbNet->usbnetInfo), sizeof(struct UsbnetTransInfo),
979 uNetTransInfo, sizeof(struct UsbnetTransInfo)) != EOK) {
980 HARCH_NET_INFO_PRINT("memcpy_s error ");
981 }
982
983 HARCH_NET_INFO_PRINT("name = %s, flags = %d, usbFlags = %x, mtu = %d, \
984 hardHeaderLen = %d, link = %d, needReset = %d, \
985 hardMtu = %d, rxUrbSize = %d, maxpacket = %d",
986 usbNet->usbnetInfo.name, usbNet->usbnetInfo.flags,
987 usbNet->usbnetInfo.usbFlags, usbNet->usbnetInfo.mtu,
988 usbNet->usbnetInfo.hardHeaderLen, usbNet->usbnetInfo.link,
989 usbNet->usbnetInfo.needReset, usbNet->usbnetInfo.hardMtu,
990 usbNet->usbnetInfo.rxUrbSize, usbNet->usbnetInfo.maxpacket);
991
992 usbNet->stats64 = netdev_alloc_pcpu_stats(PcpuSwNetstats);
993 if (!usbNet->stats64) {
994 return;
995 }
996
997 usbNet->msg_enable = netif_msg_init (g_msgLevel, NETIF_MSG_DRV
998 | NETIF_MSG_PROBE | NETIF_MSG_LINK| NETIF_MSG_RX_ERR|NETIF_MSG_TX_ERR);
999
1000 OsalMutexInit(&usbNet->sendSkbClock);
1001
1002 init_waitqueue_head(&usbNet->wait);
1003 skb_queue_head_init (&usbNet->rxq);
1004 skb_queue_head_init (&usbNet->txq);
1005 skb_queue_head_init (&usbNet->done);
1006 skb_queue_head_init(&usbNet->rxqPause);
1007
1008 // init work for tx_complete rx_complete
1009 INIT_WORK(&usbNet->TxCompleteWorkqueue, TxComplete);
1010 INIT_WORK(&usbNet->RxCompleteWorkqueue, RxComplete);
1011
1012 usbNet->bh.func = (void (*)(unsigned long))UsbnetAdapterBhTasklet;
1013 usbNet->bh.data = (unsigned long)&usbNet->delay; //TimerList delay;
1014
1015 timer_setup(&usbNet->delay, UsbnetAdapterBh, 0);
1016
1017 usbNet->net = net;
1018 }
1019
1020
UsbnetAdapterSetNetDevice(struct UsbnetAdapter * usbNet,NetDevice * net)1021 static void UsbnetAdapterSetNetDevice(struct UsbnetAdapter *usbNet, NetDevice *net)
1022 {
1023 // 1.addr
1024 static u8 node_id[ETH_ALEN];
1025 if (usbNet->usbnetInfo.isGetmacAddr) {
1026 if (memcpy_s(node_id, ETH_ALEN, usbNet->usbnetInfo.macAddr, ETH_ALEN) != EOK) {
1027 return;
1028 }
1029 } else {
1030 eth_random_addr(node_id);
1031 }
1032 memcpy_s(net->dev_addr, sizeof(node_id)/sizeof(node_id[0]), node_id, sizeof(node_id)/sizeof(node_id[0]));
1033 HARCH_NET_INFO_PRINT("macAddr addr %pM", net->dev_addr);
1034 // 2. mtu
1035 net->min_mtu = 0;
1036 net->max_mtu = ETH_MAX_MTU;
1037 net->netdev_ops = &g_UsbnetAdapterDeviceOps;
1038 net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
1039 net->ethtool_ops = &g_UsbnetAdapterEthtoolOps;
1040
1041 //3. name and mtu
1042 strcpy_s (net->name, sizeof(net->name)/sizeof(net->name[0]), "usb%d");
1043 if (usbNet->usbnetInfo.isBindDevice) {
1044 if ((usbNet->usbnetInfo.usbFlags & HDF_FLAG_ETHER) != 0 &&
1045 ((usbNet->usbnetInfo.usbFlags & HDF_FLAG_POINTTOPOINT) == 0 ||
1046 (net->dev_addr[0] & 0x02) == 0)) {
1047 HARCH_NET_INFO_PRINT();
1048 strcpy_s (net->name, sizeof(net->name)/sizeof(net->name[0]), "eth%d");
1049 }
1050
1051 /* WLAN devices should always be named "wlan%d" */
1052 if ((usbNet->usbnetInfo.usbFlags & FLAG_WLAN) != 0) {
1053 HARCH_NET_INFO_PRINT();
1054 strcpy_s(net->name, sizeof(net->name)/sizeof(net->name[0]), "wlan%d");
1055 }
1056 /* WWAN devices should always be named "wwan%d" */
1057 if ((usbNet->usbnetInfo.usbFlags & FLAG_WWAN) != 0) {
1058 HARCH_NET_INFO_PRINT();
1059 strcpy_s(net->name, sizeof(net->name)/sizeof(net->name[0]), "wwan%d");
1060 }
1061
1062 /* devices that cannot do ARP */
1063 if ((usbNet->usbnetInfo.usbFlags & FLAG_NOARP) != 0) {
1064 net->flags |= IFF_NOARP;
1065 }
1066
1067 HARCH_NET_INFO_PRINT("usbNet->usbnetInfo.mtu = %d, net->name= %s", usbNet->usbnetInfo.mtu, net->name);
1068 /* maybe the remote can't receive an Ethernet MTU */
1069 net->mtu = usbNet->usbnetInfo.mtu;
1070 net->hard_header_len = usbNet->usbnetInfo.hardHeaderLen;
1071 }
1072
1073 /* let userspace know we have a random address */
1074 if (ether_addr_equal(net->dev_addr, node_id)) {
1075 net->addr_assign_type = NET_ADDR_RANDOM;
1076 }
1077 }
1078
UsbnetAdapterProbe(struct HdfDeviceObject * device,struct HdfSBuf * data)1079 static int32_t UsbnetAdapterProbe(struct HdfDeviceObject *device, struct HdfSBuf *data)
1080 {
1081 HARCH_NET_INFO_PRINT("begin");
1082 int ret = HDF_SUCCESS;
1083 uint32_t infoSize = 0;
1084 struct UsbnetTransInfo *uNetTransInfo = NULL;
1085
1086 bool flag = HdfSbufReadBuffer(data, (const void **)(&(uNetTransInfo)), &infoSize);
1087 if ((!flag) || uNetTransInfo == NULL) {
1088 ret = HDF_ERR_INVALID_PARAM;
1089 HDF_LOGE("%s: fail to read infoTable in event data, flag = %d", __func__, flag);
1090 return ret;
1091 }
1092 NetDevice *net = alloc_etherdev(sizeof(struct UsbnetAdapter));
1093 if (net == NULL) {
1094 HARCH_NET_INFO_PRINT();
1095 goto out;
1096 }
1097 device->priv = net;
1098 struct UsbnetAdapter *usbNet = netdev_priv(net);
1099 UsbnetAdapterSetUsbNet(device, net, uNetTransInfo);
1100 UsbnetAdapterSetNetDevice(usbNet, net);
1101 HARCH_NET_INFO_PRINT("after usbNet->usbnetInfo.mtu = %d, net->name= %s", usbNet->usbnetInfo.mtu, net->name);
1102 ret = register_netdev(net);
1103 if (ret) {
1104 goto out0;
1105 }
1106 HARCH_NET_INFO_PRINT("register net %pM\n", net->dev_addr);
1107 netif_device_attach(net);
1108 HARCH_NET_INFO_PRINT("netif_device_attach net %pM\n", net->dev_addr);
1109
1110 if (usbNet->usbnetInfo.usbFlags & FLAG_LINK_INTR) {
1111 HARCH_NET_INFO_PRINT();
1112 UsbnetAdapterLinkChange(usbNet, 0, 0);
1113 }
1114 return HDF_SUCCESS;
1115
1116 out0:
1117 cancel_work_sync(&usbNet->TxCompleteWorkqueue);
1118 cancel_work_sync(&usbNet->RxCompleteWorkqueue);
1119 free_netdev(net);
1120 out:
1121 return ret;
1122 }
1123
1124
UsbnetAdapterDisconnect(struct HdfDeviceObject * device)1125 static int32_t UsbnetAdapterDisconnect(struct HdfDeviceObject *device)
1126 {
1127 HARCH_NET_INFO_PRINT("begin");
1128 if (device == NULL) {
1129 HDF_LOGI("%s: device is null", __func__);
1130 return HDF_ERR_INVALID_OBJECT;
1131 }
1132
1133 //free net
1134 NetDevice *net = (NetDevice *)device->priv;
1135 unregister_netdev (net);
1136
1137 struct UsbnetAdapter *usbNet = netdev_priv(net);
1138 if (usbNet->stats64) {
1139 free_percpu(usbNet->stats64);
1140 }
1141
1142 UsbnetAdapterTerminateUrbs(usbNet);
1143 skb_queue_purge(&usbNet->rxqPause);
1144 OsalMutexDestroy(&usbNet->sendSkbClock);
1145
1146 free_netdev(net);
1147 return HDF_SUCCESS;
1148 }
1149
UsbnetAdapterDispatch(struct HdfDeviceIoClient * client,int32_t cmd,struct HdfSBuf * data,struct HdfSBuf * reply)1150 static int32_t UsbnetAdapterDispatch(
1151 struct HdfDeviceIoClient *client, int32_t cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
1152 {
1153 HARCH_NET_INFO_PRINT("begin, received cmd = %d", cmd);
1154
1155 int32_t ret = HDF_ERR_INVALID_PARAM;
1156 switch (cmd) {
1157 case USB_NET_REGISTER_NET:
1158 //add new usbnet device
1159 ret = UsbnetAdapterProbe(client->device, data);
1160 break;
1161 case USB_NET_CLOSE_NET:
1162 ret = UsbnetAdapterDisconnect(client->device);
1163 break;
1164 case USB_NET_RECIVE_DATA_FROM_USB:
1165 ret = UsbnetAdapterRxComplete(client->device, data, GFP_ATOMIC);
1166 break;
1167 default:
1168 HDF_LOGI("%s: no this cmd: %d", __func__, cmd);
1169 break;
1170 }
1171
1172 if (!HdfSbufWriteInt32(reply, ret)) {
1173 HDF_LOGE("%s: reply int32 fail", __func__);
1174 }
1175
1176 return ret;
1177 }
1178
UsbnetAdapterBind(struct HdfDeviceObject * device)1179 static int32_t UsbnetAdapterBind(struct HdfDeviceObject *device)
1180 {
1181 HARCH_NET_INFO_PRINT("begin");
1182 static struct IDeviceIoService UsbnetAdapterService = {
1183 .Dispatch = UsbnetAdapterDispatch,
1184 };
1185
1186 if (device == NULL) {
1187 HARCH_NET_INFO_PRINT("device is NULL!");
1188 return HDF_ERR_INVALID_OBJECT;
1189 }
1190 device->service = &UsbnetAdapterService;
1191 return HDF_SUCCESS;
1192 }
1193
UsbnetAdapterInit(struct HdfDeviceObject * device)1194 static int32_t UsbnetAdapterInit(struct HdfDeviceObject *device)
1195 {
1196 HARCH_NET_INFO_PRINT("begin");
1197 if (device == NULL) {
1198 HARCH_NET_INFO_PRINT("device is null!");
1199 return HDF_FAILURE;
1200 }
1201
1202 HARCH_NET_INFO_PRINT("UsbnetAdapterInit Init success");
1203 return HDF_SUCCESS;
1204 }
1205
UsbnetAdapterRelease(struct HdfDeviceObject * device)1206 static void UsbnetAdapterRelease(struct HdfDeviceObject *device)
1207 {
1208 HARCH_NET_INFO_PRINT("begin");
1209 return;
1210 }
1211
1212 struct HdfDriverEntry g_UsbnetAdapterEntry = {
1213 .moduleVersion = 1,
1214 .Bind = UsbnetAdapterBind,
1215 .Init = UsbnetAdapterInit,
1216 .Release = UsbnetAdapterRelease,
1217 .moduleName = "HDF_USB_NET",
1218 };
1219
1220 HDF_INIT(g_UsbnetAdapterEntry);
1221