diff --git a/drivers/mtd/nand/pxa3xx_nand.c b/drivers/mtd/nand/pxa3xx_nand.c
index 321a90c..3e2a848 100644
--- a/drivers/mtd/nand/pxa3xx_nand.c
+++ b/drivers/mtd/nand/pxa3xx_nand.c
@@ -132,7 +132,7 @@
 /* macros for registers read/write */
 #define nand_writel(info, off, val)					\
 	do {								\
-		dev_vdbg(&info->pdev->dev,				\
+		dev_dbg(&info->pdev->dev,				\
 			 "%s():%d nand_writel(0x%x, 0x%04x)\n",		\
 			 __func__, __LINE__, (val), (off));		\
 		writel_relaxed((val), (info)->mmio_base + (off));	\
@@ -142,7 +142,7 @@
 	({								\
 		unsigned int _v;					\
 		_v = readl_relaxed((info)->mmio_base + (off));		\
-		dev_vdbg(&info->pdev->dev,				\
+		dev_dbg(&info->pdev->dev,				\
 			 "%s():%d nand_readl(0x%04x) = 0x%x\n",		\
 			 __func__, __LINE__, (off), _v);		\
 		_v;							\
@@ -323,6 +323,8 @@ static struct pxa3xx_nand_flash builtin_flash_types[] = {
 	{ 0xba20, 16, 16, &timing[3] },
 };
 
+#define return while(printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__),1) return
+
 static int pxa3xx_ooblayout_ecc(struct mtd_info *mtd, int section,
 				struct mtd_oob_region *oobregion)
 {
@@ -331,6 +333,7 @@ static int pxa3xx_ooblayout_ecc(struct mtd_info *mtd, int section,
 	struct pxa3xx_nand_info *info = host->info_data;
 	int nchunks = mtd->writesize / info->chunk_size;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (section >= nchunks)
 		return -ERANGE;
 
@@ -338,6 +341,7 @@ static int pxa3xx_ooblayout_ecc(struct mtd_info *mtd, int section,
 			    info->spare_size;
 	oobregion->length = info->ecc_size;
 
+	//printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 	return 0;
 }
 
@@ -349,6 +353,8 @@ static int pxa3xx_ooblayout_free(struct mtd_info *mtd, int section,
 	struct pxa3xx_nand_info *info = host->info_data;
 	int nchunks = mtd->writesize / info->chunk_size;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
+
 	if (section >= nchunks)
 		return -ERANGE;
 
@@ -434,6 +440,7 @@ pxa3xx_nand_get_variant(struct platform_device *pdev)
 {
 	const struct of_device_id *of_id =
 			of_match_device(pxa3xx_nand_dt_ids, &pdev->dev);
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (!of_id)
 		return PXA3XX_NAND_VARIANT_PXA;
 	return (enum pxa3xx_nand_variant)of_id->data;
@@ -446,6 +453,7 @@ static void pxa3xx_nand_set_timing(struct pxa3xx_nand_host *host,
 	unsigned long nand_clk = clk_get_rate(info->clk);
 	uint32_t ndtr0, ndtr1;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	ndtr0 = NDTR0_tCH(ns2cycle(t->tCH, nand_clk)) |
 		NDTR0_tCS(ns2cycle(t->tCS, nand_clk)) |
 		NDTR0_tWH(ns2cycle(t->tWH, nand_clk)) |
@@ -461,6 +469,7 @@ static void pxa3xx_nand_set_timing(struct pxa3xx_nand_host *host,
 	info->ndtr1cs0 = ndtr1;
 	nand_writel(info, NDTR0CS0, ndtr0);
 	nand_writel(info, NDTR1CS0, ndtr1);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void pxa3xx_nand_set_sdr_timing(struct pxa3xx_nand_host *host,
@@ -481,6 +490,7 @@ static void pxa3xx_nand_set_sdr_timing(struct pxa3xx_nand_host *host,
 	u32 tWHR_min = DIV_ROUND_UP(t->tWHR_min, 1000);
 	u32 tAR_min = DIV_ROUND_UP(t->tAR_min, 1000);
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	/* fallback to a default value if tR = 0 */
 	if (!tR)
 		tR = 20000;
@@ -500,6 +510,7 @@ static void pxa3xx_nand_set_sdr_timing(struct pxa3xx_nand_host *host,
 	info->ndtr1cs0 = ndtr1;
 	nand_writel(info, NDTR0CS0, ndtr0);
 	nand_writel(info, NDTR1CS0, ndtr1);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static int pxa3xx_nand_init_timings_compat(struct pxa3xx_nand_host *host,
@@ -512,6 +523,7 @@ static int pxa3xx_nand_init_timings_compat(struct pxa3xx_nand_host *host,
 	struct mtd_info *mtd = nand_to_mtd(&host->chip);
 	int i, id, ntypes;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	ntypes = ARRAY_SIZE(builtin_flash_types);
 
 	chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
@@ -544,6 +556,7 @@ static int pxa3xx_nand_init_timings_onfi(struct pxa3xx_nand_host *host,
 {
 	const struct nand_sdr_timings *timings;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	mode = fls(mode) - 1;
 	if (mode < 0)
 		mode = 0;
@@ -564,6 +577,7 @@ static int pxa3xx_nand_init(struct pxa3xx_nand_host *host)
 	unsigned int flash_width = 0, dfc_width = 0;
 	int mode, err;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	mode = onfi_get_async_timing_mode(chip);
 	if (mode == ONFI_TIMING_MODE_UNKNOWN) {
 		err = pxa3xx_nand_init_timings_compat(host, &flash_width,
@@ -596,6 +610,7 @@ static void pxa3xx_nand_start(struct pxa3xx_nand_info *info)
 {
 	uint32_t ndcr;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	ndcr = info->reg_ndcr;
 
 	if (info->use_ecc) {
@@ -624,6 +639,7 @@ static void pxa3xx_nand_start(struct pxa3xx_nand_info *info)
 	nand_writel(info, NDSR, NDSR_MASK);
 	nand_writel(info, NDCR, 0);
 	nand_writel(info, NDCR, ndcr);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void pxa3xx_nand_stop(struct pxa3xx_nand_info *info)
@@ -631,6 +647,7 @@ static void pxa3xx_nand_stop(struct pxa3xx_nand_info *info)
 	uint32_t ndcr;
 	int timeout = NAND_STOP_DELAY;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	/* wait RUN bit in NDCR become 0 */
 	ndcr = nand_readl(info, NDCR);
 	while ((ndcr & NDCR_ND_RUN) && (timeout-- > 0)) {
@@ -647,6 +664,7 @@ static void pxa3xx_nand_stop(struct pxa3xx_nand_info *info)
 
 	/* clear status bits */
 	nand_writel(info, NDSR, NDSR_MASK);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void __maybe_unused
@@ -654,20 +672,25 @@ enable_int(struct pxa3xx_nand_info *info, uint32_t int_mask)
 {
 	uint32_t ndcr;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	ndcr = nand_readl(info, NDCR);
 	nand_writel(info, NDCR, ndcr & ~int_mask);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void disable_int(struct pxa3xx_nand_info *info, uint32_t int_mask)
 {
 	uint32_t ndcr;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	ndcr = nand_readl(info, NDCR);
 	nand_writel(info, NDCR, ndcr | int_mask);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void drain_fifo(struct pxa3xx_nand_info *info, void *data, int len)
 {
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (info->ecc_bch) {
 		u32 val;
 		int ret;
@@ -697,10 +720,12 @@ static void drain_fifo(struct pxa3xx_nand_info *info, void *data, int len)
 	}
 
 	ioread32_rep(info->mmio_base + NDDB, data, len);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void handle_data_pio(struct pxa3xx_nand_info *info)
 {
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	switch (info->state) {
 	case STATE_PIO_WRITING:
 		if (info->step_chunk_size)
@@ -733,6 +758,7 @@ static void handle_data_pio(struct pxa3xx_nand_info *info)
 	/* Update buffer pointers for multi-page read/write */
 	info->data_buff_pos += info->step_chunk_size;
 	info->oob_buff_pos += info->step_spare_size;
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void pxa3xx_nand_data_dma_irq(void *data)
@@ -741,6 +767,7 @@ static void pxa3xx_nand_data_dma_irq(void *data)
 	struct dma_tx_state state;
 	enum dma_status status;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	status = dmaengine_tx_status(info->dma_chan, info->dma_cookie, &state);
 	if (likely(status == DMA_COMPLETE)) {
 		info->state = STATE_DMA_DONE;
@@ -752,6 +779,7 @@ static void pxa3xx_nand_data_dma_irq(void *data)
 
 	nand_writel(info, NDSR, NDSR_WRDREQ | NDSR_RDDREQ);
 	enable_int(info, NDCR_INT_MASK);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void start_data_dma(struct pxa3xx_nand_info *info)
@@ -759,6 +787,7 @@ static void start_data_dma(struct pxa3xx_nand_info *info)
 	enum dma_transfer_direction direction;
 	struct dma_async_tx_descriptor *tx;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	switch (info->state) {
 	case STATE_DMA_WRITING:
 		info->dma_dir = DMA_TO_DEVICE;
@@ -790,12 +819,14 @@ static void start_data_dma(struct pxa3xx_nand_info *info)
 	dma_async_issue_pending(info->dma_chan);
 	dev_dbg(&info->pdev->dev, "%s(dir=%d cookie=%x size=%u)\n",
 		__func__, direction, info->dma_cookie, info->sg.length);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static irqreturn_t pxa3xx_nand_irq_thread(int irq, void *data)
 {
 	struct pxa3xx_nand_info *info = data;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	handle_data_pio(info);
 
 	info->state = STATE_CMD_DONE;
@@ -811,6 +842,7 @@ static irqreturn_t pxa3xx_nand_irq(int irq, void *devid)
 	unsigned int ready, cmd_done;
 	irqreturn_t ret = IRQ_HANDLED;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (info->cs == 0) {
 		ready           = NDSR_FLASH_RDY;
 		cmd_done        = NDSR_CS0_CMDD;
@@ -897,11 +929,13 @@ static irqreturn_t pxa3xx_nand_irq(int irq, void *devid)
 	if (is_ready)
 		complete(&info->dev_ready);
 NORMAL_IRQ_EXIT:
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 	return ret;
 }
 
 static inline int is_buf_blank(uint8_t *buf, size_t len)
 {
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	for (; len > 0; len--)
 		if (*buf++ != 0xff)
 			return 0;
@@ -911,6 +945,7 @@ static inline int is_buf_blank(uint8_t *buf, size_t len)
 static void set_command_address(struct pxa3xx_nand_info *info,
 		unsigned int page_size, uint16_t column, int page_addr)
 {
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	/* small page addr setting */
 	if (page_size < PAGE_CHUNK_SIZE) {
 		info->ndcb1 = ((page_addr & 0xFFFFFF) << 8)
@@ -926,6 +961,7 @@ static void set_command_address(struct pxa3xx_nand_info *info,
 		else
 			info->ndcb2 = 0;
 	}
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void prepare_start_command(struct pxa3xx_nand_info *info, int command)
@@ -933,6 +969,7 @@ static void prepare_start_command(struct pxa3xx_nand_info *info, int command)
 	struct pxa3xx_nand_host *host = info->host[info->cs];
 	struct mtd_info *mtd = nand_to_mtd(&host->chip);
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	/* reset data and oob column point to handle data */
 	info->buf_start		= 0;
 	info->buf_count		= 0;
@@ -974,6 +1011,7 @@ static void prepare_start_command(struct pxa3xx_nand_info *info, int command)
 		memset(info->data_buff, 0xFF, info->buf_count);
 	}
 
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static int prepare_set_command(struct pxa3xx_nand_info *info, int command,
@@ -983,6 +1021,7 @@ static int prepare_set_command(struct pxa3xx_nand_info *info, int command,
 	struct pxa3xx_nand_host *host;
 	struct mtd_info *mtd;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	host = info->host[info->cs];
 	mtd = nand_to_mtd(&host->chip);
 	addr_cycle = 0;
@@ -1173,6 +1212,7 @@ static void nand_cmdfunc(struct mtd_info *mtd, unsigned command,
 	struct pxa3xx_nand_info *info = host->info_data;
 	int exec_cmd;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	/*
 	 * if this is a x16 device ,then convert the input
 	 * "byte" address into a "word" address appropriate
@@ -1211,6 +1251,7 @@ static void nand_cmdfunc(struct mtd_info *mtd, unsigned command,
 		}
 	}
 	info->state = STATE_IDLE;
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void nand_cmdfunc_extended(struct mtd_info *mtd,
@@ -1222,6 +1263,7 @@ static void nand_cmdfunc_extended(struct mtd_info *mtd,
 	struct pxa3xx_nand_info *info = host->info_data;
 	int exec_cmd, ext_cmd_type;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	/*
 	 * if this is a x16 device then convert the input
 	 * "byte" address into a "word" address appropriate
@@ -1331,12 +1373,14 @@ static void nand_cmdfunc_extended(struct mtd_info *mtd,
 	} while (1);
 
 	info->state = STATE_IDLE;
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static int pxa3xx_nand_write_page_hwecc(struct mtd_info *mtd,
 		struct nand_chip *chip, const uint8_t *buf, int oob_required,
 		int page)
 {
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	chip->write_buf(mtd, buf, mtd->writesize);
 	chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
 
@@ -1350,6 +1394,7 @@ static int pxa3xx_nand_read_page_hwecc(struct mtd_info *mtd,
 	struct pxa3xx_nand_host *host = nand_get_controller_data(chip);
 	struct pxa3xx_nand_info *info = host->info_data;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	chip->read_buf(mtd, buf, mtd->writesize);
 	chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
 
@@ -1378,6 +1423,7 @@ static uint8_t pxa3xx_nand_read_byte(struct mtd_info *mtd)
 	struct pxa3xx_nand_info *info = host->info_data;
 	char retval = 0xFF;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (info->buf_start < info->buf_count)
 		/* Has just send a new command? */
 		retval = info->data_buff[info->buf_start++];
@@ -1392,6 +1438,7 @@ static u16 pxa3xx_nand_read_word(struct mtd_info *mtd)
 	struct pxa3xx_nand_info *info = host->info_data;
 	u16 retval = 0xFFFF;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (!(info->buf_start & 0x01) && info->buf_start < info->buf_count) {
 		retval = *((u16 *)(info->data_buff+info->buf_start));
 		info->buf_start += 2;
@@ -1406,8 +1453,10 @@ static void pxa3xx_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 	struct pxa3xx_nand_info *info = host->info_data;
 	int real_len = min_t(size_t, len, info->buf_count - info->buf_start);
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	memcpy(buf, info->data_buff + info->buf_start, real_len);
 	info->buf_start += real_len;
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void pxa3xx_nand_write_buf(struct mtd_info *mtd,
@@ -1418,13 +1467,16 @@ static void pxa3xx_nand_write_buf(struct mtd_info *mtd,
 	struct pxa3xx_nand_info *info = host->info_data;
 	int real_len = min_t(size_t, len, info->buf_count - info->buf_start);
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	memcpy(info->data_buff + info->buf_start, buf, real_len);
 	info->buf_start += real_len;
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void pxa3xx_nand_select_chip(struct mtd_info *mtd, int chip)
 {
-	return;
+	//printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
+	//return;
 }
 
 static int pxa3xx_nand_waitfunc(struct mtd_info *mtd, struct nand_chip *this)
@@ -1433,6 +1485,7 @@ static int pxa3xx_nand_waitfunc(struct mtd_info *mtd, struct nand_chip *this)
 	struct pxa3xx_nand_host *host = nand_get_controller_data(chip);
 	struct pxa3xx_nand_info *info = host->info_data;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (info->need_wait) {
 		info->need_wait = 0;
 		if (!wait_for_completion_timeout(&info->dev_ready,
@@ -1460,6 +1513,7 @@ static int pxa3xx_nand_config_ident(struct pxa3xx_nand_info *info)
 	struct pxa3xx_nand_platform_data *pdata = dev_get_platdata(&pdev->dev);
 	const struct nand_sdr_timings *timings;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	/* Configure default flash values */
 	info->chunk_size = PAGE_CHUNK_SIZE;
 	info->reg_ndcr = 0x0; /* enable all interrupts */
@@ -1482,9 +1536,11 @@ static void pxa3xx_nand_config_tail(struct pxa3xx_nand_info *info)
 	struct nand_chip *chip = &host->chip;
 	struct mtd_info *mtd = nand_to_mtd(chip);
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	info->reg_ndcr |= (host->col_addr_cycles == 2) ? NDCR_RA_START : 0;
 	info->reg_ndcr |= (chip->page_shift == 6) ? NDCR_PG_PER_BLK : 0;
 	info->reg_ndcr |= (mtd->writesize == 2048) ? NDCR_PAGE_SZ : 0;
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static void pxa3xx_nand_detect_config(struct pxa3xx_nand_info *info)
@@ -1493,6 +1549,7 @@ static void pxa3xx_nand_detect_config(struct pxa3xx_nand_info *info)
 	struct pxa3xx_nand_platform_data *pdata = dev_get_platdata(&pdev->dev);
 	uint32_t ndcr = nand_readl(info, NDCR);
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	/* Set an initial chunk size */
 	info->chunk_size = ndcr & NDCR_PAGE_SZ ? 2048 : 512;
 	info->reg_ndcr = ndcr &
@@ -1500,6 +1557,7 @@ static void pxa3xx_nand_detect_config(struct pxa3xx_nand_info *info)
 	info->reg_ndcr |= (pdata->enable_arbiter) ? NDCR_ND_ARB_EN : 0;
 	info->ndtr0cs0 = nand_readl(info, NDTR0CS0);
 	info->ndtr1cs0 = nand_readl(info, NDTR1CS0);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static int pxa3xx_nand_init_buff(struct pxa3xx_nand_info *info)
@@ -1510,6 +1568,7 @@ static int pxa3xx_nand_init_buff(struct pxa3xx_nand_info *info)
 	struct pxad_param param;
 	int ret;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	info->data_buff = kmalloc(info->buf_size, GFP_KERNEL);
 	if (info->data_buff == NULL)
 		return -ENOMEM;
@@ -1558,11 +1617,13 @@ static int pxa3xx_nand_init_buff(struct pxa3xx_nand_info *info)
 
 static void pxa3xx_nand_free_buff(struct pxa3xx_nand_info *info)
 {
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (info->use_dma) {
 		dmaengine_terminate_all(info->dma_chan);
 		dma_release_channel(info->dma_chan);
 	}
 	kfree(info->data_buff);
+	printk(KERN_DEBUG "< %s:%d\n", __func__, __LINE__);
 }
 
 static int pxa_ecc_init(struct pxa3xx_nand_info *info,
@@ -1572,6 +1633,7 @@ static int pxa_ecc_init(struct pxa3xx_nand_info *info,
 	struct nand_chip *chip = mtd_to_nand(mtd);
 	struct nand_ecc_ctrl *ecc = &chip->ecc;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (strength == 1 && ecc_stepsize == 512 && page_size == 2048) {
 		info->nfullchunks = 1;
 		info->ntotalchunks = 1;
@@ -1659,6 +1721,7 @@ static int pxa3xx_nand_scan(struct mtd_info *mtd)
 	int ret;
 	uint16_t ecc_strength, ecc_step;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (pdata->keep_config) {
 		pxa3xx_nand_detect_config(info);
 	} else {
@@ -1774,6 +1837,7 @@ static int alloc_nand_resource(struct platform_device *pdev)
 	struct resource *r;
 	int ret, irq, cs;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	pdata = dev_get_platdata(&pdev->dev);
 	if (pdata->num_cs <= 0) {
 		dev_err(&pdev->dev, "invalid number of chip selects\n");
@@ -1891,6 +1955,7 @@ static int pxa3xx_nand_remove(struct platform_device *pdev)
 	struct pxa3xx_nand_platform_data *pdata;
 	int irq, cs;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (!info)
 		return 0;
 
@@ -1925,6 +1990,7 @@ static int pxa3xx_nand_probe_dt(struct platform_device *pdev)
 	const struct of_device_id *of_id =
 			of_match_device(pxa3xx_nand_dt_ids, &pdev->dev);
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (!of_id)
 		return 0;
 
@@ -1949,6 +2015,7 @@ static int pxa3xx_nand_probe(struct platform_device *pdev)
 	struct pxa3xx_nand_info *info;
 	int ret, cs, probe_success, dma_available;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	dma_available = IS_ENABLED(CONFIG_ARM) &&
 		(IS_ENABLED(CONFIG_ARCH_PXA) || IS_ENABLED(CONFIG_ARCH_MMP));
 	if (use_dma && !dma_available) {
@@ -2009,6 +2076,7 @@ static int pxa3xx_nand_suspend(struct device *dev)
 {
 	struct pxa3xx_nand_info *info = dev_get_drvdata(dev);
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	if (info->state) {
 		dev_err(dev, "driver busy, state = %d\n", info->state);
 		return -EAGAIN;
@@ -2023,6 +2091,7 @@ static int pxa3xx_nand_resume(struct device *dev)
 	struct pxa3xx_nand_info *info = dev_get_drvdata(dev);
 	int ret;
 
+	printk(KERN_DEBUG "> %s:%d\n", __func__, __LINE__);
 	ret = clk_enable(info->clk);
 	if (ret < 0)
 		return ret;
diff --git a/include/linux/device.h b/include/linux/device.h
index 66fe271..e73c496 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -1345,12 +1345,12 @@ void _dev_info(const struct device *dev, const char *fmt, ...)
 
 #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
 
-#if defined(CONFIG_DYNAMIC_DEBUG)
+#if 0 && defined(CONFIG_DYNAMIC_DEBUG)
 #define dev_dbg(dev, format, ...)		     \
 do {						     \
 	dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
 } while (0)
-#elif defined(DEBUG)
+#elif 1 || defined(DEBUG)
 #define dev_dbg(dev, format, arg...)		\
 	dev_printk(KERN_DEBUG, dev, format, ##arg)
 #else