[PATCH 3/3] Staging: crystalhd: Replace the BCMLOG_ERR macro with pr_err

[PATCH 3/3] Staging: crystalhd: Replace the BCMLOG_ERR macro with pr_err

[Jorgyano Vieira]

Replace the usage of BCMLOG_ERR with pr_err and remove the macro definition.

Signed-ff-by: Jorgyano Vieira <jorgyano@gmail.com>
---
 drivers/staging/crystalhd/crystalhd_cmds.c |   68 ++++++++--------
 drivers/staging/crystalhd/crystalhd_hw.c   |  116 ++++++++++++++--------------
 drivers/staging/crystalhd/crystalhd_lnx.c  |   92 +++++++++++-----------
 drivers/staging/crystalhd/crystalhd_misc.c |   66 ++++++++--------
 drivers/staging/crystalhd/crystalhd_misc.h |    8 --
 5 files changed, 171 insertions(+), 179 deletions(-)

diff --git a/drivers/staging/crystalhd/crystalhd_cmds.c b/drivers/staging/crystalhd/crystalhd_cmds.c
index 3735ed3..8213806 100644
--- a/drivers/staging/crystalhd/crystalhd_cmds.c
+++ b/drivers/staging/crystalhd/crystalhd_cmds.c
@@ -75,12 +75,12 @@ static enum BC_STATUS bc_cproc_notify_mode(struct crystalhd_cmd *ctx,
 	int rc = 0, i = 0;
 
 	if (!ctx || !idata) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
 	if (ctx->user[idata->u_id].mode != DTS_MODE_INV) {
-		BCMLOG_ERR("Close the handle first..\n");
+		pr_err("Close the handle first..\n");
 		return BC_STS_ERR_USAGE;
 	}
 	if (idata->udata.u.NotifyMode.Mode == DTS_MONITOR_MODE) {
@@ -88,14 +88,14 @@ static enum BC_STATUS bc_cproc_notify_mode(struct crystalhd_cmd *ctx,
 		return BC_STS_SUCCESS;
 	}
 	if (ctx->state != BC_LINK_INVALID) {
-		BCMLOG_ERR("Link invalid state %d\n", ctx->state);
+		pr_err("Link invalid state %d\n", ctx->state);
 		return BC_STS_ERR_USAGE;
 	}
 	/* Check for duplicate playback sessions..*/
 	for (i = 0; i < BC_LINK_MAX_OPENS; i++) {
 		if (ctx->user[i].mode == DTS_DIAG_MODE ||
 		    ctx->user[i].mode == DTS_PLAYBACK_MODE) {
-			BCMLOG_ERR("multiple playback sessions are not "
+			pr_err("multiple playback sessions are not "
 				   "supported..\n");
 			return BC_STS_ERR_USAGE;
 		}
@@ -116,7 +116,7 @@ static enum BC_STATUS bc_cproc_get_version(struct crystalhd_cmd *ctx,
 {
 
 	if (!ctx || !idata) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 	idata->udata.u.VerInfo.DriverMajor = crystalhd_kmod_major;
@@ -130,7 +130,7 @@ static enum BC_STATUS bc_cproc_get_hwtype(struct crystalhd_cmd *ctx,
 					struct crystalhd_ioctl_data *idata)
 {
 	if (!ctx || !idata) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -198,7 +198,7 @@ static enum BC_STATUS bc_cproc_mem_rd(struct crystalhd_cmd *ctx,
 		return BC_STS_INV_ARG;
 
 	if (idata->udata.u.devMem.NumDwords > (idata->add_cdata_sz / 4)) {
-		BCMLOG_ERR("insufficient buffer\n");
+		pr_err("insufficient buffer\n");
 		return BC_STS_INV_ARG;
 	}
 	sts = crystalhd_mem_rd(ctx->adp, idata->udata.u.devMem.StartOff,
@@ -217,7 +217,7 @@ static enum BC_STATUS bc_cproc_mem_wr(struct crystalhd_cmd *ctx,
 		return BC_STS_INV_ARG;
 
 	if (idata->udata.u.devMem.NumDwords > (idata->add_cdata_sz / 4)) {
-		BCMLOG_ERR("insufficient buffer\n");
+		pr_err("insufficient buffer\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -250,7 +250,7 @@ static enum BC_STATUS bc_cproc_cfg_rd(struct crystalhd_cmd *ctx,
 	for (ix = 0; ix < cnt; ix++) {
 		sts = crystalhd_pci_cfg_rd(ctx->adp, off, len, &temp[ix]);
 		if (sts != BC_STS_SUCCESS) {
-			BCMLOG_ERR("config read : %d\n", sts);
+			pr_err("config read : %d\n", sts);
 			return sts;
 		}
 		off += len;
@@ -282,7 +282,7 @@ static enum BC_STATUS bc_cproc_cfg_wr(struct crystalhd_cmd *ctx,
 	for (ix = 0; ix < cnt; ix++) {
 		sts = crystalhd_pci_cfg_wr(ctx->adp, off, len, temp[ix]);
 		if (sts != BC_STS_SUCCESS) {
-			BCMLOG_ERR("config write : %d\n", sts);
+			pr_err("config write : %d\n", sts);
 			return sts;
 		}
 		off += len;
@@ -297,12 +297,12 @@ static enum BC_STATUS bc_cproc_download_fw(struct crystalhd_cmd *ctx,
 	enum BC_STATUS sts = BC_STS_SUCCESS;
 
 	if (!ctx || !idata || !idata->add_cdata || !idata->add_cdata_sz) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
 	if (ctx->state != BC_LINK_INVALID) {
-		BCMLOG_ERR("Link invalid state %d\n", ctx->state);
+		pr_err("Link invalid state %d\n", ctx->state);
 		return BC_STS_ERR_USAGE;
 	}
 
@@ -310,7 +310,7 @@ static enum BC_STATUS bc_cproc_download_fw(struct crystalhd_cmd *ctx,
 				  idata->add_cdata_sz);
 
 	if (sts != BC_STS_SUCCESS) {
-		BCMLOG_ERR("Firmware Download Failure!! - %d\n", sts);
+		pr_err("Firmware Download Failure!! - %d\n", sts);
 	} else
 		ctx->state |= BC_LINK_INIT;
 
@@ -337,7 +337,7 @@ static enum BC_STATUS bc_cproc_do_fw_cmd(struct crystalhd_cmd *ctx,
 	uint32_t *cmd;
 
 	if (!(ctx->state & BC_LINK_INIT)) {
-		BCMLOG_ERR("Link invalid state %d\n", ctx->state);
+		pr_err("Link invalid state %d\n", ctx->state);
 		return BC_STS_ERR_USAGE;
 	}
 
@@ -377,7 +377,7 @@ static void bc_proc_in_completion(struct crystalhd_dio_req *dio_hnd,
 				  wait_queue_head_t *event, enum BC_STATUS sts)
 {
 	if (!dio_hnd || !event) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return;
 	}
 	if (sts == BC_STS_IO_USER_ABORT)
@@ -418,7 +418,7 @@ static enum BC_STATUS bc_cproc_hw_txdma(struct crystalhd_cmd *ctx,
 	int rc = 0;
 
 	if (!ctx || !idata || !dio) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -477,14 +477,14 @@ static enum BC_STATUS bc_cproc_check_inbuffs(bool pin, void *ubuff, uint32_t ub_
 					uint32_t uv_off, bool en_422)
 {
 	if (!ubuff || !ub_sz) {
-		BCMLOG_ERR("%s->Invalid Arg %p %x\n",
+		pr_err("%s->Invalid Arg %p %x\n",
 			((pin) ? "TX" : "RX"), ubuff, ub_sz);
 		return BC_STS_INV_ARG;
 	}
 
 	/* Check for alignment */
 	if (((uintptr_t)ubuff) & 0x03) {
-		BCMLOG_ERR("%s-->Un-aligned address not implemented yet.. %p\n",
+		pr_err("%s-->Un-aligned address not implemented yet.. %p\n",
 				((pin) ? "TX" : "RX"), ubuff);
 		return BC_STS_NOT_IMPL;
 	}
@@ -492,12 +492,12 @@ static enum BC_STATUS bc_cproc_check_inbuffs(bool pin, void *ubuff, uint32_t ub_
 		return BC_STS_SUCCESS;
 
 	if (!en_422 && !uv_off) {
-		BCMLOG_ERR("Need UV offset for 420 mode.\n");
+		pr_err("Need UV offset for 420 mode.\n");
 		return BC_STS_INV_ARG;
 	}
 
 	if (en_422 && uv_off) {
-		BCMLOG_ERR("UV offset in 422 mode ??\n");
+		pr_err("UV offset in 422 mode ??\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -513,7 +513,7 @@ static enum BC_STATUS bc_cproc_proc_input(struct crystalhd_cmd *ctx,
 	enum BC_STATUS sts = BC_STS_SUCCESS;
 
 	if (!ctx || !idata) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -526,7 +526,7 @@ static enum BC_STATUS bc_cproc_proc_input(struct crystalhd_cmd *ctx,
 
 	sts = crystalhd_map_dio(ctx->adp, ubuff, ub_sz, 0, 0, 1, &dio_hnd);
 	if (sts != BC_STS_SUCCESS) {
-		BCMLOG_ERR("dio map - %d\n", sts);
+		pr_err("dio map - %d\n", sts);
 		return sts;
 	}
 
@@ -550,7 +550,7 @@ static enum BC_STATUS bc_cproc_add_cap_buff(struct crystalhd_cmd *ctx,
 	enum BC_STATUS sts = BC_STS_SUCCESS;
 
 	if (!ctx || !idata) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -566,7 +566,7 @@ static enum BC_STATUS bc_cproc_add_cap_buff(struct crystalhd_cmd *ctx,
 	sts = crystalhd_map_dio(ctx->adp, ubuff, ub_sz, uv_off,
 			      en_422, 0, &dio_hnd);
 	if (sts != BC_STS_SUCCESS) {
-		BCMLOG_ERR("dio map - %d\n", sts);
+		pr_err("dio map - %d\n", sts);
 		return sts;
 	}
 
@@ -606,7 +606,7 @@ static enum BC_STATUS bc_cproc_fetch_frame(struct crystalhd_cmd *ctx,
 	struct BC_DEC_OUT_BUFF *frame;
 
 	if (!ctx || !idata) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -658,7 +658,7 @@ static enum BC_STATUS bc_cproc_flush_cap_buffs(struct crystalhd_cmd *ctx,
 	uint32_t count;
 
 	if (!ctx || !idata) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -691,7 +691,7 @@ static enum BC_STATUS bc_cproc_get_stats(struct crystalhd_cmd *ctx,
 	struct crystalhd_hw_stats	hw_stats;
 
 	if (!ctx || !idata) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -732,7 +732,7 @@ static enum BC_STATUS bc_cproc_chg_clk(struct crystalhd_cmd *ctx,
 	enum BC_STATUS sts = BC_STS_SUCCESS;
 
 	if (!ctx || !idata) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -805,7 +805,7 @@ enum BC_STATUS crystalhd_suspend(struct crystalhd_cmd *ctx,
 	enum BC_STATUS sts = BC_STS_SUCCESS;
 
 	if (!ctx || !idata) {
-		BCMLOG_ERR("Invalid Parameters\n");
+		pr_err("Invalid Parameters\n");
 		return BC_STS_ERROR;
 	}
 
@@ -885,7 +885,7 @@ enum BC_STATUS crystalhd_user_open(struct crystalhd_cmd *ctx,
 	struct crystalhd_user *uc;
 
 	if (!ctx || !user_ctx) {
-		BCMLOG_ERR("Invalid arg..\n");
+		pr_err("Invalid arg..\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -958,7 +958,7 @@ enum BC_STATUS __devinit crystalhd_setup_cmd_context(struct crystalhd_cmd *ctx,
 	int i = 0;
 
 	if (!ctx || !adp) {
-		BCMLOG_ERR("Invalid arg!!\n");
+		pr_err("Invalid arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -1016,12 +1016,12 @@ crystalhd_cmd_proc crystalhd_get_cmd_proc(struct crystalhd_cmd *ctx, uint32_t cm
 	unsigned int i, tbl_sz;
 
 	if (!ctx) {
-		BCMLOG_ERR("Invalid arg.. Cmd[%d]\n", cmd);
+		pr_err("Invalid arg.. Cmd[%d]\n", cmd);
 		return NULL;
 	}
 
 	if ((cmd != BCM_IOC_GET_DRV_STAT) && (ctx->state & BC_LINK_SUSPEND)) {
-		BCMLOG_ERR("Invalid State [suspend Set].. Cmd[%d]\n", cmd);
+		pr_err("Invalid State [suspend Set].. Cmd[%d]\n", cmd);
 		return NULL;
 	}
 
@@ -1054,7 +1054,7 @@ crystalhd_cmd_proc crystalhd_get_cmd_proc(struct crystalhd_cmd *ctx, uint32_t cm
 bool crystalhd_cmd_interrupt(struct crystalhd_cmd *ctx)
 {
 	if (!ctx) {
-		BCMLOG_ERR("Invalid arg..\n");
+		pr_err("Invalid arg..\n");
 		return 0;
 	}
 
diff --git a/drivers/staging/crystalhd/crystalhd_hw.c b/drivers/staging/crystalhd/crystalhd_hw.c
index 2d02ed2..d9ffd5f 100644
--- a/drivers/staging/crystalhd/crystalhd_hw.c
+++ b/drivers/staging/crystalhd/crystalhd_hw.c
@@ -289,7 +289,7 @@ static bool crystalhd_start_device(struct crystalhd_adp *adp)
 	crystalhd_reg_wr(adp, PCIE_DLL_DATA_LINK_CONTROL, reg_pwrmgmt);
 
 	if (!crystalhd_bring_out_of_rst(adp)) {
-		BCMLOG_ERR("Failed To Bring Link Out Of Reset\n");
+		pr_err("Failed To Bring Link Out Of Reset\n");
 		return false;
 	}
 
@@ -334,7 +334,7 @@ static bool crystalhd_stop_device(struct crystalhd_adp *adp)
 	crystalhd_clear_interrupts(adp);
 
 	if (!crystalhd_put_in_reset(adp))
-		BCMLOG_ERR("Failed to Put Link To Reset State\n");
+		pr_err("Failed to Put Link To Reset State\n");
 
 	reg = crystalhd_reg_rd(adp, PCIE_DLL_DATA_LINK_CONTROL);
 	reg |= ASPM_L1_ENABLE;
@@ -409,14 +409,14 @@ static void crystalhd_rx_pkt_rel_call_back(void *context, void *data)
 	struct crystalhd_rx_dma_pkt *pkt = (struct crystalhd_rx_dma_pkt *)data;
 
 	if (!pkt || !hw) {
-		BCMLOG_ERR("Invalid arg - %p %p\n", hw, pkt);
+		pr_err("Invalid arg - %p %p\n", hw, pkt);
 		return;
 	}
 
 	if (pkt->dio_req)
 		crystalhd_unmap_dio(hw->adp, pkt->dio_req);
 	else
-		BCMLOG_ERR("Missing dio_req: 0x%x\n", pkt->pkt_tag);
+		pr_err("Missing dio_req: 0x%x\n", pkt->pkt_tag);
 
 	crystalhd_hw_free_rx_pkt(hw, pkt);
 }
@@ -458,7 +458,7 @@ static enum BC_STATUS crystalhd_hw_create_ioqs(struct crystalhd_hw   *hw)
 	enum BC_STATUS   sts = BC_STS_SUCCESS;
 
 	if (!hw) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -529,7 +529,7 @@ static enum BC_STATUS crystalhd_hw_tx_req_complete(struct crystalhd_hw *hw,
 	struct tx_dma_pkt *tx_req;
 
 	if (!hw || !list_id) {
-		BCMLOG_ERR("Invalid Arg..\n");
+		pr_err("Invalid Arg..\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -538,7 +538,7 @@ static enum BC_STATUS crystalhd_hw_tx_req_complete(struct crystalhd_hw *hw,
 	tx_req = (struct tx_dma_pkt *)crystalhd_dioq_find_and_fetch(hw->tx_actq, list_id);
 	if (!tx_req) {
 		if (cs != BC_STS_IO_USER_ABORT)
-			BCMLOG_ERR("Find and Fetch Did not find req\n");
+			pr_err("Find and Fetch Did not find req\n");
 		return BC_STS_NO_DATA;
 	}
 
@@ -570,7 +570,7 @@ static bool crystalhd_tx_list0_handler(struct crystalhd_hw *hw, uint32_t err_sts
 	if (!(err_sts & err_mask))
 		return false;
 
-	BCMLOG_ERR("Error on Tx-L0 %x\n", err_sts);
+	pr_err("Error on Tx-L0 %x\n", err_sts);
 
 	tmp = err_mask;
 
@@ -602,7 +602,7 @@ static bool crystalhd_tx_list1_handler(struct crystalhd_hw *hw, uint32_t err_sts
 	if (!(err_sts & err_mask))
 		return false;
 
-	BCMLOG_ERR("Error on Tx-L1 %x\n", err_sts);
+	pr_err("Error on Tx-L1 %x\n", err_sts);
 
 	tmp = err_mask;
 
@@ -694,7 +694,7 @@ static enum BC_STATUS crystalhd_hw_fill_desc(struct crystalhd_dio_req *ioreq,
 
 	if (!ioreq || !desc || !desc_paddr_base || !xfr_sz ||
 	    (!sg_cnt && !ioreq->uinfo.dir_tx)) {
-		BCMLOG_ERR("Invalid Args\n");
+		pr_err("Invalid Args\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -706,7 +706,7 @@ static enum BC_STATUS crystalhd_hw_fill_desc(struct crystalhd_dio_req *ioreq,
 		/* Get SGLE length */
 		len = crystalhd_get_sgle_len(ioreq, sg_ix);
 		if (len % 4) {
-			BCMLOG_ERR(" len in sg %d %d %d\n", len, sg_ix, sg_cnt);
+			pr_err(" len in sg %d %d %d\n", len, sg_ix, sg_cnt);
 			return BC_STS_NOT_IMPL;
 		}
 		/* Setup DMA desc with Phy addr & Length at current index. */
@@ -730,7 +730,7 @@ static enum BC_STATUS crystalhd_hw_fill_desc(struct crystalhd_dio_req *ioreq,
 
 		/* Debug.. */
 		if ((!len) || (len > crystalhd_get_sgle_len(ioreq, sg_ix))) {
-			BCMLOG_ERR("inv-len(%x) Ix(%d) count:%x xfr_sz:%x sg_cnt:%d\n",
+			pr_err("inv-len(%x) Ix(%d) count:%x xfr_sz:%x sg_cnt:%d\n",
 				   len, ix, count, xfr_sz, sg_cnt);
 			return BC_STS_ERROR;
 		}
@@ -766,7 +766,7 @@ static enum BC_STATUS crystalhd_hw_fill_desc(struct crystalhd_dio_req *ioreq,
 	crystalhd_hw_dump_desc(desc, last_desc_ix, 1);
 
 	if (count != xfr_sz) {
-		BCMLOG_ERR("interal error sz curr:%x exp:%x\n", count, xfr_sz);
+		pr_err("interal error sz curr:%x exp:%x\n", count, xfr_sz);
 		return BC_STS_ERROR;
 	}
 
@@ -785,18 +785,18 @@ static enum BC_STATUS crystalhd_xlat_sgl_to_dma_desc(struct crystalhd_dio_req *i
 
 	/* Check params.. */
 	if (!ioreq || !pdesc_mem || !uv_desc_index) {
-		BCMLOG_ERR("Invalid Args\n");
+		pr_err("Invalid Args\n");
 		return BC_STS_INV_ARG;
 	}
 
 	if (!pdesc_mem->sz || !pdesc_mem->pdma_desc_start ||
 	    !ioreq->sg || (!ioreq->sg_cnt && !ioreq->uinfo.dir_tx)) {
-		BCMLOG_ERR("Invalid Args\n");
+		pr_err("Invalid Args\n");
 		return BC_STS_INV_ARG;
 	}
 
 	if ((ioreq->uinfo.dir_tx) && (ioreq->uinfo.uv_offset)) {
-		BCMLOG_ERR("UV offset for TX??\n");
+		pr_err("UV offset for TX??\n");
 		return BC_STS_INV_ARG;
 
 	}
@@ -901,7 +901,7 @@ static enum BC_STATUS crystalhd_stop_tx_dma_engine(struct crystalhd_hw *hw)
 	}
 
 	if (!cnt) {
-		BCMLOG_ERR("Failed to stop TX DMA.. l1 %d, l2 %d\n", l1, l2);
+		pr_err("Failed to stop TX DMA.. l1 %d, l2 %d\n", l1, l2);
 		crystalhd_enable_interrupts(hw->adp);
 		return BC_STS_ERROR;
 	}
@@ -942,7 +942,7 @@ static uint32_t crystalhd_get_pib_avail_cnt(struct crystalhd_hw *hw)
 			  (r_offset + MIN_PIB_Q_DEPTH);
 
 	if (pib_cnt > MAX_PIB_Q_DEPTH) {
-		BCMLOG_ERR("Invalid PIB Count (%u)\n", pib_cnt);
+		pr_err("Invalid PIB Count (%u)\n", pib_cnt);
 		return 0;
 	}
 
@@ -1023,7 +1023,7 @@ static bool crystalhd_rel_addr_to_pib_Q(struct crystalhd_hw *hw, uint32_t addr_t
 static void cpy_pib_to_app(struct c011_pib *src_pib, struct BC_PIC_INFO_BLOCK *dst_pib)
 {
 	if (!src_pib || !dst_pib) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return;
 	}
 
@@ -1175,12 +1175,12 @@ static enum BC_STATUS crystalhd_hw_prog_rxdma(struct crystalhd_hw *hw, struct cr
 	unsigned long flags;
 
 	if (!hw || !rx_pkt) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
 	if (hw->rx_list_post_index >= DMA_ENGINE_CNT) {
-		BCMLOG_ERR("List Out Of bounds %x\n", hw->rx_list_post_index);
+		pr_err("List Out Of bounds %x\n", hw->rx_list_post_index);
 		return BC_STS_INV_ARG;
 	}
 
@@ -1294,14 +1294,14 @@ static enum BC_STATUS crystalhd_rx_pkt_done(struct crystalhd_hw *hw, uint32_t li
 	enum BC_STATUS sts = BC_STS_SUCCESS;
 
 	if (!hw || list_index >= DMA_ENGINE_CNT) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
 	rx_pkt = crystalhd_dioq_find_and_fetch(hw->rx_actq,
 					     hw->rx_pkt_tag_seed + list_index);
 	if (!rx_pkt) {
-		BCMLOG_ERR("Act-Q:PostIx:%x L0Sts:%x L1Sts:%x current L:%x tag:%x comp:%x\n",
+		pr_err("Act-Q:PostIx:%x L0Sts:%x L1Sts:%x current L:%x tag:%x comp:%x\n",
 			   hw->rx_list_post_index, hw->rx_list_sts[0],
 			   hw->rx_list_sts[1], list_index,
 			   hw->rx_pkt_tag_seed + list_index, comp_sts);
@@ -1471,7 +1471,7 @@ static void crystalhd_rx_isr(struct crystalhd_hw *hw, uint32_t intr_sts)
 	bool ret = 0;
 
 	if (!hw) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return;
 	}
 
@@ -1550,7 +1550,7 @@ static enum BC_STATUS crystalhd_fw_cmd_post_proc(struct crystalhd_hw *hw,
 		break;
 	case eCMD_C011_INIT:
 		if (!(crystalhd_load_firmware_config(hw->adp))) {
-			BCMLOG_ERR("Invalid Params.\n");
+			pr_err("Invalid Params.\n");
 			sts = BC_STS_FW_AUTH_FAILED;
 		}
 		break;
@@ -1629,13 +1629,13 @@ enum BC_STATUS crystalhd_download_fw(struct crystalhd_adp *adp, void *buffer, ui
 
 
 	if (!adp || !buffer || !sz) {
-		BCMLOG_ERR("Invalid Params.\n");
+		pr_err("Invalid Params.\n");
 		return BC_STS_INV_ARG;
 	}
 
 	reg_data = crystalhd_reg_rd(adp, OTP_CMD);
 	if (!(reg_data & 0x02)) {
-		BCMLOG_ERR("Invalid hw config.. otp not programmed\n");
+		pr_err("Invalid hw config.. otp not programmed\n");
 		return BC_STS_ERROR;
 	}
 
@@ -1652,7 +1652,7 @@ enum BC_STATUS crystalhd_download_fw(struct crystalhd_adp *adp, void *buffer, ui
 		reg_data = crystalhd_reg_rd(adp, DCI_STATUS);
 		reg_data &= BC_BIT(4);
 		if (--cnt == 0) {
-			BCMLOG_ERR("Firmware Download RDY Timeout.\n");
+			pr_err("Firmware Download RDY Timeout.\n");
 			return BC_STS_TIMEOUT;
 		}
 	}
@@ -1704,7 +1704,7 @@ enum BC_STATUS crystalhd_download_fw(struct crystalhd_adp *adp, void *buffer, ui
 		crystalhd_reg_wr(adp, DCI_CMD, reg_data);
 
 	} else {
-		BCMLOG_ERR("F/w Signature mismatch\n");
+		pr_err("F/w Signature mismatch\n");
 		return BC_STS_FW_AUTH_FAILED;
 	}
 
@@ -1724,7 +1724,7 @@ enum BC_STATUS crystalhd_do_fw_cmd(struct crystalhd_hw *hw,
 	crystalhd_create_event(&fw_cmd_event);
 
 	if (!hw || !fw_cmd) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -1732,7 +1732,7 @@ enum BC_STATUS crystalhd_do_fw_cmd(struct crystalhd_hw *hw,
 	res_buff = fw_cmd->rsp;
 
 	if (!cmd_buff || !res_buff) {
-		BCMLOG_ERR("Invalid Parameters for F/W Command\n");
+		pr_err("Invalid Parameters for F/W Command\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -1756,18 +1756,18 @@ enum BC_STATUS crystalhd_do_fw_cmd(struct crystalhd_hw *hw,
 	if (!rc) {
 		sts = BC_STS_SUCCESS;
 	} else if (rc == -EBUSY) {
-		BCMLOG_ERR("Firmware command T/O\n");
+		pr_err("Firmware command T/O\n");
 		sts = BC_STS_TIMEOUT;
 	} else if (rc == -EINTR) {
 		BCMLOG(BCMLOG_DBG, "FwCmd Wait Signal int.\n");
 		sts = BC_STS_IO_USER_ABORT;
 	} else {
-		BCMLOG_ERR("FwCmd IO Error.\n");
+		pr_err("FwCmd IO Error.\n");
 		sts = BC_STS_IO_ERROR;
 	}
 
 	if (sts != BC_STS_SUCCESS) {
-		BCMLOG_ERR("FwCmd Failed.\n");
+		pr_err("FwCmd Failed.\n");
 		hw->pwr_lock--;
 		return sts;
 	}
@@ -1781,13 +1781,13 @@ enum BC_STATUS crystalhd_do_fw_cmd(struct crystalhd_hw *hw,
 	hw->pwr_lock--;
 
 	if (res_buff[2] != C011_RET_SUCCESS) {
-		BCMLOG_ERR("res_buff[2] != C011_RET_SUCCESS\n");
+		pr_err("res_buff[2] != C011_RET_SUCCESS\n");
 		return BC_STS_FW_CMD_ERR;
 	}
 
 	sts = crystalhd_fw_cmd_post_proc(hw, fw_cmd);
 	if (sts != BC_STS_SUCCESS)
-		BCMLOG_ERR("crystalhd_fw_cmd_post_proc Failed.\n");
+		pr_err("crystalhd_fw_cmd_post_proc Failed.\n");
 
 	return sts;
 }
@@ -1854,7 +1854,7 @@ bool crystalhd_hw_interrupt(struct crystalhd_adp *adp, struct crystalhd_hw *hw)
 enum BC_STATUS crystalhd_hw_open(struct crystalhd_hw *hw, struct crystalhd_adp *adp)
 {
 	if (!hw || !adp) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -1886,7 +1886,7 @@ enum BC_STATUS crystalhd_hw_open(struct crystalhd_hw *hw, struct crystalhd_adp *
 enum BC_STATUS crystalhd_hw_close(struct crystalhd_hw *hw)
 {
 	if (!hw) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -1910,13 +1910,13 @@ enum BC_STATUS crystalhd_hw_setup_dma_rings(struct crystalhd_hw *hw)
 	struct crystalhd_rx_dma_pkt *rpkt;
 
 	if (!hw || !hw->adp) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
 	sts = crystalhd_hw_create_ioqs(hw);
 	if (sts != BC_STS_SUCCESS) {
-		BCMLOG_ERR("Failed to create IOQs..\n");
+		pr_err("Failed to create IOQs..\n");
 		return sts;
 	}
 
@@ -1927,7 +1927,7 @@ enum BC_STATUS crystalhd_hw_setup_dma_rings(struct crystalhd_hw *hw)
 		if (mem) {
 			memset(mem, 0, mem_len);
 		} else {
-			BCMLOG_ERR("Insufficient Memory For TX\n");
+			pr_err("Insufficient Memory For TX\n");
 			crystalhd_hw_free_dma_rings(hw);
 			return BC_STS_INSUFF_RES;
 		}
@@ -1950,7 +1950,7 @@ enum BC_STATUS crystalhd_hw_setup_dma_rings(struct crystalhd_hw *hw)
 	for (i = 0; i < BC_RX_LIST_CNT; i++) {
 		rpkt = kzalloc(sizeof(*rpkt), GFP_KERNEL);
 		if (!rpkt) {
-			BCMLOG_ERR("Insufficient Memory For RX\n");
+			pr_err("Insufficient Memory For RX\n");
 			crystalhd_hw_free_dma_rings(hw);
 			return BC_STS_INSUFF_RES;
 		}
@@ -1959,7 +1959,7 @@ enum BC_STATUS crystalhd_hw_setup_dma_rings(struct crystalhd_hw *hw)
 		if (mem) {
 			memset(mem, 0, mem_len);
 		} else {
-			BCMLOG_ERR("Insufficient Memory For RX\n");
+			pr_err("Insufficient Memory For RX\n");
 			crystalhd_hw_free_dma_rings(hw);
 			kfree(rpkt);
 			return BC_STS_INSUFF_RES;
@@ -1980,7 +1980,7 @@ enum BC_STATUS crystalhd_hw_free_dma_rings(struct crystalhd_hw *hw)
 	struct crystalhd_rx_dma_pkt *rpkt = NULL;
 
 	if (!hw || !hw->adp) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -2027,7 +2027,7 @@ enum BC_STATUS crystalhd_hw_post_tx(struct crystalhd_hw *hw, struct crystalhd_di
 	bool rc;
 
 	if (!hw || !ioreq || !call_back || !cb_event || !list_id) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -2048,7 +2048,7 @@ enum BC_STATUS crystalhd_hw_post_tx(struct crystalhd_hw *hw, struct crystalhd_di
 	/* Get a list from TxFreeQ */
 	tx_dma_packet = (struct tx_dma_pkt *)crystalhd_dioq_fetch(hw->tx_freeq);
 	if (!tx_dma_packet) {
-		BCMLOG_ERR("No empty elements..\n");
+		pr_err("No empty elements..\n");
 		return BC_STS_ERR_USAGE;
 	}
 
@@ -2059,7 +2059,7 @@ enum BC_STATUS crystalhd_hw_post_tx(struct crystalhd_hw *hw, struct crystalhd_di
 		add_sts = crystalhd_dioq_add(hw->tx_freeq, tx_dma_packet,
 					   false, 0);
 		if (add_sts != BC_STS_SUCCESS)
-			BCMLOG_ERR("double fault..\n");
+			pr_err("double fault..\n");
 
 		return sts;
 	}
@@ -2122,7 +2122,7 @@ enum BC_STATUS crystalhd_hw_post_tx(struct crystalhd_hw *hw, struct crystalhd_di
 enum BC_STATUS crystalhd_hw_cancel_tx(struct crystalhd_hw *hw, uint32_t list_id)
 {
 	if (!hw || !list_id) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -2140,13 +2140,13 @@ enum BC_STATUS crystalhd_hw_add_cap_buffer(struct crystalhd_hw *hw,
 	enum BC_STATUS sts;
 
 	if (!hw || !ioreq) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
 	rpkt = crystalhd_hw_alloc_rx_pkt(hw);
 	if (!rpkt) {
-		BCMLOG_ERR("Insufficient resources\n");
+		pr_err("Insufficient resources\n");
 		return BC_STS_INSUFF_RES;
 	}
 
@@ -2182,7 +2182,7 @@ enum BC_STATUS crystalhd_hw_get_cap_buffer(struct crystalhd_hw *hw,
 
 
 	if (!hw || !ioreq || !pib) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -2215,7 +2215,7 @@ enum BC_STATUS crystalhd_hw_start_capture(struct crystalhd_hw *hw)
 	uint32_t i;
 
 	if (!hw) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -2238,7 +2238,7 @@ enum BC_STATUS crystalhd_hw_stop_capture(struct crystalhd_hw *hw)
 	void *temp = NULL;
 
 	if (!hw) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -2286,18 +2286,18 @@ enum BC_STATUS crystalhd_hw_suspend(struct crystalhd_hw *hw)
 	enum BC_STATUS sts;
 
 	if (!hw) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
 	sts = crystalhd_put_ddr2sleep(hw);
 	if (sts != BC_STS_SUCCESS) {
-		BCMLOG_ERR("Failed to Put DDR To Sleep!!\n");
+		pr_err("Failed to Put DDR To Sleep!!\n");
 		return BC_STS_ERROR;
 	}
 
 	if (!crystalhd_stop_device(hw->adp)) {
-		BCMLOG_ERR("Failed to Stop Device!!\n");
+		pr_err("Failed to Stop Device!!\n");
 		return BC_STS_ERROR;
 	}
 
@@ -2307,7 +2307,7 @@ enum BC_STATUS crystalhd_hw_suspend(struct crystalhd_hw *hw)
 void crystalhd_hw_stats(struct crystalhd_hw *hw, struct crystalhd_hw_stats *stats)
 {
 	if (!hw) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return;
 	}
 
@@ -2328,7 +2328,7 @@ enum BC_STATUS crystalhd_hw_set_core_clock(struct crystalhd_hw *hw)
 	uint32_t vco_mg, refresh_reg;
 
 	if (!hw) {
-		BCMLOG_ERR("Invalid Arguments\n");
+		pr_err("Invalid Arguments\n");
 		return BC_STS_INV_ARG;
 	}
 
diff --git a/drivers/staging/crystalhd/crystalhd_lnx.c b/drivers/staging/crystalhd/crystalhd_lnx.c
index 9dca92c..acbe65c 100644
--- a/drivers/staging/crystalhd/crystalhd_lnx.c
+++ b/drivers/staging/crystalhd/crystalhd_lnx.c
@@ -40,7 +40,7 @@ static int chd_dec_enable_int(struct crystalhd_adp *adp)
 	int rc = 0;
 
 	if (!adp || !adp->pdev) {
-		BCMLOG_ERR("Invalid arg!!\n");
+		pr_err("Invalid arg!!\n");
 		return -EINVAL;
 	}
 
@@ -52,7 +52,7 @@ static int chd_dec_enable_int(struct crystalhd_adp *adp)
 	rc = request_irq(adp->pdev->irq, chd_dec_isr, IRQF_SHARED,
 			 adp->name, (void *)adp);
 	if (rc) {
-		BCMLOG_ERR("Interrupt request failed..\n");
+		pr_err("Interrupt request failed..\n");
 		pci_disable_msi(adp->pdev);
 	}
 
@@ -62,7 +62,7 @@ static int chd_dec_enable_int(struct crystalhd_adp *adp)
 static int chd_dec_disable_int(struct crystalhd_adp *adp)
 {
 	if (!adp || !adp->pdev) {
-		BCMLOG_ERR("Invalid arg!!\n");
+		pr_err("Invalid arg!!\n");
 		return -EINVAL;
 	}
 
@@ -113,7 +113,7 @@ static inline int crystalhd_user_data(unsigned long ud, void *dr, int size, int
 	int rc;
 
 	if (!ud || !dr) {
-		BCMLOG_ERR("Invalid arg\n");
+		pr_err("Invalid arg\n");
 		return -EINVAL;
 	}
 
@@ -123,7 +123,7 @@ static inline int crystalhd_user_data(unsigned long ud, void *dr, int size, int
 		rc = copy_from_user(dr, (void *)ud, size);
 
 	if (rc) {
-		BCMLOG_ERR("Invalid args for command\n");
+		pr_err("Invalid args for command\n");
 		rc = -EFAULT;
 	}
 
@@ -137,13 +137,13 @@ static int chd_dec_fetch_cdata(struct crystalhd_adp *adp, struct crystalhd_ioctl
 	int rc = 0;
 
 	if (!adp || !io || !ua || !m_sz) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return -EINVAL;
 	}
 
 	io->add_cdata = vmalloc(m_sz);
 	if (!io->add_cdata) {
-		BCMLOG_ERR("kalloc fail for sz:%x\n", m_sz);
+		pr_err("kalloc fail for sz:%x\n", m_sz);
 		return -ENOMEM;
 	}
 
@@ -151,7 +151,7 @@ static int chd_dec_fetch_cdata(struct crystalhd_adp *adp, struct crystalhd_ioctl
 	ua_off = ua + sizeof(io->udata);
 	rc = crystalhd_user_data(ua_off, io->add_cdata, io->add_cdata_sz, 0);
 	if (rc) {
-		BCMLOG_ERR("failed to pull add_cdata sz:%x ua_off:%x\n",
+		pr_err("failed to pull add_cdata sz:%x ua_off:%x\n",
 			   io->add_cdata_sz, (unsigned int)ua_off);
 		kfree(io->add_cdata);
 		io->add_cdata = NULL;
@@ -168,7 +168,7 @@ static int chd_dec_release_cdata(struct crystalhd_adp *adp,
 	int rc;
 
 	if (!adp || !io || !ua) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return -EINVAL;
 	}
 
@@ -177,7 +177,7 @@ static int chd_dec_release_cdata(struct crystalhd_adp *adp,
 		rc = crystalhd_user_data(ua_off, io->add_cdata,
 					io->add_cdata_sz, 1);
 		if (rc) {
-			BCMLOG_ERR("failed to push add_cdata sz:%x ua_off:%x\n",
+			pr_err("failed to push add_cdata sz:%x ua_off:%x\n",
 				   io->add_cdata_sz, (unsigned int)ua_off);
 			return -ENODATA;
 		}
@@ -199,13 +199,13 @@ static int chd_dec_proc_user_data(struct crystalhd_adp *adp,
 	uint32_t m_sz = 0;
 
 	if (!adp || !io || !ua) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return -EINVAL;
 	}
 
 	rc = crystalhd_user_data(ua, &io->udata, sizeof(io->udata), set);
 	if (rc) {
-		BCMLOG_ERR("failed to %s iodata\n", (set ? "set" : "get"));
+		pr_err("failed to %s iodata\n", (set ? "set" : "get"));
 		return rc;
 	}
 
@@ -235,7 +235,7 @@ static int chd_dec_api_cmd(struct crystalhd_adp *adp, unsigned long ua,
 
 	temp = chd_dec_alloc_iodata(adp, 0);
 	if (!temp) {
-		BCMLOG_ERR("Failed to get iodata..\n");
+		pr_err("Failed to get iodata..\n");
 		return -EINVAL;
 	}
 
@@ -268,20 +268,20 @@ static long chd_dec_ioctl(struct file *fd, unsigned int cmd, unsigned long ua)
 	int ret;
 
 	if (!adp || !fd) {
-		BCMLOG_ERR("Invalid adp\n");
+		pr_err("Invalid adp\n");
 		return -EINVAL;
 	}
 
 	uc = fd->private_data;
 	if (!uc) {
-		BCMLOG_ERR("Failed to get uc\n");
+		pr_err("Failed to get uc\n");
 		return -ENODATA;
 	}
 
 	mutex_lock(&chd_dec_mutex);
 	cproc = crystalhd_get_cmd_proc(&adp->cmds, cmd, uc);
 	if (!cproc) {
-		BCMLOG_ERR("Unhandled command: %d\n", cmd);
+		pr_err("Unhandled command: %d\n", cmd);
 		mutex_unlock(&chd_dec_mutex);
 		return -EINVAL;
 	}
@@ -299,7 +299,7 @@ static int chd_dec_open(struct inode *in, struct file *fd)
 	struct crystalhd_user *uc = NULL;
 
 	if (!adp) {
-		BCMLOG_ERR("Invalid adp\n");
+		pr_err("Invalid adp\n");
 		return -EINVAL;
 	}
 
@@ -310,7 +310,7 @@ static int chd_dec_open(struct inode *in, struct file *fd)
 
 	sts = crystalhd_user_open(&adp->cmds, &uc);
 	if (sts != BC_STS_SUCCESS) {
-		BCMLOG_ERR("cmd_user_open - %d\n", sts);
+		pr_err("cmd_user_open - %d\n", sts);
 		rc = -EBUSY;
 	}
 
@@ -327,13 +327,13 @@ static int chd_dec_close(struct inode *in, struct file *fd)
 	struct crystalhd_user *uc;
 
 	if (!adp) {
-		BCMLOG_ERR("Invalid adp\n");
+		pr_err("Invalid adp\n");
 		return -EINVAL;
 	}
 
 	uc = fd->private_data;
 	if (!uc) {
-		BCMLOG_ERR("Failed to get uc\n");
+		pr_err("Failed to get uc\n");
 		return -ENODATA;
 	}
 
@@ -364,7 +364,7 @@ static int __devinit chd_dec_init_chdev(struct crystalhd_adp *adp)
 	adp->chd_dec_major = register_chrdev(0, CRYSTALHD_API_NAME,
 					     &chd_dec_fops);
 	if (adp->chd_dec_major < 0) {
-		BCMLOG_ERR("Failed to create config dev\n");
+		pr_err("Failed to create config dev\n");
 		rc = adp->chd_dec_major;
 		goto fail;
 	}
@@ -372,20 +372,20 @@ static int __devinit chd_dec_init_chdev(struct crystalhd_adp *adp)
 	/* register crystalhd class */
 	crystalhd_class = class_create(THIS_MODULE, "crystalhd");
 	if (IS_ERR(crystalhd_class)) {
-		BCMLOG_ERR("failed to create class\n");
+		pr_err("failed to create class\n");
 		goto fail;
 	}
 
 	dev = device_create(crystalhd_class, NULL, MKDEV(adp->chd_dec_major, 0),
 			    NULL, "crystalhd");
 	if (IS_ERR(dev)) {
-		BCMLOG_ERR("failed to create device\n");
+		pr_err("failed to create device\n");
 		goto device_create_fail;
 	}
 
 	rc = crystalhd_create_elem_pool(adp, BC_LINK_ELEM_POOL_SZ);
 	if (rc) {
-		BCMLOG_ERR("failed to create device\n");
+		pr_err("failed to create device\n");
 		goto elem_pool_fail;
 	}
 
@@ -393,7 +393,7 @@ static int __devinit chd_dec_init_chdev(struct crystalhd_adp *adp)
 	for (i = 0; i < CHD_IODATA_POOL_SZ; i++) {
 		temp = kzalloc(sizeof(struct crystalhd_ioctl_data), GFP_KERNEL);
 		if (!temp) {
-			BCMLOG_ERR("ioctl data pool kzalloc failed\n");
+			pr_err("ioctl data pool kzalloc failed\n");
 			rc = -ENOMEM;
 			goto kzalloc_fail;
 		}
@@ -451,13 +451,13 @@ static int __devinit chd_pci_reserve_mem(struct crystalhd_adp *pinfo)
 
 	rc = check_mem_region(bar2, mem_len);
 	if (rc) {
-		BCMLOG_ERR("No valid mem region...\n");
+		pr_err("No valid mem region...\n");
 		return -ENOMEM;
 	}
 
 	pinfo->addr = ioremap_nocache(bar2, mem_len);
 	if (!pinfo->addr) {
-		BCMLOG_ERR("Failed to remap mem region...\n");
+		pr_err("Failed to remap mem region...\n");
 		return -ENOMEM;
 	}
 
@@ -466,13 +466,13 @@ static int __devinit chd_pci_reserve_mem(struct crystalhd_adp *pinfo)
 
 	rc = check_mem_region(bar0, i2o_len);
 	if (rc) {
-		BCMLOG_ERR("No valid mem region...\n");
+		pr_err("No valid mem region...\n");
 		return -ENOMEM;
 	}
 
 	pinfo->i2o_addr = ioremap_nocache(bar0, i2o_len);
 	if (!pinfo->i2o_addr) {
-		BCMLOG_ERR("Failed to remap mem region...\n");
+		pr_err("Failed to remap mem region...\n");
 		return -ENOMEM;
 	}
 
@@ -481,7 +481,7 @@ static int __devinit chd_pci_reserve_mem(struct crystalhd_adp *pinfo)
 
 	rc = pci_request_regions(pinfo->pdev, pinfo->name);
 	if (rc < 0) {
-		BCMLOG_ERR("Region request failed: %d\n", rc);
+		pr_err("Region request failed: %d\n", rc);
 		return rc;
 	}
 
@@ -513,13 +513,13 @@ static void __devexit chd_dec_pci_remove(struct pci_dev *pdev)
 
 	pinfo = pci_get_drvdata(pdev);
 	if (!pinfo) {
-		BCMLOG_ERR("could not get adp\n");
+		pr_err("could not get adp\n");
 		return;
 	}
 
 	sts = crystalhd_delete_cmd_context(&pinfo->cmds);
 	if (sts != BC_STS_SUCCESS)
-		BCMLOG_ERR("cmd delete :%d\n", sts);
+		pr_err("cmd delete :%d\n", sts);
 
 	chd_dec_release_chdev(pinfo);
 
@@ -546,7 +546,7 @@ static int __devinit chd_dec_pci_probe(struct pci_dev *pdev,
 
 	pinfo = kzalloc(sizeof(struct crystalhd_adp), GFP_KERNEL);
 	if (!pinfo) {
-		BCMLOG_ERR("Failed to allocate memory\n");
+		pr_err("Failed to allocate memory\n");
 		return -ENOMEM;
 	}
 
@@ -554,7 +554,7 @@ static int __devinit chd_dec_pci_probe(struct pci_dev *pdev,
 
 	rc = pci_enable_device(pdev);
 	if (rc) {
-		BCMLOG_ERR("Failed to enable PCI device\n");
+		pr_err("Failed to enable PCI device\n");
 		goto err;
 	}
 
@@ -564,7 +564,7 @@ static int __devinit chd_dec_pci_probe(struct pci_dev *pdev,
 
 	rc = chd_pci_reserve_mem(pinfo);
 	if (rc) {
-		BCMLOG_ERR("Failed to setup memory regions.\n");
+		pr_err("Failed to setup memory regions.\n");
 		pci_disable_device(pdev);
 		rc = -ENOMEM;
 		goto err;
@@ -580,7 +580,7 @@ static int __devinit chd_dec_pci_probe(struct pci_dev *pdev,
 	chd_dec_init_chdev(pinfo);
 	rc = chd_dec_enable_int(pinfo);
 	if (rc) {
-		BCMLOG_ERR("_enable_int err:%d\n", rc);
+		pr_err("_enable_int err:%d\n", rc);
 		pci_disable_device(pdev);
 		rc = -ENODEV;
 		goto err;
@@ -594,7 +594,7 @@ static int __devinit chd_dec_pci_probe(struct pci_dev *pdev,
 		pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
 		pinfo->dmabits = 32;
 	} else {
-		BCMLOG_ERR("Unabled to setup DMA %d\n", rc);
+		pr_err("Unabled to setup DMA %d\n", rc);
 		pci_disable_device(pdev);
 		rc = -ENODEV;
 		goto err;
@@ -602,7 +602,7 @@ static int __devinit chd_dec_pci_probe(struct pci_dev *pdev,
 
 	sts = crystalhd_setup_cmd_context(&pinfo->cmds, pinfo);
 	if (sts != BC_STS_SUCCESS) {
-		BCMLOG_ERR("cmd setup :%d\n", sts);
+		pr_err("cmd setup :%d\n", sts);
 		pci_disable_device(pdev);
 		rc = -ENODEV;
 		goto err;
@@ -630,19 +630,19 @@ int chd_dec_pci_suspend(struct pci_dev *pdev, pm_message_t state)
 
 	adp = pci_get_drvdata(pdev);
 	if (!adp) {
-		BCMLOG_ERR("could not get adp\n");
+		pr_err("could not get adp\n");
 		return -ENODEV;
 	}
 
 	temp = chd_dec_alloc_iodata(adp, false);
 	if (!temp) {
-		BCMLOG_ERR("could not get ioctl data\n");
+		pr_err("could not get ioctl data\n");
 		return -ENODEV;
 	}
 
 	sts = crystalhd_suspend(&adp->cmds, temp);
 	if (sts != BC_STS_SUCCESS) {
-		BCMLOG_ERR("BCM70012 Suspend %d\n", sts);
+		pr_err("BCM70012 Suspend %d\n", sts);
 		return -ENODEV;
 	}
 
@@ -664,7 +664,7 @@ int chd_dec_pci_resume(struct pci_dev *pdev)
 
 	adp = pci_get_drvdata(pdev);
 	if (!adp) {
-		BCMLOG_ERR("could not get adp\n");
+		pr_err("could not get adp\n");
 		return -ENODEV;
 	}
 
@@ -673,7 +673,7 @@ int chd_dec_pci_resume(struct pci_dev *pdev)
 
 	/* device's irq possibly is changed, driver should take care */
 	if (pci_enable_device(pdev)) {
-		BCMLOG_ERR("Failed to enable PCI device\n");
+		pr_err("Failed to enable PCI device\n");
 		return 1;
 	}
 
@@ -681,14 +681,14 @@ int chd_dec_pci_resume(struct pci_dev *pdev)
 
 	rc = chd_dec_enable_int(adp);
 	if (rc) {
-		BCMLOG_ERR("_enable_int err:%d\n", rc);
+		pr_err("_enable_int err:%d\n", rc);
 		pci_disable_device(pdev);
 		return -ENODEV;
 	}
 
 	sts = crystalhd_resume(&adp->cmds);
 	if (sts != BC_STS_SUCCESS) {
-		BCMLOG_ERR("BCM70012 Resume %d\n", sts);
+		pr_err("BCM70012 Resume %d\n", sts);
 		pci_disable_device(pdev);
 		return -ENODEV;
 	}
@@ -750,7 +750,7 @@ static int __init chd_dec_module_init(void)
 	rc = pci_register_driver(&bc_chd_70012_driver);
 
 	if (rc < 0)
-		BCMLOG_ERR("Could not find any devices. err:%d\n", rc);
+		pr_err("Could not find any devices. err:%d\n", rc);
 
 	return rc;
 }
diff --git a/drivers/staging/crystalhd/crystalhd_misc.c b/drivers/staging/crystalhd/crystalhd_misc.c
index 5fa0c6e..db140bf 100644
--- a/drivers/staging/crystalhd/crystalhd_misc.c
+++ b/drivers/staging/crystalhd/crystalhd_misc.c
@@ -54,7 +54,7 @@ static struct crystalhd_dio_req *crystalhd_alloc_dio(struct crystalhd_adp *adp)
 	struct crystalhd_dio_req *temp = NULL;
 
 	if (!adp) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return temp;
 	}
 
@@ -143,7 +143,7 @@ static inline void crystalhd_init_sg(struct scatterlist *sg, unsigned int entrie
 uint32_t bc_dec_reg_rd(struct crystalhd_adp *adp, uint32_t reg_off)
 {
 	if (!adp || (reg_off > adp->pci_mem_len)) {
-		BCMLOG_ERR("dec_rd_reg_off outof range: 0x%08x\n", reg_off);
+		pr_err("dec_rd_reg_off outof range: 0x%08x\n", reg_off);
 		return 0;
 	}
 
@@ -166,7 +166,7 @@ uint32_t bc_dec_reg_rd(struct crystalhd_adp *adp, uint32_t reg_off)
 void bc_dec_reg_wr(struct crystalhd_adp *adp, uint32_t reg_off, uint32_t val)
 {
 	if (!adp || (reg_off > adp->pci_mem_len)) {
-		BCMLOG_ERR("dec_wr_reg_off outof range: 0x%08x\n", reg_off);
+		pr_err("dec_wr_reg_off outof range: 0x%08x\n", reg_off);
 		return;
 	}
 	writel(val, adp->addr + reg_off);
@@ -189,7 +189,7 @@ void bc_dec_reg_wr(struct crystalhd_adp *adp, uint32_t reg_off, uint32_t val)
 uint32_t crystalhd_reg_rd(struct crystalhd_adp *adp, uint32_t reg_off)
 {
 	if (!adp || (reg_off > adp->pci_i2o_len)) {
-		BCMLOG_ERR("link_rd_reg_off outof range: 0x%08x\n", reg_off);
+		pr_err("link_rd_reg_off outof range: 0x%08x\n", reg_off);
 		return 0;
 	}
 	return readl(adp->i2o_addr + reg_off);
@@ -212,7 +212,7 @@ uint32_t crystalhd_reg_rd(struct crystalhd_adp *adp, uint32_t reg_off)
 void crystalhd_reg_wr(struct crystalhd_adp *adp, uint32_t reg_off, uint32_t val)
 {
 	if (!adp || (reg_off > adp->pci_i2o_len)) {
-		BCMLOG_ERR("link_wr_reg_off outof range: 0x%08x\n", reg_off);
+		pr_err("link_wr_reg_off outof range: 0x%08x\n", reg_off);
 		return;
 	}
 	writel(val, adp->i2o_addr + reg_off);
@@ -237,7 +237,7 @@ enum BC_STATUS crystalhd_mem_rd(struct crystalhd_adp *adp, uint32_t start_off,
 
 	if (!adp || !rd_buff ||
 	    (bc_chk_dram_range(adp, start_off, dw_cnt) != BC_STS_SUCCESS)) {
-		BCMLOG_ERR("Invalid arg\n");
+		pr_err("Invalid arg\n");
 		return BC_STS_INV_ARG;
 	}
 	for (ix = 0; ix < dw_cnt; ix++)
@@ -265,7 +265,7 @@ enum BC_STATUS crystalhd_mem_wr(struct crystalhd_adp *adp, uint32_t start_off,
 
 	if (!adp || !wr_buff ||
 	    (bc_chk_dram_range(adp, start_off, dw_cnt) != BC_STS_SUCCESS)) {
-		BCMLOG_ERR("Invalid arg\n");
+		pr_err("Invalid arg\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -293,7 +293,7 @@ enum BC_STATUS crystalhd_pci_cfg_rd(struct crystalhd_adp *adp, uint32_t off,
 	int rc = 0;
 
 	if (!adp || !val) {
-		BCMLOG_ERR("Invalid arg\n");
+		pr_err("Invalid arg\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -310,7 +310,7 @@ enum BC_STATUS crystalhd_pci_cfg_rd(struct crystalhd_adp *adp, uint32_t off,
 	default:
 		rc = -EINVAL;
 		sts = BC_STS_INV_ARG;
-		BCMLOG_ERR("Invalid len:%d\n", len);
+		pr_err("Invalid len:%d\n", len);
 	}
 
 	if (rc && (sts == BC_STS_SUCCESS))
@@ -338,7 +338,7 @@ enum BC_STATUS crystalhd_pci_cfg_wr(struct crystalhd_adp *adp, uint32_t off,
 	int rc = 0;
 
 	if (!adp || !val) {
-		BCMLOG_ERR("Invalid arg\n");
+		pr_err("Invalid arg\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -355,7 +355,7 @@ enum BC_STATUS crystalhd_pci_cfg_wr(struct crystalhd_adp *adp, uint32_t off,
 	default:
 		rc = -EINVAL;
 		sts = BC_STS_INV_ARG;
-		BCMLOG_ERR("Invalid len:%d\n", len);
+		pr_err("Invalid len:%d\n", len);
 	}
 
 	if (rc && (sts == BC_STS_SUCCESS))
@@ -383,7 +383,7 @@ void *bc_kern_dma_alloc(struct crystalhd_adp *adp, uint32_t sz,
 	void *temp = NULL;
 
 	if (!adp || !sz || !phy_addr) {
-		BCMLOG_ERR("Invalide Arg..\n");
+		pr_err("Invalide Arg..\n");
 		return temp;
 	}
 
@@ -409,7 +409,7 @@ void bc_kern_dma_free(struct crystalhd_adp *adp, uint32_t sz, void *ka,
 		      dma_addr_t phy_addr)
 {
 	if (!adp || !ka || !sz || !phy_addr) {
-		BCMLOG_ERR("Invalide Arg..\n");
+		pr_err("Invalide Arg..\n");
 		return;
 	}
 
@@ -436,7 +436,7 @@ enum BC_STATUS crystalhd_create_dioq(struct crystalhd_adp *adp,
 	struct crystalhd_dioq *dioq = NULL;
 
 	if (!adp || !dioq_hnd) {
-		BCMLOG_ERR("Invalid arg!!\n");
+		pr_err("Invalid arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -505,13 +505,13 @@ enum BC_STATUS crystalhd_dioq_add(struct crystalhd_dioq *ioq, void *data,
 	struct crystalhd_elem *tmp;
 
 	if (!ioq || (ioq->sig != BC_LINK_DIOQ_SIG) || !data) {
-		BCMLOG_ERR("Invalid arg!!\n");
+		pr_err("Invalid arg!!\n");
 		return BC_STS_INV_ARG;
 	}
 
 	tmp = crystalhd_alloc_elem(ioq->adp);
 	if (!tmp) {
-		BCMLOG_ERR("No free elements.\n");
+		pr_err("No free elements.\n");
 		return BC_STS_INSUFF_RES;
 	}
 
@@ -548,7 +548,7 @@ void *crystalhd_dioq_fetch(struct crystalhd_dioq *ioq)
 	void *data = NULL;
 
 	if (!ioq || (ioq->sig != BC_LINK_DIOQ_SIG)) {
-		BCMLOG_ERR("Invalid arg!!\n");
+		pr_err("Invalid arg!!\n");
 		return data;
 	}
 
@@ -586,7 +586,7 @@ void *crystalhd_dioq_find_and_fetch(struct crystalhd_dioq *ioq, uint32_t tag)
 	void *data = NULL;
 
 	if (!ioq || (ioq->sig != BC_LINK_DIOQ_SIG)) {
-		BCMLOG_ERR("Invalid arg!!\n");
+		pr_err("Invalid arg!!\n");
 		return data;
 	}
 
@@ -631,7 +631,7 @@ void *crystalhd_dioq_fetch_wait(struct crystalhd_dioq *ioq, uint32_t to_secs,
 	void *tmp = NULL;
 
 	if (!ioq || (ioq->sig != BC_LINK_DIOQ_SIG) || !to_secs || !sig_pend) {
-		BCMLOG_ERR("Invalid arg!!\n");
+		pr_err("Invalid arg!!\n");
 		return tmp;
 	}
 
@@ -685,7 +685,7 @@ enum BC_STATUS crystalhd_map_dio(struct crystalhd_adp *adp, void *ubuff,
 	int i = 0, rw = 0, res = 0, nr_pages = 0, skip_fb_sg = 0;
 
 	if (!adp || !ubuff || !ubuff_sz || !dio_hnd) {
-		BCMLOG_ERR("Invalid arg\n");
+		pr_err("Invalid arg\n");
 		return BC_STS_INV_ARG;
 	}
 	/* Compute pages */
@@ -696,13 +696,13 @@ enum BC_STATUS crystalhd_map_dio(struct crystalhd_adp *adp, void *ubuff,
 	nr_pages = end - start;
 
 	if (!count || ((uaddr + count) < uaddr)) {
-		BCMLOG_ERR("User addr overflow!!\n");
+		pr_err("User addr overflow!!\n");
 		return BC_STS_INV_ARG;
 	}
 
 	dio = crystalhd_alloc_dio(adp);
 	if (!dio) {
-		BCMLOG_ERR("dio pool empty..\n");
+		pr_err("dio pool empty..\n");
 		return BC_STS_INSUFF_RES;
 	}
 
@@ -715,7 +715,7 @@ enum BC_STATUS crystalhd_map_dio(struct crystalhd_adp *adp, void *ubuff,
 	}
 
 	if (nr_pages > dio->max_pages) {
-		BCMLOG_ERR("max_pages(%d) exceeded(%d)!!\n",
+		pr_err("max_pages(%d) exceeded(%d)!!\n",
 			   dio->max_pages, nr_pages);
 		crystalhd_unmap_dio(adp, dio);
 		return BC_STS_INSUFF_RES;
@@ -733,7 +733,7 @@ enum BC_STATUS crystalhd_map_dio(struct crystalhd_adp *adp, void *ubuff,
 				     (void *)(uaddr + count - dio->fb_size),
 				     dio->fb_size);
 		if (res) {
-			BCMLOG_ERR("failed %d to copy %u fill bytes from %p\n",
+			pr_err("failed %d to copy %u fill bytes from %p\n",
 				   res, dio->fb_size,
 				   (void *)(uaddr + count-dio->fb_size));
 			crystalhd_unmap_dio(adp, dio);
@@ -749,7 +749,7 @@ enum BC_STATUS crystalhd_map_dio(struct crystalhd_adp *adp, void *ubuff,
 	/* Save for release..*/
 	dio->sig = crystalhd_dio_locked;
 	if (res < nr_pages) {
-		BCMLOG_ERR("get pages failed: %d-%d\n", nr_pages, res);
+		pr_err("get pages failed: %d-%d\n", nr_pages, res);
 		dio->page_cnt = res;
 		crystalhd_unmap_dio(adp, dio);
 		return BC_STS_ERROR;
@@ -791,7 +791,7 @@ enum BC_STATUS crystalhd_map_dio(struct crystalhd_adp *adp, void *ubuff,
 	dio->sg_cnt = pci_map_sg(adp->pdev, dio->sg,
 				 dio->page_cnt, dio->direction);
 	if (dio->sg_cnt <= 0) {
-		BCMLOG_ERR("sg map %d-%d\n", dio->sg_cnt, dio->page_cnt);
+		pr_err("sg map %d-%d\n", dio->sg_cnt, dio->page_cnt);
 		crystalhd_unmap_dio(adp, dio);
 		return BC_STS_ERROR;
 	}
@@ -826,7 +826,7 @@ enum BC_STATUS crystalhd_unmap_dio(struct crystalhd_adp *adp, struct crystalhd_d
 	int j = 0;
 
 	if (!adp || !dio) {
-		BCMLOG_ERR("Invalid arg\n");
+		pr_err("Invalid arg\n");
 		return BC_STS_INV_ARG;
 	}
 
@@ -867,7 +867,7 @@ int crystalhd_create_dio_pool(struct crystalhd_adp *adp, uint32_t max_pages)
 	struct crystalhd_dio_req *dio;
 
 	if (!adp || !max_pages) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return -EINVAL;
 	}
 
@@ -875,7 +875,7 @@ int crystalhd_create_dio_pool(struct crystalhd_adp *adp, uint32_t max_pages)
 	adp->fill_byte_pool = pci_pool_create("crystalhd_fbyte",
 					      adp->pdev, 8, 8, 0);
 	if (!adp->fill_byte_pool) {
-		BCMLOG_ERR("failed to create fill byte pool\n");
+		pr_err("failed to create fill byte pool\n");
 		return -ENOMEM;
 	}
 
@@ -889,7 +889,7 @@ int crystalhd_create_dio_pool(struct crystalhd_adp *adp, uint32_t max_pages)
 	for (i = 0; i < BC_LINK_SG_POOL_SZ; i++) {
 		temp = kzalloc(asz, GFP_KERNEL);
 		if ((temp) == NULL) {
-			BCMLOG_ERR("Failed to alloc %d mem\n", asz);
+			pr_err("Failed to alloc %d mem\n", asz);
 			return -ENOMEM;
 		}
 
@@ -902,7 +902,7 @@ int crystalhd_create_dio_pool(struct crystalhd_adp *adp, uint32_t max_pages)
 		dio->fb_va = pci_pool_alloc(adp->fill_byte_pool, GFP_KERNEL,
 					    &dio->fb_pa);
 		if (!dio->fb_va) {
-			BCMLOG_ERR("fill byte alloc failed.\n");
+			pr_err("fill byte alloc failed.\n");
 			return -ENOMEM;
 		}
 
@@ -927,7 +927,7 @@ void crystalhd_destroy_dio_pool(struct crystalhd_adp *adp)
 	int count = 0;
 
 	if (!adp) {
-		BCMLOG_ERR("Invalid Arg!!\n");
+		pr_err("Invalid Arg!!\n");
 		return;
 	}
 
@@ -973,7 +973,7 @@ int __devinit crystalhd_create_elem_pool(struct crystalhd_adp *adp,
 	for (i = 0; i < pool_size; i++) {
 		temp = kzalloc(sizeof(*temp), GFP_KERNEL);
 		if (!temp) {
-			BCMLOG_ERR("kalloc failed\n");
+			pr_err("kalloc failed\n");
 			return -ENOMEM;
 		}
 		crystalhd_free_elem(adp, temp);
diff --git a/drivers/staging/crystalhd/crystalhd_misc.h b/drivers/staging/crystalhd/crystalhd_misc.h
index d2f7256..379b65b 100644
--- a/drivers/staging/crystalhd/crystalhd_misc.h
+++ b/drivers/staging/crystalhd/crystalhd_misc.h
@@ -209,12 +209,4 @@ do {					\
 		printk(fmt, ##args);	\
 } while (0)
 
-
-#define BCMLOG_ERR(fmt, args...)				\
-do {								\
-	if (g_linklog_level & BCMLOG_ERROR)			\
-		printk(KERN_ERR "*ERR*:%s:%d: "fmt,		\
-				__FILE__, __LINE__, ##args);	\
-} while (0)
-
 #endif
-- 
1.7.2.5

Re: [PATCH 3/3] Staging: crystalhd: Replace the BCMLOG_ERR macro with pr_err

[Dan Carpenter]

[-- Attachment #1: Type: text/plain, Size: 334 bytes --]

On Fri, Feb 17, 2012 at 09:39:36PM -0200, Jorgyano Vieira wrote:
> Replace the usage of BCMLOG_ERR with pr_err and remove the macro definition.
>

This needs a pr_fmt line so we can tell where the errors are coming
from.

#define pr_fmt(fmt)     KBUILD_MODNAME ": %s:%d: " fmt, __func__, __LINE__

regards,
dan carpenter


[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 836 bytes --]

Re: [PATCH 3/3] Staging: crystalhd: Replace the BCMLOG_ERR macro with pr_err

[Joe Perches]

On Sat, 2012-02-18 at 09:25 +0300, Dan Carpenter wrote:
> On Fri, Feb 17, 2012 at 09:39:36PM -0200, Jorgyano Vieira wrote:
> > Replace the usage of BCMLOG_ERR with pr_err and remove the macro definition.
> This needs a pr_fmt line so we can tell where the errors are coming
> from.
> #define pr_fmt(fmt)     KBUILD_MODNAME ": %s:%d: " fmt, __func__, __LINE__

True.
__func__ and __LINE__ are not generally useful though.

I suggest just
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Re: [PATCH 3/3] Staging: crystalhd: Replace the BCMLOG_ERR macro with pr_err

[Dan Carpenter]

[-- Attachment #1: Type: text/plain, Size: 654 bytes --]

On Fri, Feb 17, 2012 at 10:30:25PM -0800, Joe Perches wrote:
> On Sat, 2012-02-18 at 09:25 +0300, Dan Carpenter wrote:
> > On Fri, Feb 17, 2012 at 09:39:36PM -0200, Jorgyano Vieira wrote:
> > > Replace the usage of BCMLOG_ERR with pr_err and remove the macro definition.
> > This needs a pr_fmt line so we can tell where the errors are coming
> > from.
> > #define pr_fmt(fmt)     KBUILD_MODNAME ": %s:%d: " fmt, __func__, __LINE__
> 
> True.
> __func__ and __LINE__ are not generally useful though.
> 

If you don't know the function and line number, then how do you
tell all the "Invalid args" printks apart?

regards,
dan carpenter


[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 836 bytes --]

Re: [PATCH 3/3] Staging: crystalhd: Replace the BCMLOG_ERR macro with pr_err

[Joe Perches]

On Sat, 2012-02-18 at 09:40 +0300, Dan Carpenter wrote:
> On Fri, Feb 17, 2012 at 10:30:25PM -0800, Joe Perches wrote:
> > On Sat, 2012-02-18 at 09:25 +0300, Dan Carpenter wrote:
> > > On Fri, Feb 17, 2012 at 09:39:36PM -0200, Jorgyano Vieira wrote:
> > > > Replace the usage of BCMLOG_ERR with pr_err and remove the macro definition.
> > > This needs a pr_fmt line so we can tell where the errors are coming
> > > from.
> > > #define pr_fmt(fmt)     KBUILD_MODNAME ": %s:%d: " fmt, __func__, __LINE__
> > True.
> > __func__ and __LINE__ are not generally useful though.
> If you don't know the function and line number, then how do you
> tell all the "Invalid args" printks apart?

It's possible to add "%s...", __func__ to
the necessary uses.  Adding it to the generic
is likely overkill.

But is it really necessary anyway?

Aren't those called via some specific notifier
such that the output would make sense given
some specific invalid input?

Re: [PATCH 3/3] Staging: crystalhd: Replace the BCMLOG_ERR macro with pr_err

[Jorgyano vieira]

> It's possible to add "%s...", __func__ to
> the necessary uses.  Adding it to the generic
> is likely overkill.
I agree with that.

> But is it really necessary anyway?
>
> Aren't those called via some specific notifier
> such that the output would make sense given
> some specific invalid input?
Some messages like "Invalid Arg" and "Invalid len" really don't make
sense as it is.

But I think that just adding __func__ to the necessary uses is enough.
I will resend this patch.