AX88772C_eeprom and ax8872c build together

hc

2024-05-16 8d2a02b24d66aa359e83eebc1ed3c0f85367a1cb

 kernel/drivers/net/wireless/rockchip_wlan/rkwifi/bcmdhd/dhd_linux.c
old mode 100644new mode 100755
..
..
@@ -65,11 +65,9 @@
65
65
 #include <asm/uaccess.h>
66
66
 #include <asm/unaligned.h>
67
67
 #include <dhd_linux_priv.h>
68
-#ifdef BCMPCIE
69
-#if defined(CUSTOMER_HW_ROCKCHIP) && defined(CUSTOMER_HW_ROCKCHIP_RK3588)
68
+#if defined(CUSTOMER_HW_ROCKCHIP) && defined(BCMPCIE)
70
69
 #include <rk_dhd_pcie_linux.h>
71
-#endif /* CUSTOMER_HW_ROCKCHIP && CUSTOMER_HW_ROCKCHIP_RK3588 */
72
-#endif /* BCMPCIE */
70
+#endif /* CUSTOMER_HW_ROCKCHIP && BCMPCIE */
73
71
 
74
72
 #include <epivers.h>
75
73
 #include <bcmutils.h>
..
..
@@ -372,6 +370,7 @@
372
370
 static void dhd_hang_process(struct work_struct *work_data);
373
371
 #endif /* OEM_ANDROID */
374
372
 MODULE_LICENSE("GPL and additional rights");
373
+MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
375
374
 
376
375
 #if defined(MULTIPLE_SUPPLICANT)
377
376
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25))
..
..
@@ -1147,16 +1146,9 @@
1147
1146
 	dhd_pub_t *dhd = &dhdinfo->pub;
1148
1147
 	struct dhd_conf *conf = dhd->conf;
1149
1148
 	int suspend_mode = conf->suspend_mode;
1150
-#if defined(BCMDBUS) && defined(WL_EXT_WOWL)
1151
-	int wowl_dngldown = 0;
1152
-#endif
1153
1149
 
1154
1150
 	BCM_REFERENCE(dhdinfo);
1155
1151
 	BCM_REFERENCE(suspend);
1156
-
1157
-#if defined(BCMDBUS) && defined(WL_EXT_WOWL)
1158
-	wowl_dngldown = dhd_conf_wowl_dngldown(dhd);
1159
-#endif
1160
1152
 
1161
1153
 	switch (action) {
1162
1154
 	case PM_HIBERNATION_PREPARE:
..
..
@@ -1189,9 +1181,6 @@
1189
1181
 			dhd_conf_set_suspend_resume(dhd, suspend);
1190
1182
 		DHD_OS_WAKE_LOCK_RESTORE(dhd);
1191
1183
 	} else {
1192
-#ifdef BCMDBUS
1193
-		if (dhd->busstate == DHD_BUS_DATA) {
1194
-#endif
1195
1184
 		if (suspend_mode == PM_NOTIFIER || suspend_mode == SUSPEND_MODE_2)
1196
1185
 			dhd_conf_set_suspend_resume(dhd, suspend);
1197
1186
 #if defined(SUPPORT_P2P_GO_PS) && defined(PROP_TXSTATUS)
..
..
@@ -1199,20 +1188,6 @@
1199
1188
 #endif /* defined(SUPPORT_P2P_GO_PS) && defined(PROP_TXSTATUS) */
1200
1189
 		if (suspend_mode == PM_NOTIFIER)
1201
1190
 			dhd_suspend_resume_helper(dhdinfo, suspend, 0);
1202
-#ifdef BCMDBUS
1203
-		} else {
1204
-#if defined(BCMDBUS) && defined(WL_EXT_WOWL)
1205
-			if (wowl_dngldown) {
1206
-				printf("%s: reset power\n", __FUNCTION__);
1207
-				dhd_wifi_platform_set_power(dhd, FALSE);
1208
-				dhd_wifi_platform_set_power(dhd, TRUE);
1209
-			} else
1210
-#endif
1211
-			{
1212
-				printf("%s: skip resume since bus suspeneded\n", __FUNCTION__);
1213
-			}
1214
-		}
1215
-#endif
1216
1191
 	}
1217
1192
 
1218
1193
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)) && (LINUX_VERSION_CODE <= \
..
..
@@ -3566,9 +3541,6 @@
3566
3541
 		return;
3567
3542
 	}
3568
3543
 
3569
-#ifdef DHD_NOTIFY_MAC_CHANGED
3570
-	rtnl_lock();
3571
-#endif /* DHD_NOTIFY_MAC_CHANGED */
3572
3544
 	dhd_net_if_lock_local(dhd);
3573
3545
 	DHD_OS_WAKE_LOCK(&dhd->pub);
3574
3546
 
..
..
@@ -3583,17 +3555,22 @@
3583
3555
 
3584
3556
 	ifp->set_macaddress = FALSE;
3585
3557
 
3558
+#ifdef DHD_NOTIFY_MAC_CHANGED
3559
+	rtnl_lock();
3560
+#endif /* DHD_NOTIFY_MAC_CHANGED */
3561
+
3586
3562
 	if (_dhd_set_mac_address(dhd, ifp->idx, ifp->mac_addr, TRUE) == 0)
3587
3563
 		DHD_INFO(("%s: MACID is overwritten\n",	__FUNCTION__));
3588
3564
 	else
3589
3565
 		DHD_ERROR(("%s: _dhd_set_mac_address() failed\n", __FUNCTION__));
3590
3566
 
3591
-done:
3592
-	DHD_OS_WAKE_UNLOCK(&dhd->pub);
3593
-	dhd_net_if_unlock_local(dhd);
3594
3567
 #ifdef DHD_NOTIFY_MAC_CHANGED
3595
3568
 	rtnl_unlock();
3596
3569
 #endif /* DHD_NOTIFY_MAC_CHANGED */
3570
+
3571
+done:
3572
+	DHD_OS_WAKE_UNLOCK(&dhd->pub);
3573
+	dhd_net_if_unlock_local(dhd);
3597
3574
 }
3598
3575
 
3599
3576
 static void
..
..
@@ -4432,13 +4409,24 @@
4432
4409
 #endif
4433
4410
 	/* Make sure there's enough room for any header */
4434
4411
 #if !defined(BCM_ROUTER_DHD)
4435
-	if (skb_cow(skb, (dhd->pub.hdrlen + htsfdlystat_sz))) {
4436
-		DHD_ERROR(("%s: skb_cow failed\n",
4437
-		           dhd_ifname(&dhd->pub, ifidx)));
4412
+	if (skb_headroom(skb) < dhd->pub.hdrlen + htsfdlystat_sz) {
4413
+		struct sk_buff *skb2;
4414
+
4415
+		DHD_INFO(("%s: insufficient headroom\n",
4416
+		          dhd_ifname(&dhd->pub, ifidx)));
4417
+		dhd->pub.tx_realloc++;
4418
+
4438
4419
 		bcm_object_trace_opr(skb, BCM_OBJDBG_REMOVE, __FUNCTION__, __LINE__);
4439
-		dev_kfree_skb_any(skb);
4440
-		ret = -ENOMEM;
4441
-		goto done;
4420
+		skb2 = skb_realloc_headroom(skb, dhd->pub.hdrlen + htsfdlystat_sz);
4421
+
4422
+		dev_kfree_skb(skb);
4423
+		if ((skb = skb2) == NULL) {
4424
+			DHD_ERROR(("%s: skb_realloc_headroom failed\n",
4425
+			           dhd_ifname(&dhd->pub, ifidx)));
4426
+			ret = -ENOMEM;
4427
+			goto done;
4428
+		}
4429
+		bcm_object_trace_opr(skb, BCM_OBJDBG_ADD_PKT, __FUNCTION__, __LINE__);
4442
4430
 	}
4443
4431
 #endif /* !BCM_ROUTER_DHD */
4444
4432
 
..
..
@@ -4772,11 +4760,6 @@
4772
4760
 static void
4773
4761
 __dhd_txflowcontrol(dhd_pub_t *dhdp, struct net_device *net, bool state)
4774
4762
 {
4775
-
4776
-	if (net->reg_state != NETREG_REGISTERED) {
4777
-		return;
4778
-	}
4779
-
4780
4763
 	if (state == ON) {
4781
4764
 		if (!netif_queue_stopped(net)) {
4782
4765
 			DHD_INFO(("%s: Stop Netif Queue\n", __FUNCTION__));
..
..
@@ -8713,6 +8696,16 @@
8713
8696
 }
8714
8697
 #endif /* DHD_PCIE_NATIVE_RUNTIMEPM */
8715
8698
 
8699
+#ifdef CONFIG_HAS_WAKELOCK
8700
+#define dhd_wake_lock_unlock_destroy(wlock) \
8701
+{ \
8702
+	if (dhd_wake_lock_active(wlock)) { \
8703
+		dhd_wake_unlock(wlock); \
8704
+	} \
8705
+	dhd_wake_lock_destroy(wlock); \
8706
+}
8707
+#endif /* CONFIG_HAS_WAKELOCK */
8708
+
8716
8709
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0) && defined(DHD_TCP_LIMIT_OUTPUT)
8717
8710
 #define DHD_TCP_LIMIT_OUTPUT_BYTES (4 * 1024 * 1024)
8718
8711
 #ifndef TCP_DEFAULT_LIMIT_OUTPUT
..
..
@@ -8782,7 +8775,7 @@
8782
8775
 
8783
8776
 #if defined(WL_STATIC_IF) && defined(WL_CFG80211)
8784
8777
 	/* If static if is operational, don't reset the chip */
8785
-	if ((!dhd->pub.hang_was_sent) && wl_cfg80211_static_if_active(cfg)) {
8778
+	if (wl_cfg80211_static_if_active(cfg)) {
8786
8779
 		WL_MSG(net->name, "static if operational. skip chip reset.\n");
8787
8780
 		skip_reset = true;
8788
8781
 		wl_cfg80211_sta_ifdown(net);
..
..
@@ -8790,7 +8783,7 @@
8790
8783
 	}
8791
8784
 #endif /* WL_STATIC_IF && WL_CFG80211 */
8792
8785
 #ifdef DHD_NOTIFY_MAC_CHANGED
8793
-	if (!dhd->pub.hang_was_sent && dhd->pub.skip_dhd_stop) {
8786
+	if (dhd->pub.skip_dhd_stop) {
8794
8787
 		WL_MSG(net->name, "skip chip reset.\n");
8795
8788
 		skip_reset = true;
8796
8789
 #if defined(WL_CFG80211)
..
..
@@ -9084,14 +9077,14 @@
9084
9077
 {
9085
9078
 	struct file *fp;
9086
9079
 	const char *clm = VENDOR_PATH CONFIG_BCMDHD_CLM_PATH;
9080
+	fp = filp_open(clm, O_RDONLY, 0);
9087
9081
 
9088
-	fp = dhd_filp_open(clm, O_RDONLY, 0);
9089
-	if (IS_ERR(fp) || (fp == NULL)) {
9082
+	if (IS_ERR(fp)) {
9090
9083
 		DHD_ERROR(("%s: filp_open(%s) failed(%d) schedule wl_accel_work\n",
9091
9084
 				__FUNCTION__, clm, (int)IS_ERR(fp)));
9092
9085
 		return FALSE;
9093
9086
 	}
9094
-	dhd_filp_close(fp, NULL);
9087
+	filp_close(fp, NULL);
9095
9088
 
9096
9089
 	return TRUE;
9097
9090
 }
..
..
@@ -10446,13 +10439,8 @@
10446
10439
 #endif /* DHDTCPACK_SUPPRESS && BCMPCIE */
10447
10440
 				if (need_rtnl_lock)
10448
10441
 					unregister_netdev(ifp->net);
10449
-				else {
10450
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)) && defined(WL_CFG80211)
10451
-					cfg80211_unregister_netdevice(ifp->net);
10452
-#else
10442
+				else
10453
10443
 					unregister_netdevice(ifp->net);
10454
-#endif
10455
-				}
10456
10444
 #if defined(WLDWDS) && defined(WL_EXT_IAPSTA)
10457
10445
 				if (ifp->dwds) {
10458
10446
 					wl_ext_iapsta_dettach_dwds_netdev(ifp->net, ifidx, ifp->bssidx);
..
..
@@ -10591,7 +10579,7 @@
10591
10579
 	if (!fp || !buf || buflen == 0)
10592
10580
 		return -1;
10593
10581
 
10594
-	if (dhd_vfs_write((struct file *)fp, buf, buflen, &wr_posn) < 0)
10582
+	if (vfs_write((struct file *)fp, buf, buflen, &wr_posn) < 0)
10595
10583
 		return -1;
10596
10584
 
10597
10585
 	*posn = wr_posn;
..
..
@@ -10607,7 +10595,7 @@
10607
10595
 	if (!file || !buf)
10608
10596
 		return -1;
10609
10597
 
10610
-	return dhd_vfs_read(filep, buf, size, &filep->f_pos);
10598
+	return vfs_read(filep, buf, size, &filep->f_pos);
10611
10599
 }
10612
10600
 
10613
10601
 int
..
..
@@ -10623,6 +10611,135 @@
10623
10611
 	return 0;
10624
10612
 }
10625
10613
 
10614
+static int
10615
+dhd_init_logstrs_array(osl_t *osh, dhd_event_log_t *temp)
10616
+{
10617
+	struct file *filep = NULL;
10618
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
10619
+	struct kstat stat;
10620
+	mm_segment_t fs;
10621
+	int error = 0;
10622
+#endif
10623
+	char *raw_fmts =  NULL;
10624
+	int logstrs_size = 0;
10625
+
10626
+	if (control_logtrace != LOGTRACE_PARSED_FMT) {
10627
+		DHD_ERROR_NO_HW4(("%s : turned off logstr parsing\n", __FUNCTION__));
10628
+		return BCME_ERROR;
10629
+	}
10630
+
10631
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
10632
+	fs = get_fs();
10633
+	set_fs(KERNEL_DS);
10634
+#endif
10635
+
10636
+	filep = filp_open(logstrs_path, O_RDONLY, 0);
10637
+
10638
+	if (IS_ERR(filep)) {
10639
+		DHD_ERROR_NO_HW4(("%s: Failed to open the file %s \n", __FUNCTION__, logstrs_path));
10640
+		goto fail;
10641
+	}
10642
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
10643
+	error = vfs_stat(logstrs_path, &stat);
10644
+	if (error) {
10645
+		DHD_ERROR_NO_HW4(("%s: Failed to stat file %s \n", __FUNCTION__, logstrs_path));
10646
+		goto fail;
10647
+	}
10648
+	logstrs_size = (int) stat.size;
10649
+#else
10650
+	logstrs_size = dhd_os_get_image_size(filep);
10651
+#endif
10652
+
10653
+	if (logstrs_size == 0) {
10654
+		DHD_ERROR(("%s: return as logstrs_size is 0\n", __FUNCTION__));
10655
+		goto fail1;
10656
+	}
10657
+
10658
+	if (temp->raw_fmts != NULL) {
10659
+		raw_fmts = temp->raw_fmts;	/* reuse already malloced raw_fmts */
10660
+	} else {
10661
+		raw_fmts = MALLOC(osh, logstrs_size);
10662
+		if (raw_fmts == NULL) {
10663
+			DHD_ERROR(("%s: Failed to allocate memory \n", __FUNCTION__));
10664
+			goto fail;
10665
+		}
10666
+	}
10667
+
10668
+	if (vfs_read(filep, raw_fmts, logstrs_size, &filep->f_pos) !=	logstrs_size) {
10669
+		DHD_ERROR_NO_HW4(("%s: Failed to read file %s\n", __FUNCTION__, logstrs_path));
10670
+		goto fail;
10671
+	}
10672
+
10673
+	if (dhd_parse_logstrs_file(osh, raw_fmts, logstrs_size, temp)
10674
+				== BCME_OK) {
10675
+		filp_close(filep, NULL);
10676
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
10677
+		set_fs(fs);
10678
+#endif
10679
+		return BCME_OK;
10680
+	}
10681
+
10682
+fail:
10683
+	if (raw_fmts) {
10684
+		MFREE(osh, raw_fmts, logstrs_size);
10685
+	}
10686
+	if (temp->fmts != NULL) {
10687
+		MFREE(osh, temp->fmts, temp->num_fmts * sizeof(char *));
10688
+	}
10689
+
10690
+fail1:
10691
+	if (!IS_ERR(filep))
10692
+		filp_close(filep, NULL);
10693
+
10694
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
10695
+	set_fs(fs);
10696
+#endif
10697
+	temp->fmts = NULL;
10698
+	temp->raw_fmts = NULL;
10699
+
10700
+	return BCME_ERROR;
10701
+}
10702
+
10703
+static int
10704
+dhd_read_map(osl_t *osh, char *fname, uint32 *ramstart, uint32 *rodata_start,
10705
+		uint32 *rodata_end)
10706
+{
10707
+	struct file *filep = NULL;
10708
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
10709
+	mm_segment_t fs;
10710
+#endif
10711
+	int err = BCME_ERROR;
10712
+
10713
+	if (fname == NULL) {
10714
+		DHD_ERROR(("%s: ERROR fname is NULL \n", __FUNCTION__));
10715
+		return BCME_ERROR;
10716
+	}
10717
+
10718
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
10719
+	fs = get_fs();
10720
+	set_fs(KERNEL_DS);
10721
+#endif
10722
+
10723
+	filep = filp_open(fname, O_RDONLY, 0);
10724
+	if (IS_ERR(filep)) {
10725
+		DHD_ERROR_NO_HW4(("%s: Failed to open %s \n",  __FUNCTION__, fname));
10726
+		goto fail;
10727
+	}
10728
+
10729
+	if ((err = dhd_parse_map_file(osh, filep, ramstart,
10730
+			rodata_start, rodata_end)) < 0)
10731
+		goto fail;
10732
+
10733
+fail:
10734
+	if (!IS_ERR(filep))
10735
+		filp_close(filep, NULL);
10736
+
10737
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
10738
+	set_fs(fs);
10739
+#endif
10740
+
10741
+	return err;
10742
+}
10626
10743
 #ifdef DHD_COREDUMP
10627
10744
 #define PC_FOUND_BIT 0x01
10628
10745
 #define LR_FOUND_BIT 0x02
..
..
@@ -10682,8 +10799,8 @@
10682
10799
 	set_fs(KERNEL_DS);
10683
10800
 #endif
10684
10801
 
10685
-	filep = dhd_filp_open(fname, O_RDONLY, 0);
10686
-	if (IS_ERR(filep) || (filep == NULL)) {
10802
+	filep = filp_open(fname, O_RDONLY, 0);
10803
+	if (IS_ERR(filep)) {
10687
10804
 		DHD_ERROR(("%s: Failed to open %s \n",  __FUNCTION__, fname));
10688
10805
 		goto fail;
10689
10806
 	}
..
..
@@ -10845,7 +10962,7 @@
10845
10962
 	}
10846
10963
 #else
10847
10964
 	if (!IS_ERR(filep))
10848
-		dhd_filp_close(filep, NULL);
10965
+		filp_close(filep, NULL);
10849
10966
 
10850
10967
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
10851
10968
 	set_fs(fs);
..
..
@@ -11220,8 +11337,8 @@
11220
11337
 	set_fs(KERNEL_DS);
11221
11338
 #endif
11222
11339
 
11223
-	filep = dhd_filp_open(str_file, O_RDONLY, 0);
11224
-	if (IS_ERR(filep) || (filep == NULL)) {
11340
+	filep = filp_open(str_file, O_RDONLY, 0);
11341
+	if (IS_ERR(filep)) {
11225
11342
 		DHD_ERROR(("%s: Failed to open the file %s \n",  __FUNCTION__, str_file));
11226
11343
 		goto fail;
11227
11344
 	}
..
..
@@ -11258,7 +11375,7 @@
11258
11375
 		}
11259
11376
 	}
11260
11377
 
11261
-	error = dhd_vfs_read(filep, raw_fmts, logstrs_size, (&filep->f_pos));
11378
+	error = vfs_read(filep, raw_fmts, logstrs_size, (&filep->f_pos));
11262
11379
 	if (error != logstrs_size) {
11263
11380
 		DHD_ERROR(("%s: %s read failed %d \n", __FUNCTION__, str_file, error));
11264
11381
 		goto fail;
..
..
@@ -11276,7 +11393,7 @@
11276
11393
 		temp->rom_rodata_end = rodata_end;
11277
11394
 	}
11278
11395
 
11279
-	dhd_filp_close(filep, NULL);
11396
+	filp_close(filep, NULL);
11280
11397
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
11281
11398
 	set_fs(fs);
11282
11399
 #endif
..
..
@@ -11290,7 +11407,7 @@
11290
11407
 
11291
11408
 fail1:
11292
11409
 	if (!IS_ERR(filep))
11293
-		dhd_filp_close(filep, NULL);
11410
+		filp_close(filep, NULL);
11294
11411
 
11295
11412
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
11296
11413
 	set_fs(fs);
..
..
@@ -11652,7 +11769,9 @@
11652
11769
 	dhd->wakelock_counter = 0;
11653
11770
 	/* wakelocks prevent a system from going into a low power state */
11654
11771
 #ifdef CONFIG_HAS_WAKELOCK
11655
-	dhd_wake_lock_init(dhd->wl_wdwake, dhd_bus_to_dev(bus), "wlan_wd_wake");
11772
+	// terence 20161023: can not destroy wl_wifi when wlan down, it will happen null pointer in dhd_ioctl_entry
11773
+	dhd_wake_lock_init(&dhd->wl_wifi, WAKE_LOCK_SUSPEND, "wlan_wake");
11774
+	dhd_wake_lock_init(&dhd->wl_wdwake, WAKE_LOCK_SUSPEND, "wlan_wd_wake");
11656
11775
 #endif /* CONFIG_HAS_WAKELOCK */
11657
11776
 
11658
11777
 #if defined(OEM_ANDROID)
..
..
@@ -11698,12 +11817,6 @@
11698
11817
 		goto fail;
11699
11818
 	}
11700
11819
 #endif /* WL_EVENT */
11701
-#ifdef WL_TIMER
11702
-	if (wl_timer_attach(net) != 0) {
11703
-		DHD_ERROR(("wl_ext_timer_attach failed\n"));
11704
-		goto fail;
11705
-	}
11706
-#endif /* WL_TIMER */
11707
11820
 #ifdef WL_ESCAN
11708
11821
 	/* Attach and link in the escan */
11709
11822
 	if (wl_escan_attach(net) != 0) {
..
..
@@ -11866,6 +11979,13 @@
11866
11979
 	}
11867
11980
 #endif /* DHD_PCIE_RUNTIMEPM */
11868
11981
 
11982
+#ifdef SHOW_LOGTRACE
11983
+	skb_queue_head_init(&dhd->evt_trace_queue);
11984
+
11985
+	/* Create ring proc entries */
11986
+	dhd_dbg_ring_proc_create(&dhd->pub);
11987
+#endif /* SHOW_LOGTRACE */
11988
+
11869
11989
 #ifdef BTLOG
11870
11990
 	skb_queue_head_init(&dhd->bt_log_queue);
11871
11991
 #endif /* BTLOG */
..
..
@@ -11897,13 +12017,6 @@
11897
12017
 		}
11898
12018
 	}
11899
12019
 #endif /* !BCMDBUS */
11900
-
11901
-#ifdef SHOW_LOGTRACE
11902
-	skb_queue_head_init(&dhd->evt_trace_queue);
11903
-
11904
-	/* Create ring proc entries */
11905
-	dhd_dbg_ring_proc_create(&dhd->pub);
11906
-#endif /* SHOW_LOGTRACE */
11907
12020
 
11908
12021
 	dhd_state |= DHD_ATTACH_STATE_THREADS_CREATED;
11909
12022
 
..
..
@@ -12788,12 +12901,10 @@
12788
12901
 	dhd_bus_l1ss_enable_rc_ep(dhdp->bus, TRUE);
12789
12902
 #endif /* BT_OVER_PCIE */
12790
12903
 
12791
-#ifdef BCMPCIE
12792
-#if defined(CUSTOMER_HW_ROCKCHIP) && defined(CUSTOMER_HW_ROCKCHIP_RK3588)
12904
+#if defined(CUSTOMER_HW_ROCKCHIP) && defined(BCMPCIE)
12793
12905
 	if (IS_ENABLED(CONFIG_PCIEASPM_ROCKCHIP_WIFI_EXTENSION))
12794
12906
 		rk_dhd_bus_l1ss_enable_rc_ep(dhdp->bus, TRUE);
12795
12907
 #endif /* CUSTOMER_HW_ROCKCHIP && BCMPCIE */
12796
-#endif /* BCMPCIE */
12797
12908
 
12798
12909
 #if defined(CONFIG_ARCH_EXYNOS) && defined(BCMPCIE)
12799
12910
 #if !defined(CONFIG_SOC_EXYNOS8890) && !defined(SUPPORT_EXYNOS7420)
..
..
@@ -13351,7 +13462,7 @@
13351
13462
 
13352
13463
 	old_fs = get_fs();
13353
13464
 	set_fs(get_ds());
13354
-	if ((ret = dhd_vfs_stat(config_path, &stat))) {
13465
+	if ((ret = vfs_stat(config_path, &stat))) {
13355
13466
 		set_fs(old_fs);
13356
13467
 		printk(KERN_ERR "%s: Failed to get information (%d)\n",
13357
13468
 			config_path, ret);
..
..
@@ -13814,8 +13925,12 @@
13814
13925
 	else {
13815
13926
 		bcmstrtok(&ptr, "\n", 0);
13816
13927
 		/* Print fw version info */
13928
+		DHD_ERROR(("Firmware version = %s\n", buf));
13817
13929
 		strncpy(fw_version, buf, FW_VER_STR_LEN);
13818
13930
 		fw_version[FW_VER_STR_LEN-1] = '\0';
13931
+#if defined(BCMSDIO) || defined(BCMPCIE)
13932
+		dhd_set_version_info(dhd, buf);
13933
+#endif /* BCMSDIO || BCMPCIE */
13819
13934
 	}
13820
13935
 
13821
13936
 	/* query for 'wlc_ver' to get version info from firmware */
..
..
@@ -13830,12 +13945,14 @@
13830
13945
 		dhd->wlc_ver_major = wlc_ver.wlc_ver_major;
13831
13946
 		dhd->wlc_ver_minor = wlc_ver.wlc_ver_minor;
13832
13947
 	}
13948
+#ifdef BOARD_HIKEY
13833
13949
 	/* Set op_mode as MFG_MODE if WLTEST is present in "wl ver" */
13834
13950
 	if (strstr(fw_version, "WLTEST") != NULL) {
13835
13951
 		DHD_ERROR(("%s: wl ver has WLTEST, setting op_mode as DHD_FLAG_MFG_MODE\n",
13836
13952
 			__FUNCTION__));
13837
13953
 		op_mode = DHD_FLAG_MFG_MODE;
13838
13954
 	}
13955
+#endif /* BOARD_HIKEY */
13839
13956
 	/* get a capabilities from firmware */
13840
13957
 	ret = dhd_get_fw_capabilities(dhd);
13841
13958
 
..
..
@@ -13992,7 +14109,6 @@
13992
14109
 
13993
14110
 	DHD_ERROR(("Firmware up: op_mode=0x%04x, MAC="MACDBG"\n",
13994
14111
 		dhd->op_mode, MAC2STRDBG(dhd->mac.octet)));
13995
-	dhd_set_version_info(dhd, fw_version);
13996
14112
 #if defined(DHD_BLOB_EXISTENCE_CHECK)
13997
14113
 	if (!dhd->is_blob)
13998
14114
 #endif /* DHD_BLOB_EXISTENCE_CHECK */
..
..
@@ -14185,10 +14301,6 @@
14185
14301
 	dhd_update_flow_prio_map(dhd, DHD_FLOW_PRIO_LLR_MAP);
14186
14302
 #endif /* defined(BCMPCIE) && defined(EAPOL_PKT_PRIO) */
14187
14303
 
14188
-#if defined(BCMSDIO) && defined(DHD_LOSSLESS_ROAMING)
14189
-	dhd_update_sdio_data_prio_map(dhd);
14190
-#endif /* BCMSDIO && DHD_LOSSLESS_ROAMING */
14191
-
14192
14304
 #ifdef ARP_OFFLOAD_SUPPORT
14193
14305
 	DHD_ERROR(("arp_enable:%d arp_ol:%d\n",
14194
14306
 		dhd->arpoe_enable, dhd->arpol_configured));
..
..
@@ -14200,64 +14312,60 @@
14200
14312
 	 */
14201
14313
 #ifdef PKT_FILTER_SUPPORT
14202
14314
 	/* Setup default defintions for pktfilter , enable in suspend */
14203
-	if (dhd_master_mode) {
14204
-		dhd->pktfilter_count = 6;
14205
-		dhd->pktfilter[DHD_BROADCAST_FILTER_NUM] = NULL;
14206
-		if (!FW_SUPPORTED(dhd, pf6)) {
14207
-			dhd->pktfilter[DHD_MULTICAST4_FILTER_NUM] = NULL;
14208
-			dhd->pktfilter[DHD_MULTICAST6_FILTER_NUM] = NULL;
14209
-		} else {
14210
-			/* Immediately pkt filter TYPE 6 Discard IPv4/IPv6 Multicast Packet */
14211
-			dhd->pktfilter[DHD_MULTICAST4_FILTER_NUM] = DISCARD_IPV4_MCAST;
14212
-			dhd->pktfilter[DHD_MULTICAST6_FILTER_NUM] = DISCARD_IPV6_MCAST;
14213
-		}
14214
-		/* apply APP pktfilter */
14215
-		dhd->pktfilter[DHD_ARP_FILTER_NUM] = "105 0 0 12 0xFFFF 0x0806";
14315
+	dhd->pktfilter_count = 6;
14316
+	dhd->pktfilter[DHD_BROADCAST_FILTER_NUM] = NULL;
14317
+	if (!FW_SUPPORTED(dhd, pf6)) {
14318
+		dhd->pktfilter[DHD_MULTICAST4_FILTER_NUM] = NULL;
14319
+		dhd->pktfilter[DHD_MULTICAST6_FILTER_NUM] = NULL;
14320
+	} else {
14321
+		/* Immediately pkt filter TYPE 6 Discard IPv4/IPv6 Multicast Packet */
14322
+		dhd->pktfilter[DHD_MULTICAST4_FILTER_NUM] = DISCARD_IPV4_MCAST;
14323
+		dhd->pktfilter[DHD_MULTICAST6_FILTER_NUM] = DISCARD_IPV6_MCAST;
14324
+	}
14325
+	/* apply APP pktfilter */
14326
+	dhd->pktfilter[DHD_ARP_FILTER_NUM] = "105 0 0 12 0xFFFF 0x0806";
14216
14327
 
14217
14328
 #ifdef BLOCK_IPV6_PACKET
14218
-		/* Setup filter to allow only IPv4 unicast frames */
14219
-		dhd->pktfilter[DHD_UNICAST_FILTER_NUM] = "100 0 0 0 "
14220
-			HEX_PREF_STR UNI_FILTER_STR ZERO_ADDR_STR ETHER_TYPE_STR IPV6_FILTER_STR
14221
-			" "
14222
-			HEX_PREF_STR ZERO_ADDR_STR ZERO_ADDR_STR ETHER_TYPE_STR ZERO_TYPE_STR;
14329
+	/* Setup filter to allow only IPv4 unicast frames */
14330
+	dhd->pktfilter[DHD_UNICAST_FILTER_NUM] = "100 0 0 0 "
14331
+		HEX_PREF_STR UNI_FILTER_STR ZERO_ADDR_STR ETHER_TYPE_STR IPV6_FILTER_STR
14332
+		" "
14333
+		HEX_PREF_STR ZERO_ADDR_STR ZERO_ADDR_STR ETHER_TYPE_STR ZERO_TYPE_STR;
14223
14334
 #else
14224
-		/* Setup filter to allow only unicast */
14225
-		dhd->pktfilter[DHD_UNICAST_FILTER_NUM] = "100 0 0 0 0x01 0x00";
14335
+	/* Setup filter to allow only unicast */
14336
+	dhd->pktfilter[DHD_UNICAST_FILTER_NUM] = "100 0 0 0 0x01 0x00";
14226
14337
 #endif /* BLOCK_IPV6_PACKET */
14227
14338
 
14228
14339
 #ifdef PASS_IPV4_SUSPEND
14229
-		/* XXX customer want to get IPv4 multicast packets */
14230
-		dhd->pktfilter[DHD_MDNS_FILTER_NUM] = "104 0 0 0 0xFFFFFF 0x01005E";
14340
+	/* XXX customer want to get IPv4 multicast packets */
14341
+	dhd->pktfilter[DHD_MDNS_FILTER_NUM] = "104 0 0 0 0xFFFFFF 0x01005E";
14231
14342
 #else
14232
-		/* Add filter to pass multicastDNS packet and NOT filter out as Broadcast */
14233
-		dhd->pktfilter[DHD_MDNS_FILTER_NUM] = NULL;
14343
+	/* Add filter to pass multicastDNS packet and NOT filter out as Broadcast */
14344
+	dhd->pktfilter[DHD_MDNS_FILTER_NUM] = NULL;
14234
14345
 #endif /* PASS_IPV4_SUSPEND */
14235
-		if (FW_SUPPORTED(dhd, pf6)) {
14236
-			/* Immediately pkt filter TYPE 6 Dicard Broadcast IP packet */
14237
-			dhd->pktfilter[DHD_IP4BCAST_DROP_FILTER_NUM] = DISCARD_IPV4_BCAST;
14238
-			/* Immediately pkt filter TYPE 6 Dicard Cisco STP packet */
14239
-			dhd->pktfilter[DHD_LLC_STP_DROP_FILTER_NUM] = DISCARD_LLC_STP;
14240
-			/* Immediately pkt filter TYPE 6 Dicard Cisco XID protocol */
14241
-			dhd->pktfilter[DHD_LLC_XID_DROP_FILTER_NUM] = DISCARD_LLC_XID;
14242
-			/* Immediately pkt filter TYPE 6 Dicard NETBIOS packet(port 137) */
14243
-			dhd->pktfilter[DHD_UDPNETBIOS_DROP_FILTER_NUM] = DISCARD_UDPNETBIOS;
14244
-			dhd->pktfilter_count = 11;
14245
-		}
14346
+	if (FW_SUPPORTED(dhd, pf6)) {
14347
+		/* Immediately pkt filter TYPE 6 Dicard Broadcast IP packet */
14348
+		dhd->pktfilter[DHD_IP4BCAST_DROP_FILTER_NUM] = DISCARD_IPV4_BCAST;
14349
+		/* Immediately pkt filter TYPE 6 Dicard Cisco STP packet */
14350
+		dhd->pktfilter[DHD_LLC_STP_DROP_FILTER_NUM] = DISCARD_LLC_STP;
14351
+		/* Immediately pkt filter TYPE 6 Dicard Cisco XID protocol */
14352
+		dhd->pktfilter[DHD_LLC_XID_DROP_FILTER_NUM] = DISCARD_LLC_XID;
14353
+		/* Immediately pkt filter TYPE 6 Dicard NETBIOS packet(port 137) */
14354
+		dhd->pktfilter[DHD_UDPNETBIOS_DROP_FILTER_NUM] = DISCARD_UDPNETBIOS;
14355
+		dhd->pktfilter_count = 11;
14356
+	}
14246
14357
 
14247
14358
 #ifdef GAN_LITE_NAT_KEEPALIVE_FILTER
14248
-		dhd->pktfilter_count = 4;
14249
-		/* Setup filter to block broadcast and NAT Keepalive packets */
14250
-		/* discard all broadcast packets */
14251
-		dhd->pktfilter[DHD_UNICAST_FILTER_NUM] = "100 0 0 0 0xffffff 0xffffff";
14252
-		/* discard NAT Keepalive packets */
14253
-		dhd->pktfilter[DHD_BROADCAST_FILTER_NUM] = "102 0 0 36 0xffffffff 0x11940009";
14254
-		/* discard NAT Keepalive packets */
14255
-		dhd->pktfilter[DHD_MULTICAST4_FILTER_NUM] = "104 0 0 38 0xffffffff 0x11940009";
14256
-		dhd->pktfilter[DHD_MULTICAST6_FILTER_NUM] = NULL;
14359
+	dhd->pktfilter_count = 4;
14360
+	/* Setup filter to block broadcast and NAT Keepalive packets */
14361
+	/* discard all broadcast packets */
14362
+	dhd->pktfilter[DHD_UNICAST_FILTER_NUM] = "100 0 0 0 0xffffff 0xffffff";
14363
+	/* discard NAT Keepalive packets */
14364
+	dhd->pktfilter[DHD_BROADCAST_FILTER_NUM] = "102 0 0 36 0xffffffff 0x11940009";
14365
+	/* discard NAT Keepalive packets */
14366
+	dhd->pktfilter[DHD_MULTICAST4_FILTER_NUM] = "104 0 0 38 0xffffffff 0x11940009";
14367
+	dhd->pktfilter[DHD_MULTICAST6_FILTER_NUM] = NULL;
14257
14368
 #endif /* GAN_LITE_NAT_KEEPALIVE_FILTER */
14258
-	} else
14259
-		dhd_conf_discard_pkt_filter(dhd);
14260
-	dhd_conf_add_pkt_filter(dhd);
14261
14369
 
14262
14370
 #if defined(SOFTAP)
14263
14371
 	if (ap_fw_loaded) {
..
..
@@ -14499,7 +14607,6 @@
14499
14607
 	dhd_set_bandlock(dhd);
14500
14608
 
14501
14609
 done:
14502
-	dhd_conf_postinit_ioctls(dhd);
14503
14610
 	if (iov_buf) {
14504
14611
 		MFREE(dhd->osh, iov_buf, WLC_IOCTL_SMLEN);
14505
14612
 	}
..
..
@@ -14768,12 +14875,14 @@
14768
14875
 		fw_version[FW_VER_STR_LEN-1] = '\0';
14769
14876
 	}
14770
14877
 
14878
+#ifdef BOARD_HIKEY
14771
14879
 	/* Set op_mode as MFG_MODE if WLTEST is present in "wl ver" */
14772
14880
 	if (strstr(fw_version, "WLTEST") != NULL) {
14773
14881
 		DHD_ERROR(("%s: wl ver has WLTEST, setting op_mode as DHD_FLAG_MFG_MODE\n",
14774
14882
 			__FUNCTION__));
14775
14883
 		op_mode = DHD_FLAG_MFG_MODE;
14776
14884
 	}
14885
+#endif /* BOARD_HIKEY */
14777
14886
 
14778
14887
 	if ((!op_mode && dhd_get_fw_mode(dhd->info) == DHD_FLAG_MFG_MODE) ||
14779
14888
 		(op_mode == DHD_FLAG_MFG_MODE)) {
..
..
@@ -15329,7 +15438,7 @@
15329
15438
 	}
15330
15439
 
15331
15440
 #else /* OEM_ANDROID */
15332
-	if ((ret = dhd_apply_default_clm(dhd, dhd->clm_path)) < 0) {
15441
+	if ((ret = dhd_apply_default_clm(dhd, clm_path)) < 0) {
15333
15442
 		DHD_ERROR(("%s: CLM set failed. Abort initialization.\n", __FUNCTION__));
15334
15443
 		goto done;
15335
15444
 	}
..
..
@@ -15721,10 +15830,6 @@
15721
15830
 	dhd_update_flow_prio_map(dhd, DHD_FLOW_PRIO_LLR_MAP);
15722
15831
 #endif /* defined(BCMPCIE) && defined(EAPOL_PKT_PRIO) */
15723
15832
 
15724
-#if defined(BCMSDIO) && defined(DHD_LOSSLESS_ROAMING)
15725
-	dhd_update_sdio_data_prio_map(dhd);
15726
-#endif /* BCMSDIO && DHD_LOSSLESS_ROAMING */
15727
-
15728
15833
 #ifdef RSSI_MONITOR_SUPPORT
15729
15834
 	setbit(mask, WLC_E_RSSI_LQM);
15730
15835
 #endif /* RSSI_MONITOR_SUPPORT */
..
..
@@ -15762,9 +15867,6 @@
15762
15867
 	setbit(mask, WLC_E_DELTS_IND);
15763
15868
 #endif /* WL_BCNRECV */
15764
15869
 	setbit(mask, WLC_E_COUNTRY_CODE_CHANGED);
15765
-#if defined(WL_TWT) || defined(WL_TWT_HAL_IF)
15766
-	setbit(mask, WLC_E_TWT);
15767
-#endif /* WL_TWT || WL_TWT_HAL_IF */
15768
15870
 
15769
15871
 	/* Write updated Event mask */
15770
15872
 	eventmask_msg->ver = EVENTMSGS_VER;
..
..
@@ -17269,9 +17371,6 @@
17269
17371
 #ifdef WL_ESCAN
17270
17372
 	wl_escan_detach(dev);
17271
17373
 #endif /* WL_ESCAN */
17272
-#ifdef WL_TIMER
17273
-	wl_timer_dettach(dhdp);
17274
-#endif /* WL_TIMER */
17275
17374
 #ifdef WL_EVENT
17276
17375
 	wl_ext_event_dettach(dhdp);
17277
17376
 #endif /* WL_EVENT */
..
..
@@ -17545,7 +17644,9 @@
17545
17644
 	DHD_TRACE(("wd wakelock count:%d\n", dhd->wakelock_wd_counter));
17546
17645
 #ifdef CONFIG_HAS_WAKELOCK
17547
17646
 	dhd->wakelock_wd_counter = 0;
17548
-	dhd_wake_lock_destroy(dhd->wl_wdwake);
17647
+	dhd_wake_lock_unlock_destroy(&dhd->wl_wdwake);
17648
+	// terence 20161023: can not destroy wl_wifi when wlan down, it will happen null pointer in dhd_ioctl_entry
17649
+	dhd_wake_lock_unlock_destroy(&dhd->wl_wifi);
17549
17650
 #endif /* CONFIG_HAS_WAKELOCK */
17550
17651
 	if (dhd->dhd_state & DHD_ATTACH_STATE_WAKELOCKS_INIT) {
17551
17652
 		DHD_OS_WAKE_LOCK_DESTROY(dhd);
..
..
@@ -18425,7 +18526,7 @@
18425
18526
 		/* convert to BCME_NOTFOUND error for error handling */
18426
18527
 		ret = BCME_NOTFOUND;
18427
18528
 	} else
18428
-		DHD_ERROR(("%s: %s (%zu bytes) open success\n", __FUNCTION__, file_path, (*fw)->size));
18529
+		 DHD_ERROR(("%s: %s (%zu bytes) open success\n", __FUNCTION__, file_path, (*fw)->size));
18429
18530
 
18430
18531
 	return ret;
18431
18532
 }
..
..
@@ -18443,14 +18544,14 @@
18443
18544
 	struct file *fp;
18444
18545
 	int size;
18445
18546
 
18446
-	fp = dhd_filp_open(filename, O_RDONLY, 0);
18547
+	fp = filp_open(filename, O_RDONLY, 0);
18447
18548
 	/*
18448
-	 * 2.6.11 (FC4) supports dhd_filp_open() but later revs don't?
18549
+	 * 2.6.11 (FC4) supports filp_open() but later revs don't?
18449
18550
 	 * Alternative:
18450
18551
 	 * fp = open_namei(AT_FDCWD, filename, O_RD, 0);
18451
18552
 	 * ???
18452
18553
 	 */
18453
-	 if (IS_ERR(fp) || (fp == NULL)) {
18554
+	 if (IS_ERR(fp)) {
18454
18555
 		 fp = NULL;
18455
18556
 		 goto err;
18456
18557
 	 }
..
..
@@ -18461,7 +18562,7 @@
18461
18562
 		 goto err;
18462
18563
 	 }
18463
18564
 
18464
-	 size = dhd_i_size_read(file_inode(fp));
18565
+	 size = i_size_read(file_inode(fp));
18465
18566
 	 if (size <= 0) {
18466
18567
 		 DHD_ERROR(("%s: %s file size invalid %d\n", __FUNCTION__, filename, size));
18467
18568
 		 fp = NULL;
..
..
@@ -18485,8 +18586,8 @@
18485
18586
 		return 0;
18486
18587
 	}
18487
18588
 
18488
-	size = dhd_i_size_read(file_inode(fp));
18489
-	rdlen = dhd_kernel_read_compat(fp, fp->f_pos, buf, MIN(len, size));
18589
+	size = i_size_read(file_inode(fp));
18590
+	rdlen = kernel_read_compat(fp, fp->f_pos, buf, MIN(len, size));
18490
18591
 
18491
18592
 	if (len >= size && size != rdlen) {
18492
18593
 		return -EIO;
..
..
@@ -18511,7 +18612,7 @@
18511
18612
 	if (!image)
18512
18613
 		return 0;
18513
18614
 
18514
-	rd_len = dhd_kernel_read_compat(fp, fp->f_pos, str, len);
18615
+	rd_len = kernel_read_compat(fp, fp->f_pos, str, len);
18515
18616
 	str_end = strnchr(str, len, '\n');
18516
18617
 	if (str_end == NULL) {
18517
18618
 		goto err;
..
..
@@ -18536,7 +18637,7 @@
18536
18637
 		return 0;
18537
18638
 	}
18538
18639
 
18539
-	size = dhd_i_size_read(file_inode(fp));
18640
+	size = i_size_read(file_inode(fp));
18540
18641
 
18541
18642
 	return size;
18542
18643
 }
..
..
@@ -18545,7 +18646,7 @@
18545
18646
 dhd_os_close_image1(dhd_pub_t *pub, void *image)
18546
18647
 {
18547
18648
 	if (image) {
18548
-		dhd_filp_close((struct file *)image, NULL);
18649
+		filp_close((struct file *)image, NULL);
18549
18650
 	}
18550
18651
 }
18551
18652
 
..
..
@@ -20888,14 +20989,14 @@
20888
20989
 #endif
20889
20990
 
20890
20991
 	/* open file to write */
20891
-	fp = dhd_filp_open(file_name, flags, 0664);
20892
-	if (IS_ERR(fp) || (fp == NULL)) {
20992
+	fp = filp_open(file_name, flags, 0664);
20993
+	if (IS_ERR(fp)) {
20893
20994
 		DHD_ERROR(("open file error, err = %ld\n", PTR_ERR(fp)));
20894
20995
 		goto exit;
20895
20996
 	}
20896
20997
 
20897
20998
 	/* Write buf to file */
20898
-	ret = dhd_vfs_write(fp, buf, size, &pos);
20999
+	ret = vfs_write(fp, buf, size, &pos);
20899
21000
 	if (ret < 0) {
20900
21001
 		DHD_ERROR(("write file error, err = %d\n", ret));
20901
21002
 		goto exit;
..
..
@@ -20903,7 +21004,7 @@
20903
21004
 
20904
21005
 	/* Sync file from filesystem to physical media */
20905
21006
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
20906
-	ret = dhd_vfs_fsync(fp, 0);
21007
+	ret = vfs_fsync(fp, 0);
20907
21008
 #else
20908
21009
 	ret = vfs_fsync(fp, fp->f_path.dentry, 0);
20909
21010
 #endif
..
..
@@ -20916,7 +21017,7 @@
20916
21017
 exit:
20917
21018
 	/* close file before return */
20918
21019
 	if (!IS_ERR(fp))
20919
-		dhd_filp_close(fp, current->files);
21020
+		filp_close(fp, current->files);
20920
21021
 
20921
21022
 	/* restore previous address limit */
20922
21023
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
..
..
@@ -21108,14 +21209,14 @@
21108
21209
 	 */
21109
21210
 	file_mode = O_CREAT | O_WRONLY | O_SYNC;
21110
21211
 	{
21111
-		struct file *fp = dhd_filp_open(memdump_path, file_mode, 0664);
21212
+		struct file *fp = filp_open(memdump_path, file_mode, 0664);
21112
21213
 		/* Check if it is live Brix image having /installmedia, else use /data */
21113
-		if (IS_ERR(fp) || (fp == NULL)) {
21214
+		if (IS_ERR(fp)) {
21114
21215
 			DHD_ERROR(("open file %s, try /data/\n", memdump_path));
21115
21216
 			snprintf(memdump_path, sizeof(memdump_path), "%s%s_%s_" "%s",
21116
21217
 				"/data/", fname, memdump_type,  dhd->debug_dump_time_str);
21117
21218
 		} else {
21118
-			dhd_filp_close(fp, NULL);
21219
+			filp_close(fp, NULL);
21119
21220
 		}
21120
21221
 	}
21121
21222
 #else
..
..
@@ -21153,15 +21254,11 @@
21153
21254
 		ret = dhd->wakelock_rx_timeout_enable > dhd->wakelock_ctrl_timeout_enable ?
21154
21255
 			dhd->wakelock_rx_timeout_enable : dhd->wakelock_ctrl_timeout_enable;
21155
21256
 #ifdef CONFIG_HAS_WAKELOCK
21156
-#ifdef DHD_DEBUG_WAKE_LOCK
21157
-		printf("%s: rx_timeout=%dms, ctrl_timeout=%dms\n", __FUNCTION__,
21158
-		dhd->wakelock_rx_timeout_enable, dhd->wakelock_ctrl_timeout_enable);
21159
-#endif
21160
21257
 		if (dhd->wakelock_rx_timeout_enable)
21161
-			dhd_wake_lock_timeout(dhd->wl_rxwake,
21258
+			dhd_wake_lock_timeout(&dhd->wl_rxwake,
21162
21259
 				msecs_to_jiffies(dhd->wakelock_rx_timeout_enable));
21163
21260
 		if (dhd->wakelock_ctrl_timeout_enable)
21164
-			dhd_wake_lock_timeout(dhd->wl_ctrlwake,
21261
+			dhd_wake_lock_timeout(&dhd->wl_ctrlwake,
21165
21262
 				msecs_to_jiffies(dhd->wakelock_ctrl_timeout_enable));
21166
21263
 #endif
21167
21264
 		dhd->wakelock_rx_timeout_enable = 0;
..
..
@@ -21218,8 +21315,8 @@
21218
21315
 		DHD_WAKE_SPIN_LOCK(&dhd->wakelock_spinlock, flags);
21219
21316
 		dhd->wakelock_ctrl_timeout_enable = 0;
21220
21317
 #ifdef CONFIG_HAS_WAKELOCK
21221
-		if (dhd_wake_lock_active(dhd->wl_ctrlwake))
21222
-			dhd_wake_unlock(dhd->wl_ctrlwake);
21318
+		if (dhd_wake_lock_active(&dhd->wl_ctrlwake))
21319
+			dhd_wake_unlock(&dhd->wl_ctrlwake);
21223
21320
 #endif
21224
21321
 		DHD_WAKE_SPIN_UNLOCK(&dhd->wakelock_spinlock, flags);
21225
21322
 	}
..
..
@@ -21453,7 +21550,7 @@
21453
21550
 		DHD_WAKE_SPIN_LOCK(&dhd->wakelock_spinlock, flags);
21454
21551
 		if (dhd->wakelock_counter == 0 && !dhd->waive_wakelock) {
21455
21552
 #ifdef CONFIG_HAS_WAKELOCK
21456
-			dhd_wake_lock(dhd->wl_wifi);
21553
+			dhd_wake_lock(&dhd->wl_wifi);
21457
21554
 #elif defined(BCMSDIO)
21458
21555
 			dhd_bus_dev_pm_stay_awake(pub);
21459
21556
 #endif
..
..
@@ -21477,7 +21574,7 @@
21477
21574
 
21478
21575
 	if (dhd) {
21479
21576
 #ifdef CONFIG_HAS_WAKELOCK
21480
-		dhd_wake_lock(dhd->wl_evtwake);
21577
+		dhd_wake_lock(&dhd->wl_evtwake);
21481
21578
 #elif defined(BCMSDIO)
21482
21579
 		dhd_bus_dev_pm_stay_awake(pub);
21483
21580
 #endif
..
..
@@ -21491,7 +21588,7 @@
21491
21588
 	dhd_info_t *dhd = (dhd_info_t *)(pub->info);
21492
21589
 
21493
21590
 	if (dhd) {
21494
-		dhd_wake_lock_timeout(dhd->wl_pmwake, msecs_to_jiffies(val));
21591
+		dhd_wake_lock_timeout(&dhd->wl_pmwake, msecs_to_jiffies(val));
21495
21592
 	}
21496
21593
 #endif /* CONFIG_HAS_WAKE_LOCK */
21497
21594
 }
..
..
@@ -21503,7 +21600,7 @@
21503
21600
 	dhd_info_t *dhd = (dhd_info_t *)(pub->info);
21504
21601
 
21505
21602
 	if (dhd) {
21506
-		dhd_wake_lock_timeout(dhd->wl_txflwake, msecs_to_jiffies(val));
21603
+		dhd_wake_lock_timeout(&dhd->wl_txflwake, msecs_to_jiffies(val));
21507
21604
 	}
21508
21605
 #endif /* CONFIG_HAS_WAKE_LOCK */
21509
21606
 }
..
..
@@ -21515,7 +21612,7 @@
21515
21612
 	dhd_info_t *dhd = (dhd_info_t *)(pub->info);
21516
21613
 
21517
21614
 	if (dhd) {
21518
-		dhd_wake_lock_timeout(dhd->wl_nanwake, msecs_to_jiffies(val));
21615
+		dhd_wake_lock_timeout(&dhd->wl_nanwake, msecs_to_jiffies(val));
21519
21616
 	}
21520
21617
 #endif /* CONFIG_HAS_WAKE_LOCK */
21521
21618
 }
..
..
@@ -21549,7 +21646,7 @@
21549
21646
 #endif /* DHD_TRACE_WAKE_LOCK */
21550
21647
 			if (dhd->wakelock_counter == 0 && !dhd->waive_wakelock) {
21551
21648
 #ifdef CONFIG_HAS_WAKELOCK
21552
-				dhd_wake_unlock(dhd->wl_wifi);
21649
+				dhd_wake_unlock(&dhd->wl_wifi);
21553
21650
 #elif defined(BCMSDIO)
21554
21651
 				dhd_bus_dev_pm_relax(pub);
21555
21652
 #endif
..
..
@@ -21567,7 +21664,7 @@
21567
21664
 
21568
21665
 	if (dhd) {
21569
21666
 #ifdef CONFIG_HAS_WAKELOCK
21570
-		dhd_wake_unlock(dhd->wl_evtwake);
21667
+		dhd_wake_unlock(&dhd->wl_evtwake);
21571
21668
 #elif defined(BCMSDIO)
21572
21669
 		dhd_bus_dev_pm_relax(pub);
21573
21670
 #endif
..
..
@@ -21581,8 +21678,8 @@
21581
21678
 
21582
21679
 	if (dhd) {
21583
21680
 		/* if wl_pmwake is active, unlock it */
21584
-		if (dhd_wake_lock_active(dhd->wl_pmwake)) {
21585
-			dhd_wake_unlock(dhd->wl_pmwake);
21681
+		if (dhd_wake_lock_active(&dhd->wl_pmwake)) {
21682
+			dhd_wake_unlock(&dhd->wl_pmwake);
21586
21683
 		}
21587
21684
 	}
21588
21685
 #endif /* CONFIG_HAS_WAKELOCK */
..
..
@@ -21595,8 +21692,8 @@
21595
21692
 
21596
21693
 	if (dhd) {
21597
21694
 		/* if wl_txflwake is active, unlock it */
21598
-		if (dhd_wake_lock_active(dhd->wl_txflwake)) {
21599
-			dhd_wake_unlock(dhd->wl_txflwake);
21695
+		if (dhd_wake_lock_active(&dhd->wl_txflwake)) {
21696
+			dhd_wake_unlock(&dhd->wl_txflwake);
21600
21697
 		}
21601
21698
 	}
21602
21699
 #endif /* CONFIG_HAS_WAKELOCK */
..
..
@@ -21609,8 +21706,8 @@
21609
21706
 
21610
21707
 	if (dhd) {
21611
21708
 		/* if wl_nanwake is active, unlock it */
21612
-		if (dhd_wake_lock_active(dhd->wl_nanwake)) {
21613
-			dhd_wake_unlock(dhd->wl_nanwake);
21709
+		if (dhd_wake_lock_active(&dhd->wl_nanwake)) {
21710
+			dhd_wake_unlock(&dhd->wl_nanwake);
21614
21711
 		}
21615
21712
 	}
21616
21713
 #endif /* CONFIG_HAS_WAKELOCK */
..
..
@@ -21635,8 +21732,8 @@
21635
21732
 
21636
21733
 #ifdef CONFIG_HAS_WAKELOCK
21637
21734
 	c = dhd->wakelock_counter;
21638
-	l1 = dhd_wake_lock_active(dhd->wl_wifi);
21639
-	l2 = dhd_wake_lock_active(dhd->wl_wdwake);
21735
+	l1 = dhd_wake_lock_active(&dhd->wl_wifi);
21736
+	l2 = dhd_wake_lock_active(&dhd->wl_wdwake);
21640
21737
 	lock_active = (l1 || l2);
21641
21738
 	/* Indicate to the SD Host to avoid going to suspend if internal locks are up */
21642
21739
 	if (lock_active) {
..
..
@@ -21679,20 +21776,20 @@
21679
21776
 
21680
21777
 #ifdef CONFIG_HAS_WAKELOCK
21681
21778
 	c = dhd->wakelock_counter;
21682
-	l1 = dhd_wake_lock_active(dhd->wl_wifi);
21683
-	l2 = dhd_wake_lock_active(dhd->wl_wdwake);
21684
-	l3 = dhd_wake_lock_active(dhd->wl_rxwake);
21685
-	l4 = dhd_wake_lock_active(dhd->wl_ctrlwake);
21686
-	l7 = dhd_wake_lock_active(dhd->wl_evtwake);
21779
+	l1 = dhd_wake_lock_active(&dhd->wl_wifi);
21780
+	l2 = dhd_wake_lock_active(&dhd->wl_wdwake);
21781
+	l3 = dhd_wake_lock_active(&dhd->wl_rxwake);
21782
+	l4 = dhd_wake_lock_active(&dhd->wl_ctrlwake);
21783
+	l7 = dhd_wake_lock_active(&dhd->wl_evtwake);
21687
21784
 #ifdef BCMPCIE_OOB_HOST_WAKE
21688
-	l5 = dhd_wake_lock_active(dhd->wl_intrwake);
21785
+	l5 = dhd_wake_lock_active(&dhd->wl_intrwake);
21689
21786
 #endif /* BCMPCIE_OOB_HOST_WAKE */
21690
21787
 #ifdef DHD_USE_SCAN_WAKELOCK
21691
-	l6 = dhd_wake_lock_active(dhd->wl_scanwake);
21788
+	l6 = dhd_wake_lock_active(&dhd->wl_scanwake);
21692
21789
 #endif /* DHD_USE_SCAN_WAKELOCK */
21693
-	l8 = dhd_wake_lock_active(dhd->wl_pmwake);
21694
-	l9 = dhd_wake_lock_active(dhd->wl_txflwake);
21695
-	l10 = dhd_wake_lock_active(dhd->wl_nanwake);
21790
+	l8 = dhd_wake_lock_active(&dhd->wl_pmwake);
21791
+	l9 = dhd_wake_lock_active(&dhd->wl_txflwake);
21792
+	l10 = dhd_wake_lock_active(&dhd->wl_nanwake);
21696
21793
 	lock_active = (l1 || l2 || l3 || l4 || l5 || l6 || l7 || l8 || l9 || l10);
21697
21794
 
21698
21795
 	/* Indicate to the Host to avoid going to suspend if internal locks are up */
..
..
@@ -21732,7 +21829,7 @@
21732
21829
 		if (dhd->wakelock_wd_counter == 0 && !dhd->waive_wakelock) {
21733
21830
 #ifdef CONFIG_HAS_WAKELOCK
21734
21831
 			/* if wakelock_wd_counter was never used : lock it at once */
21735
-			dhd_wake_lock(dhd->wl_wdwake);
21832
+			dhd_wake_lock(&dhd->wl_wdwake);
21736
21833
 #endif
21737
21834
 		}
21738
21835
 		dhd->wakelock_wd_counter++;
..
..
@@ -21754,7 +21851,7 @@
21754
21851
 			dhd->wakelock_wd_counter = 0;
21755
21852
 			if (!dhd->waive_wakelock) {
21756
21853
 #ifdef CONFIG_HAS_WAKELOCK
21757
-				dhd_wake_unlock(dhd->wl_wdwake);
21854
+				dhd_wake_unlock(&dhd->wl_wdwake);
21758
21855
 #endif
21759
21856
 			}
21760
21857
 		}
..
..
@@ -21767,13 +21864,16 @@
21767
21864
 void
21768
21865
 dhd_os_oob_irq_wake_lock_timeout(dhd_pub_t *pub, int val)
21769
21866
 {
21770
-#ifdef CONFIG_HAS_WAKELOCK
21771
21867
 	dhd_info_t *dhd = (dhd_info_t *)(pub->info);
21772
21868
 
21773
21869
 	if (dhd) {
21774
-		dhd_wake_lock_timeout(dhd->wl_intrwake, msecs_to_jiffies(val));
21775
-	}
21870
+#ifdef CONFIG_HAS_WAKELOCK
21871
+		dhd_wake_lock_timeout(&dhd->wl_intrwake, msecs_to_jiffies(val));
21872
+#else
21873
+		printk("%s: =========\n",__FUNCTION__);
21874
+		wake_lock_timeout(&dhd->rx_wakelock, 5*HZ);
21776
21875
 #endif /* CONFIG_HAS_WAKELOCK */
21876
+	}
21777
21877
 }
21778
21878
 
21779
21879
 void
..
..
@@ -21784,8 +21884,8 @@
21784
21884
 
21785
21885
 	if (dhd) {
21786
21886
 		/* if wl_intrwake is active, unlock it */
21787
-		if (dhd_wake_lock_active(dhd->wl_intrwake)) {
21788
-			dhd_wake_unlock(dhd->wl_intrwake);
21887
+		if (dhd_wake_lock_active(&dhd->wl_intrwake)) {
21888
+			dhd_wake_unlock(&dhd->wl_intrwake);
21789
21889
 		}
21790
21890
 	}
21791
21891
 #endif /* CONFIG_HAS_WAKELOCK */
..
..
@@ -21800,7 +21900,7 @@
21800
21900
 	dhd_info_t *dhd = (dhd_info_t *)(pub->info);
21801
21901
 
21802
21902
 	if (dhd) {
21803
-		dhd_wake_lock_timeout(dhd->wl_scanwake, msecs_to_jiffies(val));
21903
+		dhd_wake_lock_timeout(&dhd->wl_scanwake, msecs_to_jiffies(val));
21804
21904
 	}
21805
21905
 #endif /* CONFIG_HAS_WAKELOCK */
21806
21906
 }
..
..
@@ -21813,8 +21913,8 @@
21813
21913
 
21814
21914
 	if (dhd) {
21815
21915
 		/* if wl_scanwake is active, unlock it */
21816
-		if (dhd_wake_lock_active(dhd->wl_scanwake)) {
21817
-			dhd_wake_unlock(dhd->wl_scanwake);
21916
+		if (dhd_wake_lock_active(&dhd->wl_scanwake)) {
21917
+			dhd_wake_unlock(&dhd->wl_scanwake);
21818
21918
 		}
21819
21919
 	}
21820
21920
 #endif /* CONFIG_HAS_WAKELOCK */
..
..
@@ -21880,13 +21980,13 @@
21880
21980
 
21881
21981
 	if (dhd->wakelock_before_waive == 0 && dhd->wakelock_counter > 0) {
21882
21982
 #ifdef CONFIG_HAS_WAKELOCK
21883
-		dhd_wake_lock(dhd->wl_wifi);
21983
+		dhd_wake_lock(&dhd->wl_wifi);
21884
21984
 #elif defined(BCMSDIO)
21885
21985
 		dhd_bus_dev_pm_stay_awake(&dhd->pub);
21886
21986
 #endif
21887
21987
 	} else if (dhd->wakelock_before_waive > 0 && dhd->wakelock_counter == 0) {
21888
21988
 #ifdef CONFIG_HAS_WAKELOCK
21889
-		dhd_wake_unlock(dhd->wl_wifi);
21989
+		dhd_wake_unlock(&dhd->wl_wifi);
21890
21990
 #elif defined(BCMSDIO)
21891
21991
 		dhd_bus_dev_pm_relax(&dhd->pub);
21892
21992
 #endif
..
..
@@ -21906,23 +22006,24 @@
21906
22006
 	dhd->wakelock_ctrl_timeout_enable = 0;
21907
22007
 	/* wakelocks prevent a system from going into a low power state */
21908
22008
 #ifdef CONFIG_HAS_WAKELOCK
21909
-	dhd_wake_lock_init(dhd->wl_wifi, dhd_bus_to_dev(dhd->pub.bus), "wlan_wake");
21910
-	dhd_wake_lock_init(dhd->wl_rxwake, dhd_bus_to_dev(dhd->pub.bus), "wlan_rx_wake");
21911
-	dhd_wake_lock_init(dhd->wl_ctrlwake, dhd_bus_to_dev(dhd->pub.bus), "wlan_ctrl_wake");
21912
-	dhd_wake_lock_init(dhd->wl_evtwake, dhd_bus_to_dev(dhd->pub.bus), "wlan_evt_wake");
21913
-	dhd_wake_lock_init(dhd->wl_pmwake, dhd_bus_to_dev(dhd->pub.bus), "wlan_pm_wake");
21914
-	dhd_wake_lock_init(dhd->wl_txflwake, dhd_bus_to_dev(dhd->pub.bus), "wlan_txfl_wake");
22009
+	// terence 20161023: can not destroy wl_wifi when wlan down, it will happen null pointer in dhd_ioctl_entry
22010
+	dhd_wake_lock_init(&dhd->wl_rxwake, WAKE_LOCK_SUSPEND, "wlan_rx_wake");
22011
+	dhd_wake_lock_init(&dhd->wl_ctrlwake, WAKE_LOCK_SUSPEND, "wlan_ctrl_wake");
22012
+	dhd_wake_lock_init(&dhd->wl_evtwake, WAKE_LOCK_SUSPEND, "wlan_evt_wake");
22013
+	dhd_wake_lock_init(&dhd->wl_pmwake, WAKE_LOCK_SUSPEND, "wlan_pm_wake");
22014
+	dhd_wake_lock_init(&dhd->wl_txflwake, WAKE_LOCK_SUSPEND, "wlan_txfl_wake");
21915
22015
 #ifdef BCMPCIE_OOB_HOST_WAKE
21916
-	dhd_wake_lock_init(dhd->wl_intrwake, dhd_bus_to_dev(dhd->pub.bus), "wlan_oob_irq_wake");
22016
+	dhd_wake_lock_init(&dhd->wl_intrwake, WAKE_LOCK_SUSPEND, "wlan_oob_irq_wake");
21917
22017
 #endif /* BCMPCIE_OOB_HOST_WAKE */
21918
22018
 #ifdef DHD_USE_SCAN_WAKELOCK
21919
-	dhd_wake_lock_init(dhd->wl_scanwake, dhd_bus_to_dev(dhd->pub.bus), "wlan_scan_wake");
22019
+	dhd_wake_lock_init(&dhd->wl_scanwake, WAKE_LOCK_SUSPEND, "wlan_scan_wake");
21920
22020
 #endif /* DHD_USE_SCAN_WAKELOCK */
21921
-	dhd_wake_lock_init(dhd->wl_nanwake, dhd_bus_to_dev(dhd->pub.bus), "wlan_nan_wake");
22021
+	dhd_wake_lock_init(&dhd->wl_nanwake, WAKE_LOCK_SUSPEND, "wlan_nan_wake");
21922
22022
 #endif /* CONFIG_HAS_WAKELOCK */
21923
22023
 #ifdef DHD_TRACE_WAKE_LOCK
21924
22024
 	dhd_wk_lock_trace_init(dhd);
21925
22025
 #endif /* DHD_TRACE_WAKE_LOCK */
22026
+	wake_lock_init(&dhd->rx_wakelock, WAKE_LOCK_SUSPEND, "wlan_rx_wakelock");
21926
22027
 }
21927
22028
 
21928
22029
 void dhd_os_wake_lock_destroy(struct dhd_info *dhd)
..
..
@@ -21932,19 +22033,19 @@
21932
22033
 	dhd->wakelock_counter = 0;
21933
22034
 	dhd->wakelock_rx_timeout_enable = 0;
21934
22035
 	dhd->wakelock_ctrl_timeout_enable = 0;
21935
-	dhd_wake_lock_destroy(dhd->wl_wifi);
21936
-	dhd_wake_lock_destroy(dhd->wl_rxwake);
21937
-	dhd_wake_lock_destroy(dhd->wl_ctrlwake);
21938
-	dhd_wake_lock_destroy(dhd->wl_evtwake);
21939
-	dhd_wake_lock_destroy(dhd->wl_pmwake);
21940
-	dhd_wake_lock_destroy(dhd->wl_txflwake);
22036
+	// terence 20161023: can not destroy wl_wifi when wlan down, it will happen null pointer in dhd_ioctl_entry
22037
+	dhd_wake_lock_unlock_destroy(&dhd->wl_rxwake);
22038
+	dhd_wake_lock_unlock_destroy(&dhd->wl_ctrlwake);
22039
+	dhd_wake_lock_unlock_destroy(&dhd->wl_evtwake);
22040
+	dhd_wake_lock_unlock_destroy(&dhd->wl_pmwake);
22041
+	dhd_wake_lock_unlock_destroy(&dhd->wl_txflwake);
21941
22042
 #ifdef BCMPCIE_OOB_HOST_WAKE
21942
-	dhd_wake_lock_destroy(dhd->wl_intrwake);
22043
+	dhd_wake_lock_unlock_destroy(&dhd->wl_intrwake);
21943
22044
 #endif /* BCMPCIE_OOB_HOST_WAKE */
21944
22045
 #ifdef DHD_USE_SCAN_WAKELOCK
21945
-	dhd_wake_lock_destroy(dhd->wl_scanwake);
22046
+	dhd_wake_lock_unlock_destroy(&dhd->wl_scanwake);
21946
22047
 #endif /* DHD_USE_SCAN_WAKELOCK */
21947
-	dhd_wake_lock_destroy(dhd->wl_nanwake);
22048
+	dhd_wake_lock_unlock_destroy(&dhd->wl_nanwake);
21948
22049
 #ifdef DHD_TRACE_WAKE_LOCK
21949
22050
 	dhd_wk_lock_trace_deinit(dhd);
21950
22051
 #endif /* DHD_TRACE_WAKE_LOCK */
..
..
@@ -21955,6 +22056,7 @@
21955
22056
 		while (dhd_os_wake_unlock(&dhd->pub));
21956
22057
 	}
21957
22058
 #endif /* CONFIG_HAS_WAKELOCK */
22059
+	wake_lock_destroy(&dhd->rx_wakelock);
21958
22060
 }
21959
22061
 
21960
22062
 bool dhd_os_check_if_up(dhd_pub_t *pub)
..
..
@@ -22479,8 +22581,8 @@
22479
22581
 	loff_t pos = 0;
22480
22582
 
22481
22583
 	/* Read memdump info from the file */
22482
-	fp = dhd_filp_open(filepath, file_mode, 0);
22483
-	if (IS_ERR(fp) || (fp == NULL)) {
22584
+	fp = filp_open(filepath, file_mode, 0);
22585
+	if (IS_ERR(fp)) {
22484
22586
 		DHD_ERROR(("%s: File [%s] doesn't exist\n", __FUNCTION__, filepath));
22485
22587
 #if defined(CONFIG_X86) && defined(OEM_ANDROID)
22486
22588
 		/* Check if it is Live Brix Image */
..
..
@@ -22490,8 +22592,8 @@
22490
22592
 		/* Try if it is Installed Brix Image */
22491
22593
 		filepath = RNDINFO_INST".in";
22492
22594
 		DHD_ERROR(("%s: Try File [%s]\n", __FUNCTION__, filepath));
22493
-		fp = dhd_filp_open(filepath, file_mode, 0);
22494
-		if (IS_ERR(fp) || (fp == NULL)) {
22595
+		fp = filp_open(filepath, file_mode, 0);
22596
+		if (IS_ERR(fp)) {
22495
22597
 			DHD_ERROR(("%s: File [%s] doesn't exist\n", __FUNCTION__, filepath));
22496
22598
 			goto err1;
22497
22599
 		}
..
..
@@ -22504,7 +22606,7 @@
22504
22606
 	set_fs(KERNEL_DS);
22505
22607
 
22506
22608
 	/* Handle success case */
22507
-	ret = dhd_vfs_read(fp, (char *)&dhd->rnd_len, sizeof(dhd->rnd_len), &pos);
22609
+	ret = vfs_read(fp, (char *)&dhd->rnd_len, sizeof(dhd->rnd_len), &pos);
22508
22610
 	if (ret < 0) {
22509
22611
 		DHD_ERROR(("%s: rnd_len read error, ret=%d\n", __FUNCTION__, ret));
22510
22612
 		goto err2;
..
..
@@ -22516,14 +22618,14 @@
22516
22618
 		goto err2;
22517
22619
 	}
22518
22620
 
22519
-	ret = dhd_vfs_read(fp, (char *)dhd->rnd_buf, dhd->rnd_len, &pos);
22621
+	ret = vfs_read(fp, (char *)dhd->rnd_buf, dhd->rnd_len, &pos);
22520
22622
 	if (ret < 0) {
22521
22623
 		DHD_ERROR(("%s: rnd_buf read error, ret=%d\n", __FUNCTION__, ret));
22522
22624
 		goto err3;
22523
22625
 	}
22524
22626
 
22525
22627
 	set_fs(old_fs);
22526
-	dhd_filp_close(fp, NULL);
22628
+	filp_close(fp, NULL);
22527
22629
 
22528
22630
 	DHD_ERROR(("%s: RND read from %s\n", __FUNCTION__, filepath));
22529
22631
 	return BCME_OK;
..
..
@@ -22533,7 +22635,7 @@
22533
22635
 	dhd->rnd_buf = NULL;
22534
22636
 err2:
22535
22637
 	set_fs(old_fs);
22536
-	dhd_filp_close(fp, NULL);
22638
+	filp_close(fp, NULL);
22537
22639
 err1:
22538
22640
 	return BCME_ERROR;
22539
22641
 }
..
..
@@ -22549,8 +22651,8 @@
22549
22651
 	loff_t pos = 0;
22550
22652
 
22551
22653
 	/* Read memdump info from the file */
22552
-	fp = dhd_filp_open(filepath, file_mode, 0664);
22553
-	if (IS_ERR(fp) || (fp == NULL)) {
22654
+	fp = filp_open(filepath, file_mode, 0664);
22655
+	if (IS_ERR(fp)) {
22554
22656
 		DHD_ERROR(("%s: File [%s] doesn't exist\n", __FUNCTION__, filepath));
22555
22657
 #if defined(CONFIG_X86) && defined(OEM_ANDROID)
22556
22658
 		/* Check if it is Live Brix Image */
..
..
@@ -22560,8 +22662,8 @@
22560
22662
 		/* Try if it is Installed Brix Image */
22561
22663
 		filepath = RNDINFO_INST".out";
22562
22664
 		DHD_ERROR(("%s: Try File [%s]\n", __FUNCTION__, filepath));
22563
-		fp = dhd_filp_open(filepath, file_mode, 0664);
22564
-		if (IS_ERR(fp) || (fp == NULL)) {
22665
+		fp = filp_open(filepath, file_mode, 0664);
22666
+		if (IS_ERR(fp)) {
22565
22667
 			DHD_ERROR(("%s: File [%s] doesn't exist\n", __FUNCTION__, filepath));
22566
22668
 			goto err1;
22567
22669
 		}
..
..
@@ -22574,26 +22676,26 @@
22574
22676
 	set_fs(KERNEL_DS);
22575
22677
 
22576
22678
 	/* Handle success case */
22577
-	ret = dhd_vfs_write(fp, (char *)&rnd_len, sizeof(rnd_len), &pos);
22679
+	ret = vfs_write(fp, (char *)&rnd_len, sizeof(rnd_len), &pos);
22578
22680
 	if (ret < 0) {
22579
22681
 		DHD_ERROR(("%s: rnd_len write error, ret=%d\n", __FUNCTION__, ret));
22580
22682
 		goto err2;
22581
22683
 	}
22582
22684
 
22583
-	ret = dhd_vfs_write(fp, (char *)rnd_buf, rnd_len, &pos);
22685
+	ret = vfs_write(fp, (char *)rnd_buf, rnd_len, &pos);
22584
22686
 	if (ret < 0) {
22585
22687
 		DHD_ERROR(("%s: rnd_buf write error, ret=%d\n", __FUNCTION__, ret));
22586
22688
 		goto err2;
22587
22689
 	}
22588
22690
 
22589
22691
 	set_fs(old_fs);
22590
-	dhd_filp_close(fp, NULL);
22692
+	filp_close(fp, NULL);
22591
22693
 	DHD_ERROR(("%s: RND written to %s\n", __FUNCTION__, filepath));
22592
22694
 	return BCME_OK;
22593
22695
 
22594
22696
 err2:
22595
22697
 	set_fs(old_fs);
22596
-	dhd_filp_close(fp, NULL);
22698
+	filp_close(fp, NULL);
22597
22699
 err1:
22598
22700
 	return BCME_ERROR;
22599
22701
 
..
..
@@ -24511,8 +24613,8 @@
24511
24613
 	else
24512
24614
 		file_mode = O_CREAT | O_RDWR | O_SYNC;
24513
24615
 
24514
-	fp = dhd_filp_open(dump_path, file_mode, 0664);
24515
-	if (IS_ERR(fp) || (fp == NULL)) {
24616
+	fp = filp_open(dump_path, file_mode, 0664);
24617
+	if (IS_ERR(fp)) {
24516
24618
 		/* If android installed image, try '/data' directory */
24517
24619
 #if defined(CONFIG_X86) && defined(OEM_ANDROID)
24518
24620
 		DHD_ERROR(("%s: File open error on Installed android image, trying /data...\n",
..
..
@@ -24523,8 +24625,8 @@
24523
24625
 				sizeof(dump_path) - strlen(dump_path),
24524
24626
 				"_%s", dhdp->debug_dump_time_str);
24525
24627
 		}
24526
-		fp = dhd_filp_open(dump_path, file_mode, 0664);
24527
-		if (IS_ERR(fp) || (fp == NULL)) {
24628
+		fp = filp_open(dump_path, file_mode, 0664);
24629
+		if (IS_ERR(fp)) {
24528
24630
 			ret = PTR_ERR(fp);
24529
24631
 			DHD_ERROR(("open file error, err = %d\n", ret));
24530
24632
 			goto exit2;
..
..
@@ -24538,7 +24640,7 @@
24538
24640
 	}
24539
24641
 
24540
24642
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
24541
-	ret = dhd_vfs_stat(dump_path, &stat);
24643
+	ret = vfs_stat(dump_path, &stat);
24542
24644
 	if (ret < 0) {
24543
24645
 		DHD_ERROR(("file stat error, err = %d\n", ret));
24544
24646
 		goto exit2;
..
..
@@ -24707,7 +24809,7 @@
24707
24809
 
24708
24810
 exit2:
24709
24811
 	if (!IS_ERR(fp) && fp != NULL) {
24710
-		dhd_filp_close(fp, NULL);
24812
+		filp_close(fp, NULL);
24711
24813
 		DHD_ERROR(("%s: Finished writing log dump to file - '%s' \n",
24712
24814
 				__FUNCTION__, dump_path));
24713
24815
 	}
..
..
@@ -24742,7 +24844,7 @@
24742
24844
 	int ret = BCME_OK;
24743
24845
 
24744
24846
 	if (fp) {
24745
-		ret = dhd_vfs_write(fp, mem_buf, buf_len, (loff_t *)pos);
24847
+		ret = vfs_write(fp, mem_buf, buf_len, (loff_t *)pos);
24746
24848
 		if (ret < 0) {
24747
24849
 			DHD_ERROR(("write file error, err = %d\n", ret));
24748
24850
 			goto exit;
..
..
@@ -26643,8 +26745,8 @@
26643
26745
 	struct file *fp;
26644
26746
 	char *filepath = VENDOR_PATH CONFIG_BCMDHD_CLM_PATH;
26645
26747
 
26646
-	fp = dhd_filp_open(filepath, O_RDONLY, 0);
26647
-	if (IS_ERR(fp) || (fp == NULL)) {
26748
+	fp = filp_open(filepath, O_RDONLY, 0);
26749
+	if (IS_ERR(fp)) {
26648
26750
 		DHD_ERROR(("%s: ----- blob file doesn't exist (%s) -----\n", __FUNCTION__,
26649
26751
 			filepath));
26650
26752
 		dhdp->is_blob = FALSE;
..
..
@@ -26656,7 +26758,7 @@
26656
26758
 #else
26657
26759
 		BCM_REFERENCE(fw_path);
26658
26760
 #endif /* SKIP_CONCATE_BLOB */
26659
-		dhd_filp_close(fp, NULL);
26761
+		filp_close(fp, NULL);
26660
26762
 	}
26661
26763
 }
26662
26764
 #endif /* DHD_BLOB_EXISTENCE_CHECK */
..
..
@@ -26813,14 +26915,14 @@
26813
26915
 #endif
26814
26916
 
26815
26917
 	/* File is always created. */
26816
-	fp = dhd_filp_open(filepath, O_RDWR | O_CREAT, 0664);
26817
-	if (IS_ERR(fp) || (fp == NULL)) {
26918
+	fp = filp_open(filepath, O_RDWR | O_CREAT, 0664);
26919
+	if (IS_ERR(fp)) {
26818
26920
 		DHD_ERROR(("%s: Couldn't open file '%s' err %ld\n",
26819
26921
 			__FUNCTION__, filepath, PTR_ERR(fp)));
26820
26922
 		ret = BCME_ERROR;
26821
26923
 	} else {
26822
26924
 		if (fp->f_mode & FMODE_WRITE) {
26823
-			ret = dhd_vfs_write(fp, buf, buf_len, &fp->f_pos);
26925
+			ret = vfs_write(fp, buf, buf_len, &fp->f_pos);
26824
26926
 			if (ret < 0) {
26825
26927
 				DHD_ERROR(("%s: Couldn't write file '%s'\n",
26826
26928
 					__FUNCTION__, filepath));
..
..
@@ -26829,7 +26931,7 @@
26829
26931
 				ret = BCME_OK;
26830
26932
 			}
26831
26933
 		}
26832
-		dhd_filp_close(fp, NULL);
26934
+		filp_close(fp, NULL);
26833
26935
 	}
26834
26936
 
26835
26937
 	/* restore previous address limit */
..
..
@@ -26855,8 +26957,8 @@
26855
26957
 	set_fs(KERNEL_DS);
26856
26958
 #endif
26857
26959
 
26858
-	fp = dhd_filp_open(filepath, O_RDONLY, 0);
26859
-	if (IS_ERR(fp) || (fp == NULL)) {
26960
+	fp = filp_open(filepath, O_RDONLY, 0);
26961
+	if (IS_ERR(fp)) {
26860
26962
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
26861
26963
 		set_fs(old_fs);
26862
26964
 #endif
..
..
@@ -26864,8 +26966,8 @@
26864
26966
 		return BCME_ERROR;
26865
26967
 	}
26866
26968
 
26867
-	ret = dhd_kernel_read_compat(fp, 0, buf, buf_len);
26868
-	dhd_filp_close(fp, NULL);
26969
+	ret = kernel_read_compat(fp, 0, buf, buf_len);
26970
+	filp_close(fp, NULL);
26869
26971
 
26870
26972
 	/* restore previous address limit */
26871
26973
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
..
..
@@ -27172,7 +27274,15 @@
27172
27274
 dhd_get_random_bytes(uint8 *buf, uint len)
27173
27275
 {
27174
27276
 #ifdef BCMPCIE
27175
-	get_random_bytes(buf, len);
27277
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0))
27278
+	int rndlen = get_random_bytes_arch(buf, len);
27279
+	if (rndlen != len) {
27280
+		bzero(buf, len);
27281
+		get_random_bytes(buf, len);
27282
+	}
27283
+#else
27284
+	get_random_bytes_arch(buf, len);
27285
+#endif
27176
27286
 #endif /* BCMPCIE */
27177
27287
 	return BCME_OK;
27178
27288
 }
..
..
@@ -29657,15 +29767,27 @@
29657
29767
 }
29658
29768
 /* END of DHD RING */
29659
29769
 
29770
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 19, 0))
29771
+#define DHD_VFS_INODE(dir) (dir->d_inode)
29772
+#else
29773
+#define DHD_VFS_INODE(dir) d_inode(dir)
29774
+#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3, 19, 0) */
29775
+
29776
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 13, 0))
29777
+#define DHD_VFS_UNLINK(dir, b, c) vfs_unlink(DHD_VFS_INODE(dir), b)
29778
+#else
29779
+#define DHD_VFS_UNLINK(dir, b, c) vfs_unlink(DHD_VFS_INODE(dir), b, c)
29780
+#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3, 13, 0) */
29781
+
29660
29782
 #if ((defined DHD_DUMP_MNGR) || (defined DNGL_AXI_ERROR_LOGGING))
29661
29783
 int
29662
29784
 dhd_file_delete(char *path)
29663
29785
 {
29664
-	struct path file_path = {.dentry = 0};
29786
+	struct path file_path;
29665
29787
 	int err;
29666
29788
 	struct dentry *dir;
29667
29789
 
29668
-	err = dhd_kern_path(path, 0, &file_path);
29790
+	err = kern_path(path, 0, &file_path);
29669
29791
 
29670
29792
 	if (err < 0) {
29671
29793
 		DHD_ERROR(("Failed to get kern-path delete file: %s error: %d\n", path, err));