Coding Style cleanup, update CHANGELOG

Signed-off-by: Wolfgang Denk <wd@denx.de>

3 files changed, 83 insertions, 83 deletions

diff --git a/drivers/mtd/nand/fsl_elbc_nand.c b/drivers/mtd/nand/fsl_elbc_nand.c
index 0bd1bdb..674c542 100644
--- a/drivers/mtd/nand/fsl_elbc_nand.c
+++ b/drivers/mtd/nand/fsl_elbc_nand.c
@@ -141,14 +141,14 @@ static void set_addr(struct mtd_info *mtd, int column, int page_addr, int oob)
 	if (priv->page_size) {
 		out_be32(&lbc->fbar, page_addr >> 6);
 		out_be32(&lbc->fpar,
-		         ((page_addr << FPAR_LP_PI_SHIFT) & FPAR_LP_PI) |
-		         (oob ? FPAR_LP_MS : 0) | column);
+			 ((page_addr << FPAR_LP_PI_SHIFT) & FPAR_LP_PI) |
+			 (oob ? FPAR_LP_MS : 0) | column);
 		buf_num = (page_addr & 1) << 2;
 	} else {
 		out_be32(&lbc->fbar, page_addr >> 5);
 		out_be32(&lbc->fpar,
-		         ((page_addr << FPAR_SP_PI_SHIFT) & FPAR_SP_PI) |
-		         (oob ? FPAR_SP_MS : 0) | column);
+			 ((page_addr << FPAR_SP_PI_SHIFT) & FPAR_SP_PI) |
+			 (oob ? FPAR_SP_MS : 0) | column);
 		buf_num = page_addr & 7;
 	}
 
@@ -227,24 +227,24 @@ static void fsl_elbc_do_read(struct nand_chip *chip, int oob)
 
 	if (priv->page_size) {
 		out_be32(&lbc->fir,
-		         (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-		         (FIR_OP_CA  << FIR_OP1_SHIFT) |
-		         (FIR_OP_PA  << FIR_OP2_SHIFT) |
-		         (FIR_OP_CW1 << FIR_OP3_SHIFT) |
-		         (FIR_OP_RBW << FIR_OP4_SHIFT));
+			 (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+			 (FIR_OP_CA  << FIR_OP1_SHIFT) |
+			 (FIR_OP_PA  << FIR_OP2_SHIFT) |
+			 (FIR_OP_CW1 << FIR_OP3_SHIFT) |
+			 (FIR_OP_RBW << FIR_OP4_SHIFT));
 
 		out_be32(&lbc->fcr, (NAND_CMD_READ0 << FCR_CMD0_SHIFT) |
-		                    (NAND_CMD_READSTART << FCR_CMD1_SHIFT));
+				    (NAND_CMD_READSTART << FCR_CMD1_SHIFT));
 	} else {
 		out_be32(&lbc->fir,
-		         (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-		         (FIR_OP_CA  << FIR_OP1_SHIFT) |
-		         (FIR_OP_PA  << FIR_OP2_SHIFT) |
-		         (FIR_OP_RBW << FIR_OP3_SHIFT));
+			 (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+			 (FIR_OP_CA  << FIR_OP1_SHIFT) |
+			 (FIR_OP_PA  << FIR_OP2_SHIFT) |
+			 (FIR_OP_RBW << FIR_OP3_SHIFT));
 
 		if (oob)
 			out_be32(&lbc->fcr,
-			         NAND_CMD_READOOB << FCR_CMD0_SHIFT);
+				 NAND_CMD_READOOB << FCR_CMD0_SHIFT);
 		else
 			out_be32(&lbc->fcr, NAND_CMD_READ0 << FCR_CMD0_SHIFT);
 	}
@@ -252,7 +252,7 @@ static void fsl_elbc_do_read(struct nand_chip *chip, int oob)
 
 /* cmdfunc send commands to the FCM */
 static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
-                             int column, int page_addr)
+			     int column, int page_addr)
 {
 	struct nand_chip *chip = mtd->priv;
 	struct fsl_elbc_mtd *priv = chip->priv;
@@ -306,8 +306,8 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
 		vdbg("fsl_elbc_cmdfunc: NAND_CMD_READID.\n");
 
 		out_be32(&lbc->fir, (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-		                    (FIR_OP_UA  << FIR_OP1_SHIFT) |
-		                    (FIR_OP_RBW << FIR_OP2_SHIFT));
+				    (FIR_OP_UA  << FIR_OP1_SHIFT) |
+				    (FIR_OP_RBW << FIR_OP2_SHIFT));
 		out_be32(&lbc->fcr, NAND_CMD_READID << FCR_CMD0_SHIFT);
 		/* 5 bytes for manuf, device and exts */
 		out_be32(&lbc->fbcr, 5);
@@ -331,13 +331,13 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
 		vdbg("fsl_elbc_cmdfunc: NAND_CMD_ERASE2.\n");
 
 		out_be32(&lbc->fir,
-		         (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-		         (FIR_OP_PA  << FIR_OP1_SHIFT) |
-		         (FIR_OP_CM1 << FIR_OP2_SHIFT));
+			 (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+			 (FIR_OP_PA  << FIR_OP1_SHIFT) |
+			 (FIR_OP_CM1 << FIR_OP2_SHIFT));
 
 		out_be32(&lbc->fcr,
-		         (NAND_CMD_ERASE1 << FCR_CMD0_SHIFT) |
-		         (NAND_CMD_ERASE2 << FCR_CMD1_SHIFT));
+			 (NAND_CMD_ERASE1 << FCR_CMD0_SHIFT) |
+			 (NAND_CMD_ERASE2 << FCR_CMD1_SHIFT));
 
 		out_be32(&lbc->fbcr, 0);
 		ctrl->read_bytes = 0;
@@ -360,22 +360,22 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
 			      (NAND_CMD_PAGEPROG << FCR_CMD1_SHIFT);
 
 			out_be32(&lbc->fir,
-			         (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-			         (FIR_OP_CA  << FIR_OP1_SHIFT) |
-			         (FIR_OP_PA  << FIR_OP2_SHIFT) |
-			         (FIR_OP_WB  << FIR_OP3_SHIFT) |
-			         (FIR_OP_CW1 << FIR_OP4_SHIFT));
+				 (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+				 (FIR_OP_CA  << FIR_OP1_SHIFT) |
+				 (FIR_OP_PA  << FIR_OP2_SHIFT) |
+				 (FIR_OP_WB  << FIR_OP3_SHIFT) |
+				 (FIR_OP_CW1 << FIR_OP4_SHIFT));
 		} else {
 			fcr = (NAND_CMD_PAGEPROG << FCR_CMD1_SHIFT) |
 			      (NAND_CMD_SEQIN << FCR_CMD2_SHIFT);
 
 			out_be32(&lbc->fir,
-			         (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-			         (FIR_OP_CM2 << FIR_OP1_SHIFT) |
-			         (FIR_OP_CA  << FIR_OP2_SHIFT) |
-			         (FIR_OP_PA  << FIR_OP3_SHIFT) |
-			         (FIR_OP_WB  << FIR_OP4_SHIFT) |
-			         (FIR_OP_CW1 << FIR_OP5_SHIFT));
+				 (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+				 (FIR_OP_CM2 << FIR_OP1_SHIFT) |
+				 (FIR_OP_CA  << FIR_OP2_SHIFT) |
+				 (FIR_OP_PA  << FIR_OP3_SHIFT) |
+				 (FIR_OP_WB  << FIR_OP4_SHIFT) |
+				 (FIR_OP_CW1 << FIR_OP5_SHIFT));
 
 			if (column >= mtd->writesize) {
 				/* OOB area --> READOOB */
@@ -430,7 +430,7 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
 			fsl_elbc_run_command(mtd);
 
 			memcpy_fromio(ctrl->oob_poi + 6,
-			              &ctrl->addr[ctrl->index], 3);
+				      &ctrl->addr[ctrl->index], 3);
 			ctrl->index += 3;
 		}
 
@@ -442,8 +442,8 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
 	/* Note - it does not wait for the ready line */
 	case NAND_CMD_STATUS:
 		out_be32(&lbc->fir,
-		         (FIR_OP_CM0 << FIR_OP0_SHIFT) |
-		         (FIR_OP_RBW << FIR_OP1_SHIFT));
+			 (FIR_OP_CM0 << FIR_OP0_SHIFT) |
+			 (FIR_OP_RBW << FIR_OP1_SHIFT));
 		out_be32(&lbc->fcr, NAND_CMD_STATUS << FCR_CMD0_SHIFT);
 		out_be32(&lbc->fbcr, 1);
 		set_addr(mtd, 0, 0, 0);
@@ -467,7 +467,7 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
 
 	default:
 		printf("fsl_elbc_cmdfunc: error, unsupported command 0x%x.\n",
-		        command);
+			command);
 	}
 }
 
@@ -559,7 +559,7 @@ static void fsl_elbc_read_buf(struct mtd_info *mtd, u8 *buf, int len)
  * Verify buffer against the FCM Controller Data Buffer
  */
 static int fsl_elbc_verify_buf(struct mtd_info *mtd,
-                               const u_char *buf, int len)
+			       const u_char *buf, int len)
 {
 	struct nand_chip *chip = mtd->priv;
 	struct fsl_elbc_mtd *priv = chip->priv;
@@ -603,8 +603,8 @@ static int fsl_elbc_wait(struct mtd_info *mtd, struct nand_chip *chip)
 	/* Use READ_STATUS command, but wait for the device to be ready */
 	ctrl->use_mdr = 0;
 	out_be32(&lbc->fir,
-	         (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-	         (FIR_OP_RBW << FIR_OP1_SHIFT));
+		 (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+		 (FIR_OP_RBW << FIR_OP1_SHIFT));
 	out_be32(&lbc->fcr, NAND_CMD_STATUS << FCR_CMD0_SHIFT);
 	out_be32(&lbc->fbcr, 1);
 	set_addr(mtd, 0, 0, 0);
@@ -623,8 +623,8 @@ static int fsl_elbc_wait(struct mtd_info *mtd, struct nand_chip *chip)
 }
 
 static int fsl_elbc_read_page(struct mtd_info *mtd,
-                              struct nand_chip *chip,
-                              uint8_t *buf)
+			      struct nand_chip *chip,
+			      uint8_t *buf)
 {
 	fsl_elbc_read_buf(mtd, buf, mtd->writesize);
 	fsl_elbc_read_buf(mtd, chip->oob_poi, mtd->oobsize);
@@ -639,8 +639,8 @@ static int fsl_elbc_read_page(struct mtd_info *mtd,
  * waitfunc.
  */
 static void fsl_elbc_write_page(struct mtd_info *mtd,
-                                struct nand_chip *chip,
-                                const uint8_t *buf)
+				struct nand_chip *chip,
+				const uint8_t *buf)
 {
 	struct fsl_elbc_mtd *priv = chip->priv;
 	struct fsl_elbc_ctrl *ctrl = priv->ctrl;
@@ -737,8 +737,8 @@ int board_nand_init(struct nand_chip *nand)
 		nand->ecc.mode = NAND_ECC_HW;
 
 		nand->ecc.layout = (priv->fmr & FMR_ECCM) ?
-		                   &fsl_elbc_oob_sp_eccm1 :
-		                   &fsl_elbc_oob_sp_eccm0;
+				   &fsl_elbc_oob_sp_eccm1 :
+				   &fsl_elbc_oob_sp_eccm0;
 
 		nand->ecc.size = 512;
 		nand->ecc.bytes = 3;
@@ -758,8 +758,8 @@ int board_nand_init(struct nand_chip *nand)
 		if ((br & BR_DECC) == BR_DECC_CHK_GEN) {
 			nand->ecc.steps = 4;
 			nand->ecc.layout = (priv->fmr & FMR_ECCM) ?
-			                   &fsl_elbc_oob_lp_eccm1 :
-			                   &fsl_elbc_oob_lp_eccm0;
+					   &fsl_elbc_oob_lp_eccm1 :
+					   &fsl_elbc_oob_lp_eccm0;
 		}
 	}
 
diff --git a/drivers/mtd/nand/nand_util.c b/drivers/mtd/nand/nand_util.c
index 22820d5..52b3d21 100644
--- a/drivers/mtd/nand/nand_util.c
+++ b/drivers/mtd/nand/nand_util.c
@@ -435,7 +435,7 @@ int nand_unlock(nand_info_t *meminfo, ulong start, ulong length)
  * @return image length including bad blocks
  */
 static size_t get_len_incl_bad (nand_info_t *nand, size_t offset,
-                                const size_t length)
+				const size_t length)
 {
 	size_t len_incl_bad = 0;
 	size_t len_excl_bad = 0;
@@ -472,7 +472,7 @@ static size_t get_len_incl_bad (nand_info_t *nand, size_t offset,
  * @return		0 in case of success
  */
 int nand_write_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
-                        u_char *buffer)
+			u_char *buffer)
 {
 	int rval;
 	size_t left_to_write = *length;
@@ -497,7 +497,7 @@ int nand_write_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
 		rval = nand_write (nand, offset, length, buffer);
 		if (rval != 0) {
 			printf ("NAND write to offset %x failed %d\n",
-			        offset, rval);
+				offset, rval);
 			return rval;
 		}
 	}
@@ -521,7 +521,7 @@ int nand_write_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
 		rval = nand_write (nand, offset, &write_size, p_buffer);
 		if (rval != 0) {
 			printf ("NAND write to offset %x failed %d\n",
-			        offset, rval);
+				offset, rval);
 			*length -= left_to_write;
 			return rval;
 		}
@@ -567,7 +567,7 @@ int nand_read_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
 		rval = nand_read (nand, offset, length, buffer);
 		if (rval != 0) {
 			printf ("NAND read from offset %x failed %d\n",
-			        offset, rval);
+				offset, rval);
 			return rval;
 		}
 	}
@@ -591,7 +591,7 @@ int nand_read_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
 		rval = nand_read (nand, offset, &read_length, p_buffer);
 		if (rval != 0) {
 			printf ("NAND read from offset %x failed %d\n",
-			        offset, rval);
+				offset, rval);
 			*length -= left_to_read;
 			return rval;
 		}
diff --git a/drivers/mtd/onenand/onenand_base.c b/drivers/mtd/onenand/onenand_base.c
index 8f12fa2..9ce68e1 100644
--- a/drivers/mtd/onenand/onenand_base.c
+++ b/drivers/mtd/onenand/onenand_base.c
@@ -292,13 +292,13 @@ static int onenand_wait(struct mtd_info *mtd, int state)
 
 	if (ctrl & ONENAND_CTRL_ERROR) {
 		MTDDEBUG (MTD_DEBUG_LEVEL0,
-		          "onenand_wait: controller error = 0x%04x\n", ctrl);
+			  "onenand_wait: controller error = 0x%04x\n", ctrl);
 		return -EAGAIN;
 	}
 
 	if (ctrl & ONENAND_CTRL_LOCK) {
 		MTDDEBUG (MTD_DEBUG_LEVEL0,
-		          "onenand_wait: it's locked error = 0x%04x\n", ctrl);
+			  "onenand_wait: it's locked error = 0x%04x\n", ctrl);
 		return -EIO;
 	}
 
@@ -306,7 +306,7 @@ static int onenand_wait(struct mtd_info *mtd, int state)
 		ecc = this->read_word(this->base + ONENAND_REG_ECC_STATUS);
 		if (ecc & ONENAND_ECC_2BIT_ALL) {
 			MTDDEBUG (MTD_DEBUG_LEVEL0,
-			          "onenand_wait: ECC error = 0x%04x\n", ecc);
+				  "onenand_wait: ECC error = 0x%04x\n", ecc);
 			return -EBADMSG;
 		}
 	}
@@ -487,7 +487,7 @@ static int onenand_update_bufferram(struct mtd_info *mtd, loff_t addr,
  * Invalidate BufferRAM information
  */
 static void onenand_invalidate_bufferram(struct mtd_info *mtd, loff_t addr,
-                                         unsigned int len)
+					 unsigned int len)
 {
 	struct onenand_chip *this = mtd->priv;
 	int i;
@@ -547,13 +547,13 @@ static int onenand_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
 	int ret = 0;
 
 	MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_read_ecc: "
-	          "from = 0x%08x, len = %i\n",
-	          (unsigned int)from, (int)len);
+		  "from = 0x%08x, len = %i\n",
+		  (unsigned int)from, (int)len);
 
 	/* Do not allow reads past end of device */
 	if ((from + len) > mtd->size) {
 		MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_read_ecc: "
-		          "Attempt read beyond end of device\n");
+			  "Attempt read beyond end of device\n");
 		*retlen = 0;
 		return -EINVAL;
 	}
@@ -585,7 +585,7 @@ static int onenand_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
 
 		if (ret) {
 			MTDDEBUG (MTD_DEBUG_LEVEL0,
-			          "onenand_read_ecc: read failed = %d\n", ret);
+				  "onenand_read_ecc: read failed = %d\n", ret);
 			break;
 		}
 
@@ -639,8 +639,8 @@ int onenand_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
 	int ret = 0;
 
 	MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_read_oob: "
-	          "from = 0x%08x, len = %i\n",
-	          (unsigned int)from, (int)len);
+		  "from = 0x%08x, len = %i\n",
+		  (unsigned int)from, (int)len);
 
 	/* Initialize return length value */
 	*retlen = 0;
@@ -648,7 +648,7 @@ int onenand_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
 	/* Do not allow reads past end of device */
 	if (unlikely((from + len) > mtd->size)) {
 		MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_read_oob: "
-		          "Attempt read beyond end of device\n");
+			  "Attempt read beyond end of device\n");
 		return -EINVAL;
 	}
 
@@ -677,7 +677,7 @@ int onenand_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
 
 		if (ret) {
 			MTDDEBUG (MTD_DEBUG_LEVEL0,
-			          "onenand_read_oob: read failed = %d\n", ret);
+				  "onenand_read_oob: read failed = %d\n", ret);
 			break;
 		}
 
@@ -756,8 +756,8 @@ static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
 	int ret = 0;
 
 	MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_write_ecc: "
-	          "to = 0x%08x, len = %i\n",
-	          (unsigned int)to, (int)len);
+		  "to = 0x%08x, len = %i\n",
+		  (unsigned int)to, (int)len);
 
 	/* Initialize retlen, in case of early exit */
 	*retlen = 0;
@@ -765,14 +765,14 @@ static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
 	/* Do not allow writes past end of device */
 	if (unlikely((to + len) > mtd->size)) {
 		MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_write_ecc: "
-		          "Attempt write to past end of device\n");
+			  "Attempt write to past end of device\n");
 		return -EINVAL;
 	}
 
 	/* Reject writes, which are not page aligned */
 	if (unlikely(NOTALIGNED(to)) || unlikely(NOTALIGNED(len))) {
 		MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_write_ecc: "
-		          "Attempt to write not page aligned data\n");
+			  "Attempt to write not page aligned data\n");
 		return -EINVAL;
 	}
 
@@ -796,7 +796,7 @@ static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
 		ret = this->wait(mtd, FL_WRITING);
 		if (ret) {
 			MTDDEBUG (MTD_DEBUG_LEVEL0,
-			          "onenand_write_ecc: write filaed %d\n", ret);
+				  "onenand_write_ecc: write filaed %d\n", ret);
 			break;
 		}
 
@@ -806,7 +806,7 @@ static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
 		ret = onenand_verify_page(mtd, (u_char *) buf, to);
 		if (ret) {
 			MTDDEBUG (MTD_DEBUG_LEVEL0,
-			          "onenand_write_ecc: verify failed %d\n", ret);
+				  "onenand_write_ecc: verify failed %d\n", ret);
 			break;
 		}
 
@@ -860,8 +860,8 @@ int onenand_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
 	int written = 0;
 
 	MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_write_oob: "
-	          "to = 0x%08x, len = %i\n",
-	          (unsigned int)to, (int)len);
+		  "to = 0x%08x, len = %i\n",
+		  (unsigned int)to, (int)len);
 
 	/* Initialize retlen, in case of early exit */
 	*retlen = 0;
@@ -869,7 +869,7 @@ int onenand_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
 	/* Do not allow writes past end of device */
 	if (unlikely((to + len) > mtd->size)) {
 		MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_write_oob: "
-		          "Attempt write to past end of device\n");
+			  "Attempt write to past end of device\n");
 		return -EINVAL;
 	}
 
@@ -948,28 +948,28 @@ int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
 	int ret = 0;
 
 	MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_erase: start = 0x%08x, len = %i\n",
-	          (unsigned int)instr->addr, (unsigned int)instr->len);
+		  (unsigned int)instr->addr, (unsigned int)instr->len);
 
 	block_size = (1 << this->erase_shift);
 
 	/* Start address must align on block boundary */
 	if (unlikely(instr->addr & (block_size - 1))) {
 		MTDDEBUG (MTD_DEBUG_LEVEL0,
-		          "onenand_erase: Unaligned address\n");
+			  "onenand_erase: Unaligned address\n");
 		return -EINVAL;
 	}
 
 	/* Length must align on block boundary */
 	if (unlikely(instr->len & (block_size - 1))) {
 		MTDDEBUG (MTD_DEBUG_LEVEL0,
-		          "onenand_erase: Length not block aligned\n");
+			  "onenand_erase: Length not block aligned\n");
 		return -EINVAL;
 	}
 
 	/* Do not allow erase past end of device */
 	if (unlikely((instr->len + instr->addr) > mtd->size)) {
 		MTDDEBUG (MTD_DEBUG_LEVEL0,
-		          "onenand_erase: Erase past end of device\n");
+			  "onenand_erase: Erase past end of device\n");
 		return -EINVAL;
 	}
 
@@ -997,11 +997,11 @@ int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
 		if (ret) {
 			if (ret == -EPERM)
 				MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_erase: "
-				          "Device is write protected!!!\n");
+					  "Device is write protected!!!\n");
 			else
 				MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_erase: "
-				          "Failed erase, block %d\n",
-				          (unsigned)(addr >> this->erase_shift));
+					  "Failed erase, block %d\n",
+					  (unsigned)(addr >> this->erase_shift));
 			instr->state = MTD_ERASE_FAILED;
 			instr->fail_addr = addr;
 			goto erase_exit;