qcacmn: utils: Remove redundant __func__ from the logs

1. The logging macros implicitly takes care of embedding function name
in the log, hence there is no need to include __func__ again.
Getting rid of redundant __func__ reduces driver memory footprint.

2. Instead of adding __func__ to the qdf_nofl_* macros, its better to use
   qdf_* which already takes care of adding __func__.

Change-Id: If5717c811016845b5cffcf3fdc97805f3a1b731b
CRs-Fixed: 2774457

utils/logging/src/wlan_logging_sock_svc.c

@@ -585,8 +585,8 @@ static int pktlog_send_per_pkt_stats_to_user(void)
 		skb_new = dev_alloc_skb(MAX_SKBMSG_LENGTH);
 		if (!skb_new) {
 			if (!rate_limit) {
-				qdf_nofl_err("%s: dev_alloc_skb() failed for msg size[%d] drop count = %u",
-					     __func__, MAX_SKBMSG_LENGTH,
+				qdf_err("dev_alloc_skb() failed for msg size[%d] drop count = %u",
+					MAX_SKBMSG_LENGTH,
 					gwlan_logging.drop_count);
 			}
 			rate_limit = 1;
@@ -603,15 +603,13 @@ static int pktlog_send_per_pkt_stats_to_user(void)
 
 		ret = pkt_stats_fill_headers(pstats_msg->skb);
 		if (ret < 0) {
-			qdf_nofl_err("%s failed to fill headers %d",
-				     __func__, ret);
+			qdf_err("Failed to fill headers %d", ret);
 			free_old_skb = true;
 			goto err;
 		}
 		ret = nl_srv_bcast_diag(pstats_msg->skb);
 		if (ret < 0) {
-			qdf_nofl_info("%s: Send Failed %d drop_count = %u",
-				      __func__, ret,
+			qdf_info("Send Failed %d drop_count = %u", ret,
 				++gwlan_logging.pkt_stat_drop_cnt);
 		} else {
 			ret = 0;
@@ -662,9 +660,9 @@ static int send_filled_buffers_to_user(void)
 		skb = dev_alloc_skb(MAX_LOGMSG_LENGTH);
 		if (!skb) {
 			if (!rate_limit) {
-				qdf_nofl_err("%s: dev_alloc_skb() failed for msg size[%d] drop count = %u",
-					     __func__, MAX_LOGMSG_LENGTH,
-					     gwlan_logging.drop_count);
+				qdf_err("dev_alloc_skb() failed for msg size[%d] drop count = %u",
+					MAX_LOGMSG_LENGTH,
+					gwlan_logging.drop_count);
 			}
 			rate_limit = 1;
 			ret = -ENOMEM;
@@ -690,10 +688,9 @@ static int send_filled_buffers_to_user(void)
 			list_add_tail(&plog_msg->node,
 				      &gwlan_logging.free_list);
 			spin_unlock_irqrestore(&gwlan_logging.spin_lock, flags);
-			qdf_nofl_err("%s: drop_count = %u", __func__,
-				     ++gwlan_logging.drop_count);
-			qdf_nofl_err("%s: nlmsg_put() failed for msg size[%d]",
-				     __func__, tot_msg_len);
+			qdf_err("drop_count = %u", ++gwlan_logging.drop_count);
+			qdf_err("nlmsg_put() failed for msg size[%d]",
+				tot_msg_len);
 			dev_kfree_skb(skb);
 			skb = NULL;
 			ret = -EINVAL;
@@ -712,8 +709,8 @@ static int send_filled_buffers_to_user(void)
 		ret = nl_srv_bcast_host_logs(skb);
 		/* print every 64th drop count */
 		if (ret < 0 && (!(gwlan_logging.drop_count % 0x40))) {
-			qdf_nofl_err("%s: Send Failed %d drop_count = %u",
-				     __func__, ret, ++gwlan_logging.drop_count);
+			qdf_err("Send Failed %d drop_count = %u",
+				ret, ++gwlan_logging.drop_count);
 		}
 	}
 
@@ -821,8 +818,7 @@ static int wlan_logging_thread(void *Arg)
 						  || gwlan_logging.exit));
 
 		if (ret_wait_status == -ERESTARTSYS) {
-			qdf_nofl_err("%s: wait_event_interruptible returned -ERESTARTSYS",
-				     __func__);
+			qdf_err("wait_event_interruptible returned -ERESTARTSYS");
 			break;
 		}
 
@@ -1078,8 +1074,7 @@ int wlan_logging_sock_init_svc(void)
 	gwlan_logging.buffer_length = MAX_LOGMSG_LENGTH;
 
 	if (allocate_log_msg_buffer() != QDF_STATUS_SUCCESS) {
-		qdf_nofl_err("%s: Could not allocate memory for log_msg",
-			     __func__);
+		qdf_err("Could not allocate memory for log_msg");
 		return -ENOMEM;
 	}
 
@@ -1101,8 +1096,7 @@ int wlan_logging_sock_init_svc(void)
 	pkt_stats_size = sizeof(struct pkt_stats_msg);
 	gpkt_stats_buffers = vmalloc(MAX_PKTSTATS_BUFF * pkt_stats_size);
 	if (!gpkt_stats_buffers) {
-		qdf_nofl_err("%s: Could not allocate memory for Pkt stats",
-			     __func__);
+		qdf_err("Could not allocate memory for Pkt stats");
 		goto err1;
 	}
 	qdf_mem_zero(gpkt_stats_buffers,
@@ -1118,8 +1112,7 @@ int wlan_logging_sock_init_svc(void)
 	for (i = 0; i < MAX_PKTSTATS_BUFF; i++) {
 		gpkt_stats_buffers[i].skb = dev_alloc_skb(MAX_PKTSTATS_LENGTH);
 		if (!gpkt_stats_buffers[i].skb) {
-			qdf_nofl_err("%s: Memory alloc failed for skb",
-				     __func__);
+			qdf_err("Memory alloc failed for skb");
 			/* free previously allocated skb and return */
 			for (j = 0; j < i ; j++)
 				dev_kfree_skb(gpkt_stats_buffers[j].skb);
@@ -1146,8 +1139,7 @@ int wlan_logging_sock_init_svc(void)
 	gwlan_logging.thread = kthread_create(wlan_logging_thread, NULL,
 					      "wlan_logging_thread");
 	if (IS_ERR(gwlan_logging.thread)) {
-		qdf_nofl_err("%s: Could not Create LogMsg Thread Controller",
-			     __func__);
+		qdf_err("Could not Create LogMsg Thread Controller");
 		goto err3;
 	}
 	wake_up_process(gwlan_logging.thread);
@@ -1278,8 +1270,7 @@ void wlan_flush_host_logs_for_fatal(void)
 	unsigned long flags;
 
 	if (gwlan_logging.flush_timer_period == 0)
-		qdf_nofl_info("%s:flush all host logs Setting HOST_LOG_POST_MAS",
-			      __func__);
+		qdf_info("Flush all host logs Setting HOST_LOG_POST_MAS");
 	spin_lock_irqsave(&gwlan_logging.spin_lock, flags);
 	wlan_queue_logmsg_for_app();
 	spin_unlock_irqrestore(&gwlan_logging.spin_lock, flags);
@@ -1326,8 +1317,8 @@ static int wlan_get_pkt_stats_free_node(void)
 		if (
 			cds_is_multicast_logging() &&
 			(!(gwlan_logging.pkt_stat_drop_cnt % 0x40))) {
-			qdf_nofl_err("%s: drop_count = %u",
-				     __func__, gwlan_logging.pkt_stat_drop_cnt);
+			qdf_err("drop_count = %u",
+				gwlan_logging.pkt_stat_drop_cnt);
 		}
 		list_del_init(gwlan_logging.pkt_stat_filled_list.next);
 		ret = 1;
@@ -1362,7 +1353,7 @@ void wlan_pkt_stats_to_logger_thread(void *pl_hdr, void *pkt_dump, void *data)
 	pktlog_hdr = (struct ath_pktlog_hdr *)pl_hdr;
 
 	if (!pktlog_hdr) {
-		qdf_nofl_err("%s : Invalid pkt_stats_header", __func__);
+		qdf_err("Invalid pkt_stats_header");
 		return;
 	}
 
@@ -1472,7 +1463,7 @@ static void send_packetdump(ol_txrx_soc_handle soc,
 	struct packet_dump pd_hdr = {0};
 
 	if (!netbuf) {
-		qdf_nofl_err("%s: Invalid netbuf.", __func__);
+		qdf_err("Invalid netbuf");
 		return;
 	}
 

utils/pktlog/linux_ac.c

@@ -109,8 +109,7 @@ int pktlog_alloc_buf(struct hif_opaque_softc *scn)
 	pl_dev = get_pktlog_handle();
 
 	if (!pl_dev) {
-		qdf_nofl_info(PKTLOG_TAG
-			      "%s: pdev_txrx_handle->pl_dev is null", __func__);
+		qdf_info(PKTLOG_TAG "pdev_txrx_handle->pl_dev is null");
 		return -EINVAL;
 	}
 
@@ -162,12 +161,12 @@ void pktlog_release_buf(struct hif_opaque_softc *scn)
 	pl_dev = get_pktlog_handle();
 
 	if (!pl_dev) {
-		qdf_print("%s: invalid pl_dev handle", __func__);
+		qdf_print("Invalid pl_dev handle");
 		return;
 	}
 
 	if (!pl_dev->pl_info) {
-		qdf_print("%s: invalid pl_dev handle", __func__);
+		qdf_print("Invalid pl_dev handle");
 		return;
 	}
 
@@ -207,7 +206,7 @@ qdf_sysctl_decl(ath_sysctl_pktlog_enable, ctl, write, filp, buffer, lenp, ppos)
 
 	if (!scn) {
 		mutex_unlock(&proc_mutex);
-		qdf_nofl_info("%s: Invalid scn context", __func__);
+		qdf_info("Invalid scn context");
 		ASSERT(0);
 		return -EINVAL;
 	}
@@ -216,7 +215,7 @@ qdf_sysctl_decl(ath_sysctl_pktlog_enable, ctl, write, filp, buffer, lenp, ppos)
 
 	if (!pl_dev) {
 		mutex_unlock(&proc_mutex);
-		qdf_nofl_info("%s: Invalid pktlog context", __func__);
+		qdf_info("Invalid pktlog context");
 		ASSERT(0);
 		return -ENODEV;
 	}
@@ -270,7 +269,7 @@ qdf_sysctl_decl(ath_sysctl_pktlog_size, ctl, write, filp, buffer, lenp, ppos)
 
 	if (!scn) {
 		mutex_unlock(&proc_mutex);
-		qdf_nofl_info("%s: Invalid scn context", __func__);
+		qdf_info("Invalid scn context");
 		ASSERT(0);
 		return -EINVAL;
 	}
@@ -279,7 +278,7 @@ qdf_sysctl_decl(ath_sysctl_pktlog_size, ctl, write, filp, buffer, lenp, ppos)
 
 	if (!pl_dev) {
 		mutex_unlock(&proc_mutex);
-		qdf_nofl_info("%s: Invalid pktlog handle", __func__);
+		qdf_info("Invalid pktlog handle");
 		ASSERT(0);
 		return -ENODEV;
 	}
@@ -458,16 +457,15 @@ static int pktlog_attach(struct hif_opaque_softc *scn)
 			&pl_info_lnx->info);
 
 	if (!proc_entry) {
-		qdf_nofl_info(PKTLOG_TAG "%s: create_proc_entry failed for %s",
-			      __func__, proc_name);
+		qdf_info(PKTLOG_TAG "create_proc_entry failed for %s", proc_name);
 		goto attach_fail1;
 	}
 
 	pl_info_lnx->proc_entry = proc_entry;
 
 	if (pktlog_sysctl_register(scn)) {
-		qdf_nofl_info(PKTLOG_TAG "%s: sysctl register failed for %s",
-			      __func__, proc_name);
+		qdf_nofl_info(PKTLOG_TAG "sysctl register failed for %s",
+			      proc_name);
 		goto attach_fail2;
 	}
 
@@ -488,7 +486,7 @@ static void pktlog_sysctl_unregister(struct pktlog_dev_t *pl_dev)
 	struct ath_pktlog_info_lnx *pl_info_lnx;
 
 	if (!pl_dev) {
-		qdf_nofl_info("%s: Invalid pktlog context", __func__);
+		qdf_info("Invalid pktlog context");
 		ASSERT(0);
 		return;
 	}
@@ -508,14 +506,14 @@ static void pktlog_detach(struct hif_opaque_softc *scn)
 	struct pktlog_dev_t *pl_dev = get_pktlog_handle();
 
 	if (!pl_dev) {
-		qdf_nofl_info("%s: Invalid pktlog context", __func__);
+		qdf_info("Invalid pktlog context");
 		ASSERT(0);
 		return;
 	}
 
 	pl_info = pl_dev->pl_info;
 	if (!pl_info) {
-		qdf_print("%s: Invalid pktlog handle", __func__);
+		qdf_print("Invalid pktlog handle");
 		ASSERT(0);
 		return;
 	}
@@ -550,7 +548,7 @@ static int __pktlog_open(struct inode *i, struct file *f)
 	PKTLOG_MOD_INC_USE_COUNT;
 	scn = cds_get_context(QDF_MODULE_ID_HIF);
 	if (!scn) {
-		qdf_print("%s: Invalid scn context", __func__);
+		qdf_print("Invalid scn context");
 		ASSERT(0);
 		return -EINVAL;
 	}
@@ -558,7 +556,7 @@ static int __pktlog_open(struct inode *i, struct file *f)
 	pl_dev = get_pktlog_handle();
 
 	if (!pl_dev) {
-		qdf_print("%s: Invalid pktlog handle", __func__);
+		qdf_print("Invalid pktlog handle");
 		ASSERT(0);
 		return -ENODEV;
 	}
@@ -566,7 +564,7 @@ static int __pktlog_open(struct inode *i, struct file *f)
 	pl_info = pl_dev->pl_info;
 
 	if (!pl_info) {
-		qdf_nofl_err("%s: pl_info NULL", __func__);
+		qdf_err("pl_info NULL");
 		return -EINVAL;
 	}
 
@@ -576,15 +574,15 @@ static int __pktlog_open(struct inode *i, struct file *f)
 
 	if (!pl_info_lnx->sysctl_header) {
 		mutex_unlock(&pl_info->pktlog_mutex);
-		qdf_print("%s: pktlog sysctl is unergistered.", __func__);
+		qdf_print("pktlog sysctl is unergistered");
 		ASSERT(0);
 		return -EINVAL;
 	}
 
 	if (pl_info->curr_pkt_state != PKTLOG_OPR_NOT_IN_PROGRESS) {
 		mutex_unlock(&pl_info->pktlog_mutex);
-		qdf_print("%s: plinfo state (%d) != PKTLOG_OPR_NOT_IN_PROGRESS",
-			  __func__, pl_info->curr_pkt_state);
+		qdf_print("plinfo state (%d) != PKTLOG_OPR_NOT_IN_PROGRESS",
+			  pl_info->curr_pkt_state);
 		return -EBUSY;
 	}
 
@@ -636,7 +634,7 @@ static int __pktlog_release(struct inode *i, struct file *f)
 	PKTLOG_MOD_DEC_USE_COUNT;
 	scn = cds_get_context(QDF_MODULE_ID_HIF);
 	if (!scn) {
-		qdf_print("%s: Invalid scn context", __func__);
+		qdf_print("Invalid scn context");
 		ASSERT(0);
 		return -EINVAL;
 	}
@@ -644,7 +642,7 @@ static int __pktlog_release(struct inode *i, struct file *f)
 	pl_dev = get_pktlog_handle();
 
 	if (!pl_dev) {
-		qdf_print("%s: Invalid pktlog handle", __func__);
+		qdf_print("Invalid pktlog handle");
 		ASSERT(0);
 		return -ENODEV;
 	}
@@ -652,7 +650,7 @@ static int __pktlog_release(struct inode *i, struct file *f)
 	pl_info = pl_dev->pl_info;
 
 	if (!pl_info) {
-		qdf_print("%s: Invalid pktlog info", __func__);
+		qdf_print("Invalid pktlog info");
 		ASSERT(0);
 		return -EINVAL;
 	}
@@ -664,7 +662,7 @@ static int __pktlog_release(struct inode *i, struct file *f)
 	if (!pl_info_lnx->sysctl_header) {
 		pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
 		mutex_unlock(&pl_info->pktlog_mutex);
-		qdf_print("%s: pktlog sysctl is unergistered.", __func__);
+		qdf_print("pktlog sysctl is unergistered");
 		ASSERT(0);
 		return -EINVAL;
 	}
@@ -682,8 +680,7 @@ static int __pktlog_release(struct inode *i, struct file *f)
 	pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
 	mutex_unlock(&pl_info->pktlog_mutex);
 	if (ret != 0)
-		qdf_print("%s: pktlog cannot be enabled. ret value %d",
-			  __func__, ret);
+		qdf_print("pktlog cannot be enabled. ret value %d", ret);
 
 	return ret;
 }
@@ -1045,7 +1042,7 @@ int pktlogmod_init(void *context)
 	g_pktlog_pde = proc_mkdir(PKTLOG_PROC_DIR, NULL);
 
 	if (!g_pktlog_pde) {
-		qdf_nofl_info(PKTLOG_TAG "%s: proc_mkdir failed", __func__);
+		qdf_info(PKTLOG_TAG "proc_mkdir failed");
 		return -EPERM;
 	}
 

utils/pktlog/pktlog_ac.c

@@ -177,7 +177,7 @@ wdi_pktlog_subscribe(uint8_t pdev_id, int32_t log_state)
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 
 	if (pdev_id < 0) {
-		qdf_print("Invalid pdev in %s", __func__);
+		qdf_print("Invalid pdev");
 		return A_ERROR;
 	}
 
@@ -229,7 +229,7 @@ wdi_pktlog_subscribe(uint8_t pdev_id, int32_t log_state)
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 
 	if (pdev_id < 0) {
-		qdf_print("Invalid pdev in %s", __func__);
+		qdf_print("Invalid pdev");
 		return A_ERROR;
 	}
 
@@ -636,28 +636,28 @@ int __pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
 	int error;
 
 	if (!scn) {
-		qdf_print("%s: Invalid scn context", __func__);
+		qdf_print("Invalid scn context");
 		ASSERT(0);
 		return -EINVAL;
 	}
 
 	pl_dev = get_pktlog_handle();
 	if (!pl_dev) {
-		qdf_print("%s: Invalid pktlog context", __func__);
+		qdf_print("Invalid pktlog context");
 		ASSERT(0);
 		return -EINVAL;
 	}
 
 	pdev_id = WMI_PDEV_ID_SOC;
 	if (pdev_id < 0) {
-		qdf_print("%s: Invalid txrx context", __func__);
+		qdf_print("Invalid txrx context");
 		ASSERT(0);
 		return -EINVAL;
 	}
 
 	pl_info = pl_dev->pl_info;
 	if (!pl_info) {
-		qdf_print("%s: Invalid pl_info context", __func__);
+		qdf_print("Invalid pl_info context");
 		ASSERT(0);
 		return -EINVAL;
 	}
@@ -674,7 +674,7 @@ int __pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
 	if (is_iwpriv_command == 0 && log_state == 0 &&
 	    pl_dev->vendor_cmd_send == false) {
 		pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
-		qdf_print("%s: pktlog operation not in progress", __func__);
+		qdf_print("pktlog operation not in progress");
 		return 0;
 	}
 
@@ -685,16 +685,14 @@ int __pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
 			if (error != 0) {
 				pl_info->curr_pkt_state =
 					PKTLOG_OPR_NOT_IN_PROGRESS;
-				qdf_print("%s: pktlog buff alloc failed",
-					  __func__);
+				qdf_print("pktlog buff alloc failed");
 				return -ENOMEM;
 			}
 
 			if (!pl_info->buf) {
 				pl_info->curr_pkt_state =
 					PKTLOG_OPR_NOT_IN_PROGRESS;
-				qdf_print("%s: pktlog buf alloc failed",
-					  __func__);
+				qdf_print("pktlog buf alloc failed");
 				ASSERT(0);
 				return -ENOMEM;
 			}
@@ -724,21 +722,20 @@ int __pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
 			if (error) {
 				pl_info->curr_pkt_state =
 						PKTLOG_OPR_NOT_IN_PROGRESS;
-				qdf_print("Unable to subscribe to the WDI %s",
-					  __func__);
+				qdf_print("Unable to subscribe to the WDI");
 				return -EINVAL;
 			}
 		} else {
 			pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
-			qdf_print("Unable to subscribe %d to the WDI %s",
-				  log_state, __func__);
+			qdf_print("Unable to subscribe %d to the WDI",
+				  log_state);
 			return -EINVAL;
 		}
 		/* WMI command to enable pktlog on the firmware */
 		if (pktlog_enable_tgt(scn, log_state, ini_triggered,
 				user_triggered)) {
 			pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
-			qdf_print("Device cannot be enabled, %s", __func__);
+			qdf_print("Device cannot be enabled");
 			return -EINVAL;
 		}
 		pl_dev->is_pktlog_cb_subscribed = true;
@@ -768,14 +765,14 @@ int pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
 	pl_dev = get_pktlog_handle();
 
 	if (!pl_dev) {
-		qdf_print("%s: invalid pl_dev handle", __func__);
+		qdf_print("Invalid pl_dev handle");
 		return -EINVAL;
 	}
 
 	pl_info = pl_dev->pl_info;
 
 	if (!pl_info) {
-		qdf_print("%s: invalid pl_info handle", __func__);
+		qdf_print("Invalid pl_info handle");
 		return -EINVAL;
 	}
 
@@ -798,24 +795,24 @@ static int __pktlog_setsize(struct hif_opaque_softc *scn, int32_t size)
 	pl_dev = get_pktlog_handle();
 
 	if (!pl_dev) {
-		qdf_print("%s: invalid pl_dev handle", __func__);
+		qdf_print("Invalid pl_dev handle");
 		return -EINVAL;
 	}
 
 	pl_info = pl_dev->pl_info;
 
 	if (!pl_info) {
-		qdf_print("%s: invalid pl_dev handle", __func__);
+		qdf_print("Invalid pl_dev handle");
 		return -EINVAL;
 	}
 
 	if (pdev_id < 0) {
-		qdf_print("%s: invalid pdev", __func__);
+		qdf_print("Invalid pdev");
 		return -EINVAL;
 	}
 
 	if (pl_info->curr_pkt_state < PKTLOG_OPR_NOT_IN_PROGRESS) {
-		qdf_print("%s: pktlog is not configured", __func__);
+		qdf_print("pktlog is not configured");
 		return -EBUSY;
 	}
 
@@ -825,25 +822,23 @@ static int __pktlog_setsize(struct hif_opaque_softc *scn, int32_t size)
 	max_allowed_buff_size = (buff_size ? buff_size : ONE_MEGABYTE);
 
 	if (size < ONE_MEGABYTE || size > max_allowed_buff_size) {
-		qdf_print("%s: Cannot Set Pktlog Buffer size of %d bytes.Min required is %d MB and Max allowed is %d MB.",
-			  __func__, size, (ONE_MEGABYTE / ONE_MEGABYTE),
+		qdf_print("Cannot Set Pktlog Buffer size of %d bytes.Min required is %d MB and Max allowed is %d MB",
+			  size, (ONE_MEGABYTE / ONE_MEGABYTE),
 			  (max_allowed_buff_size / ONE_MEGABYTE));
 		pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
-		qdf_print("%s: Invalid requested buff size", __func__);
+		qdf_print("Invalid requested buff size");
 		return -EINVAL;
 	}
 
 	if (size == pl_info->buf_size) {
 		pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
-		qdf_print("%s: Pktlog Buff Size is already of same size.",
-			  __func__);
+		qdf_print("Pktlog Buff Size is already of same size");
 		return 0;
 	}
 
 	if (pl_info->log_state) {
 		pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
-		qdf_print("%s: Logging should be disabled before changing"
-			  "buffer size.", __func__);
+		qdf_print("Logging should be disabled before changing buffer size");
 		return -EINVAL;
 	}
 
@@ -863,7 +858,7 @@ static int __pktlog_setsize(struct hif_opaque_softc *scn, int32_t size)
 	}
 
 	if (size != 0) {
-		qdf_print("%s: New Pktlog Buff Size is %d", __func__, size);
+		qdf_print("New Pktlog Buff Size is %d", size);
 		pl_info->buf_size = size;
 	}
 	pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
@@ -880,14 +875,14 @@ int pktlog_setsize(struct hif_opaque_softc *scn, int32_t size)
 	pl_dev = get_pktlog_handle();
 
 	if (!pl_dev) {
-		qdf_print("%s: invalid pl_dev handle", __func__);
+		qdf_print("Invalid pl_dev handle");
 		return -EINVAL;
 	}
 
 	pl_info = pl_dev->pl_info;
 
 	if (!pl_info) {
-		qdf_print("%s: invalid pl_dev handle", __func__);
+		qdf_print("Invalid pl_dev handle");
 		return -EINVAL;
 	}
 
@@ -907,14 +902,14 @@ int pktlog_clearbuff(struct hif_opaque_softc *scn, bool clear_buff)
 	pl_dev = get_pktlog_handle();
 
 	if (!pl_dev) {
-		qdf_print("%s: invalid pl_dev handle", __func__);
+		qdf_print("Invalid pl_dev handle");
 		return -EINVAL;
 	}
 
 	pl_info = pl_dev->pl_info;
 
 	if (!pl_info) {
-		qdf_print("%s: invalid pl_dev handle", __func__);
+		qdf_print("Invalid pl_dev handle");
 		return -EINVAL;
 	}
 
@@ -931,8 +926,7 @@ int pktlog_clearbuff(struct hif_opaque_softc *scn, bool clear_buff)
 
 	if (pl_info->log_state) {
 		pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
-		qdf_print("%s: Logging should be disabled before clearing "
-			  "pktlog buffer.", __func__);
+		qdf_print("Logging should be disabled before clearing pktlog buffer");
 		return -EINVAL;
 	}
 
@@ -945,14 +939,14 @@ int pktlog_clearbuff(struct hif_opaque_softc *scn, bool clear_buff)
 			pl_info->buf->rd_offset = -1;
 		} else {
 			pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
-			qdf_print("%s: pktlog buffer size is not proper. "
-				  "Existing Buf size %d", __func__,
+			qdf_print("pktlog buffer size is not proper. "
+				  "Existing Buf size %d",
 				  pl_info->buf_size);
 			return -EFAULT;
 		}
 	} else {
 		pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
-		qdf_print("%s: pktlog buff is NULL", __func__);
+		qdf_print("pktlog buff is NULL");
 		return -EFAULT;
 	}
 
@@ -972,7 +966,7 @@ void pktlog_process_fw_msg(uint8_t pdev_id, uint32_t *buff, uint32_t len)
 	struct ol_fw_data pl_fw_data;
 
 	if (pdev_id == OL_TXRX_INVALID_PDEV_ID) {
-		qdf_print("%s: txrx pdev_id is invalid", __func__);
+		qdf_print("txrx pdev_id is invalid");
 		return;
 	}
 	pl_hdr = buff;
@@ -1032,8 +1026,8 @@ static void pktlog_t2h_msg_handler(void *context, HTC_PACKET *pkt)
 
 	/* check for sanity of the packet, have seen corrupted pkts */
 	if (pktlog_nbuf_check_sanity(pktlog_t2h_msg)) {
-		qdf_print("%s: packet 0x%pK corrupted? Leaking...",
-			  __func__, pktlog_t2h_msg);
+		qdf_print("packet 0x%pK corrupted? Leaking...",
+			  pktlog_t2h_msg);
 		/* do not free; may crash! */
 		QDF_ASSERT(0);
 		return;
@@ -1065,7 +1059,7 @@ static void pktlog_t2h_msg_handler(void *context, HTC_PACKET *pkt)
  */
 static void pktlog_tx_resume_handler(void *context)
 {
-	qdf_print("%s: Not expected", __func__);
+	qdf_print("Not expected");
 	qdf_assert(0);
 }
 
@@ -1078,7 +1072,7 @@ static void pktlog_tx_resume_handler(void *context)
  */
 static void pktlog_h2t_send_complete(void *context, HTC_PACKET *htc_pkt)
 {
-	qdf_print("%s: Not expected", __func__);
+	qdf_print("Not expected");
 	qdf_assert(0);
 }
 

utils/pktlog/pktlog_internal.c

@@ -86,7 +86,7 @@ void pktlog_getbuf_intsafe(struct ath_pktlog_arg *plarg)
 #endif
 
 	if (!plarg) {
-		qdf_nofl_info("Invalid parg in %s", __func__);
+		qdf_info("Invalid parg");
 		return;
 	}
 
@@ -102,7 +102,7 @@ void pktlog_getbuf_intsafe(struct ath_pktlog_arg *plarg)
 	flags = plarg->flags;
 
 	if (!log_buf) {
-		qdf_nofl_info("Invalid log_buf in %s", __func__);
+		qdf_info("Invalid log_buf");
 		return;
 	}
 

utils/pktlog/pktlog_wifi2.c

@@ -205,12 +205,12 @@ A_STATUS process_tx_info(struct cdp_pdev *txrx_pdev, void *data)
 	uint32_t len;
 
 	if (!txrx_pdev) {
-		qdf_nofl_info("Invalid pdev in %s", __func__);
+		qdf_info("Invalid pdev");
 		return A_ERROR;
 	}
 
 	if (!pl_dev) {
-		qdf_nofl_err("Invalid pktlog handle in %s", __func__);
+		qdf_err("Invalid pktlog handle");
 		qdf_assert(pl_dev);
 		return A_ERROR;
 	}
@@ -231,7 +231,7 @@ A_STATUS process_tx_info(struct cdp_pdev *txrx_pdev, void *data)
 		       (ATH_PKTLOG_HDR_SIZE_OFFSET + 1)) ||
 		len < (sizeof(uint32_t) *
 		       (ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET + 1))) {
-		qdf_print("Invalid msdu len in %s", __func__);
+		qdf_print("Invalid msdu len");
 		qdf_assert(0);
 		return A_ERROR;
 	}
@@ -318,12 +318,12 @@ A_STATUS process_tx_info(struct cdp_pdev *txrx_pdev, void *data)
 	uint32_t len;
 
 	if (!txrx_pdev) {
-		qdf_print("Invalid pdev in %s", __func__);
+		qdf_print("Invalid pdev");
 		return A_ERROR;
 	}
 
 	if (!pl_dev) {
-		qdf_nofl_err("Invalid pktlog handle in %s", __func__);
+		qdf_err("Invalid pktlog handle");
 		qdf_assert(pl_dev);
 		return A_ERROR;
 	}
@@ -342,7 +342,7 @@ A_STATUS process_tx_info(struct cdp_pdev *txrx_pdev, void *data)
 		       (ATH_PKTLOG_HDR_SIZE_OFFSET + 1)) ||
 		len < (sizeof(uint32_t) *
 		       (ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET + 1))) {
-		qdf_print("Invalid msdu len in %s", __func__);
+		qdf_print("Invalid msdu len");
 		qdf_assert(0);
 		return A_ERROR;
 	}
@@ -506,7 +506,7 @@ A_STATUS process_rx_info_remote(void *pdev, void *data)
 	qdf_nbuf_t msdu;
 
 	if (!pdev || !r_data || !pl_dev) {
-		qdf_print("%s: Invalid handle", __func__);
+		qdf_print("Invalid handle");
 		return A_ERROR;
 	}
 
@@ -568,13 +568,13 @@ A_STATUS process_rx_info(void *pdev, void *data)
 	uint32_t len;
 
 	if (!pdev) {
-		qdf_nofl_info("Invalid pdev in %s", __func__);
+		qdf_info("Invalid pdev");
 		return A_ERROR;
 	}
 
 	pl_dev = ((struct ol_txrx_pdev_t *)pdev)->pl_dev;
 	if (!pl_dev) {
-		qdf_nofl_info("Invalid pl_dev in %s", __func__);
+		qdf_info("Invalid pl_dev");
 		return A_ERROR;
 	}
 
@@ -592,7 +592,7 @@ A_STATUS process_rx_info(void *pdev, void *data)
 		       (ATH_PKTLOG_HDR_SIZE_OFFSET + 1)) ||
 		len < (sizeof(uint32_t) *
 		       (ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET + 1))) {
-		qdf_print("Invalid msdu len in %s", __func__);
+		qdf_print("Invalid msdu len");
 		qdf_assert(0);
 		return A_ERROR;
 	}
@@ -645,13 +645,13 @@ A_STATUS process_rx_info(void *pdev, void *data)
 	uint32_t len;
 
 	if (!pdev) {
-		qdf_nofl_info("Invalid pdev in %s", __func__);
+		qdf_info("Invalid pdev");
 		return A_ERROR;
 	}
 
 	pl_dev = ((struct ol_txrx_pdev_t *)pdev)->pl_dev;
 	if (!pl_dev) {
-		qdf_nofl_info("Invalid pl_dev in %s", __func__);
+		qdf_info("Invalid pl_dev");
 		return A_ERROR;
 	}
 
@@ -667,7 +667,7 @@ A_STATUS process_rx_info(void *pdev, void *data)
 		       (ATH_PKTLOG_HDR_SIZE_OFFSET + 1)) ||
 		len < (sizeof(uint32_t) *
 		       (ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET + 1))) {
-		qdf_print("Invalid msdu len in %s", __func__);
+		qdf_print("Invalid msdu len");
 		qdf_assert(0);
 		return A_ERROR;
 	}
@@ -723,7 +723,7 @@ A_STATUS process_rate_find(void *pdev, void *data)
 	uint32_t *pl_tgt_hdr;
 
 	if (!pdev || !data || !pl_dev) {
-		qdf_print("%s: Invalid handle", __func__);
+		qdf_print("Invalid handle");
 		return A_ERROR;
 	}
 
@@ -741,7 +741,7 @@ A_STATUS process_rate_find(void *pdev, void *data)
 		       (ATH_PKTLOG_HDR_SIZE_OFFSET + 1)) ||
 		len < (sizeof(uint32_t) *
 		       (ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET + 1))) {
-		qdf_print("Invalid msdu len in %s", __func__);
+		qdf_print("Invalid msdu len");
 		qdf_assert(0);
 		return A_ERROR;
 	}
@@ -805,7 +805,7 @@ A_STATUS process_rate_find(void *pdev, void *data)
 	uint32_t *pl_tgt_hdr;
 
 	if (!pdev || !data || !pl_dev) {
-		qdf_print("%s: Invalid handle", __func__);
+		qdf_print("Invalid handle");
 		return A_ERROR;
 	}
 
@@ -821,7 +821,7 @@ A_STATUS process_rate_find(void *pdev, void *data)
 		       (ATH_PKTLOG_HDR_SIZE_OFFSET + 1)) ||
 		len < (sizeof(uint32_t) *
 		       (ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET + 1))) {
-		qdf_print("Invalid msdu len in %s", __func__);
+		qdf_print("Invalid msdu len");
 		qdf_assert(0);
 		return A_ERROR;
 	}
@@ -876,7 +876,7 @@ A_STATUS process_rate_update(void *pdev, void *data)
 	uint32_t len;
 
 	if (!pdev || !data || !pl_dev) {
-		qdf_print("%s: Invalid handle", __func__);
+		qdf_print("Invalid handle");
 		return A_ERROR;
 	}
 
@@ -894,7 +894,7 @@ A_STATUS process_rate_update(void *pdev, void *data)
 		       (ATH_PKTLOG_HDR_SIZE_OFFSET + 1)) ||
 		len < (sizeof(uint32_t) *
 		       (ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET + 1))) {
-		qdf_print("Invalid msdu len in %s", __func__);
+		qdf_print("Invalid msdu len");
 		qdf_assert(0);
 		return A_ERROR;
 	}
@@ -955,7 +955,7 @@ A_STATUS process_rate_update(void *pdev, void *data)
 	uint32_t len;
 
 	if (!pdev || !data || !pl_dev) {
-		qdf_print("%s: Invalid handle", __func__);
+		qdf_print("Invalid handle");
 		return A_ERROR;
 	}
 
@@ -971,7 +971,7 @@ A_STATUS process_rate_update(void *pdev, void *data)
 		       (ATH_PKTLOG_HDR_SIZE_OFFSET + 1)) ||
 		len < (sizeof(uint32_t) *
 		       (ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET + 1))) {
-		qdf_print("Invalid msdu len in %s", __func__);
+		qdf_print("Invalid msdu len");
 		qdf_assert(0);
 		return A_ERROR;
 	}
@@ -1036,15 +1036,15 @@ A_STATUS process_sw_event(void *pdev, void *data)
 	uint32_t *pl_tgt_hdr;
 
 	if (!pdev) {
-		qdf_print("Invalid pdev in %s", __func__);
+		qdf_print("Invalid pdev");
 		return A_ERROR;
 	}
 	if (!data) {
-		qdf_print("Invalid data in %s", __func__);
+		qdf_print("Invalid data");
 		return A_ERROR;
 	}
 	if (!pl_dev) {
-		qdf_print("Invalid pl_dev in %s", __func__);
+		qdf_print("Invalid pl_dev");
 		return A_ERROR;
 	}
 
@@ -1062,7 +1062,7 @@ A_STATUS process_sw_event(void *pdev, void *data)
 		       (ATH_PKTLOG_HDR_SIZE_OFFSET + 1)) ||
 		len < (sizeof(uint32_t) *
 		       (ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET + 1))) {
-		qdf_print("Invalid msdu len in %s", __func__);
+		qdf_print("Invalid msdu len");
 		qdf_assert(0);
 		return A_ERROR;
 	}
@@ -1125,15 +1125,15 @@ A_STATUS process_sw_event(void *pdev, void *data)
 	uint32_t *pl_tgt_hdr;
 
 	if (!pdev) {
-		qdf_print("Invalid pdev in %s", __func__);
+		qdf_print("Invalid pdev");
 		return A_ERROR;
 	}
 	if (!data) {
-		qdf_print("Invalid data in %s", __func__);
+		qdf_print("Invalid data");
 		return A_ERROR;
 	}
 	if (!pl_dev) {
-		qdf_print("Invalid pl_dev in %s", __func__);
+		qdf_print("Invalid pl_dev");
 		return A_ERROR;
 	}
 
@@ -1149,7 +1149,7 @@ A_STATUS process_sw_event(void *pdev, void *data)
 		       (ATH_PKTLOG_HDR_SIZE_OFFSET + 1)) ||
 		len < (sizeof(uint32_t) *
 		       (ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET + 1))) {
-		qdf_print("Invalid msdu len in %s", __func__);
+		qdf_print("Invalid msdu len");
 		qdf_assert(0);
 		return A_ERROR;
 	}