cfi_flash: Fix space between function name and parenthesis
authorMario Six <mario.six@gdsys.cc>
Fri, 26 Jan 2018 13:43:31 +0000 (14:43 +0100)
committerStefan Roese <sr@denx.de>
Mon, 29 Jan 2018 06:48:58 +0000 (07:48 +0100)
There should not be a space between a function name and a parenthesis
("func (...)"). Fix all instances where this occurs.

Signed-off-by: Mario Six <mario.six@gdsys.cc>
Signed-off-by: Stefan Roese <sr@denx.de>
drivers/mtd/cfi_flash.c

index f096e039cbcbdcd03c066e6975561ac3ba787ea4..0dc7f4a6ba1a8a11ba31f9eb17ff8929bd7d356b 100644 (file)
@@ -204,7 +204,7 @@ unsigned long flash_sector_size(flash_info_t *info, flash_sect_t sect)
  * create an address based on the offset and the port width
  */
 static inline void *
-flash_map (flash_info_t * info, flash_sect_t sect, uint offset)
+flash_map(flash_info_t * info, flash_sect_t sect, uint offset)
 {
        unsigned int byte_offset = offset * info->portwidth;
 
@@ -247,17 +247,17 @@ static void flash_make_cmd(flash_info_t *info, u32 cmd, void *cmdbuf)
 /*-----------------------------------------------------------------------
  * Debug support
  */
-static void print_longlong (char *str, unsigned long long data)
+static void print_longlong(char *str, unsigned long long data)
 {
        int i;
        char *cp;
 
        cp = (char *) &data;
        for (i = 0; i < 8; i++)
-               sprintf (&str[i * 2], "%2.2x", *cp++);
+               sprintf(&str[i * 2], "%2.2x", *cp++);
 }
 
-static void flash_printqry (struct cfi_qry *qry)
+static void flash_printqry(struct cfi_qry *qry)
 {
        u8 *p = (u8 *)qry;
        int x, y;
@@ -283,31 +283,31 @@ static void flash_printqry (struct cfi_qry *qry)
 /*-----------------------------------------------------------------------
  * read a character at a port width address
  */
-static inline uchar flash_read_uchar (flash_info_t * info, uint offset)
+static inline uchar flash_read_uchar(flash_info_t * info, uint offset)
 {
        uchar *cp;
        uchar retval;
 
-       cp = flash_map (info, 0, offset);
+       cp = flash_map(info, 0, offset);
 #if defined(__LITTLE_ENDIAN) || defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
        retval = flash_read8(cp);
 #else
        retval = flash_read8(cp + info->portwidth - 1);
 #endif
-       flash_unmap (info, 0, offset, cp);
+       flash_unmap(info, 0, offset, cp);
        return retval;
 }
 
 /*-----------------------------------------------------------------------
  * read a word at a port width address, assume 16bit bus
  */
-static inline ushort flash_read_word (flash_info_t * info, uint offset)
+static inline ushort flash_read_word(flash_info_t * info, uint offset)
 {
        ushort *addr, retval;
 
-       addr = flash_map (info, 0, offset);
-       retval = flash_read16 (addr);
-       flash_unmap (info, 0, offset, addr);
+       addr = flash_map(info, 0, offset);
+       retval = flash_read16(addr);
+       flash_unmap(info, 0, offset, addr);
        return retval;
 }
 
@@ -325,13 +325,13 @@ static ulong flash_read_long (flash_info_t * info, flash_sect_t sect,
 #ifdef DEBUG
        int x;
 #endif
-       addr = flash_map (info, sect, offset);
+       addr = flash_map(info, sect, offset);
 
 #ifdef DEBUG
-       debug ("long addr is at %p info->portwidth = %d\n", addr,
+       debug("long addr is at %p info->portwidth = %d\n", addr,
               info->portwidth);
        for (x = 0; x < 4 * info->portwidth; x++) {
-               debug ("addr[%x] = 0x%x\n", x, flash_read8(addr + x));
+               debug("addr[%x] = 0x%x\n", x, flash_read8(addr + x));
        }
 #endif
 #if defined(__LITTLE_ENDIAN) || defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
@@ -360,22 +360,22 @@ static void flash_write_cmd(flash_info_t *info, flash_sect_t sect,
        void *addr;
        cfiword_t cword;
 
-       addr = flash_map (info, sect, offset);
-       flash_make_cmd (info, cmd, &cword);
+       addr = flash_map(info, sect, offset);
+       flash_make_cmd(info, cmd, &cword);
        switch (info->portwidth) {
        case FLASH_CFI_8BIT:
-               debug ("fwc addr %p cmd %x %x 8bit x %d bit\n", addr, cmd,
+               debug("fwc addr %p cmd %x %x 8bit x %d bit\n", addr, cmd,
                       cword.w8, info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
                flash_write8(cword.w8, addr);
                break;
        case FLASH_CFI_16BIT:
-               debug ("fwc addr %p cmd %x %4.4x 16bit x %d bit\n", addr,
+               debug("fwc addr %p cmd %x %4.4x 16bit x %d bit\n", addr,
                       cmd, cword.w16,
                       info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
                flash_write16(cword.w16, addr);
                break;
        case FLASH_CFI_32BIT:
-               debug ("fwc addr %p cmd %x %8.8x 32bit x %d bit\n", addr,
+               debug("fwc addr %p cmd %x %8.8x 32bit x %d bit\n", addr,
                       cmd, cword.w32,
                       info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
                flash_write32(cword.w32, addr);
@@ -385,9 +385,9 @@ static void flash_write_cmd(flash_info_t *info, flash_sect_t sect,
                {
                        char str[20];
 
-                       print_longlong (str, cword.w64);
+                       print_longlong(str, cword.w64);
 
-                       debug ("fwrite addr %p cmd %x %s 64 bit x %d bit\n",
+                       debug("fwrite addr %p cmd %x %s 64 bit x %d bit\n",
                               addr, cmd, str,
                               info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
                }
@@ -402,36 +402,36 @@ static void flash_write_cmd(flash_info_t *info, flash_sect_t sect,
        flash_unmap(info, sect, offset, addr);
 }
 
-static void flash_unlock_seq (flash_info_t * info, flash_sect_t sect)
+static void flash_unlock_seq(flash_info_t * info, flash_sect_t sect)
 {
-       flash_write_cmd (info, sect, info->addr_unlock1, AMD_CMD_UNLOCK_START);
-       flash_write_cmd (info, sect, info->addr_unlock2, AMD_CMD_UNLOCK_ACK);
+       flash_write_cmd(info, sect, info->addr_unlock1, AMD_CMD_UNLOCK_START);
+       flash_write_cmd(info, sect, info->addr_unlock2, AMD_CMD_UNLOCK_ACK);
 }
 
 /*-----------------------------------------------------------------------
  */
-static int flash_isequal (flash_info_t * info, flash_sect_t sect,
+static int flash_isequal(flash_info_t * info, flash_sect_t sect,
                          uint offset, uchar cmd)
 {
        void *addr;
        cfiword_t cword;
        int retval;
 
-       addr = flash_map (info, sect, offset);
-       flash_make_cmd (info, cmd, &cword);
+       addr = flash_map(info, sect, offset);
+       flash_make_cmd(info, cmd, &cword);
 
-       debug ("is= cmd %x(%c) addr %p ", cmd, cmd, addr);
+       debug("is= cmd %x(%c) addr %p ", cmd, cmd, addr);
        switch (info->portwidth) {
        case FLASH_CFI_8BIT:
-               debug ("is= %x %x\n", flash_read8(addr), cword.w8);
+               debug("is= %x %x\n", flash_read8(addr), cword.w8);
                retval = (flash_read8(addr) == cword.w8);
                break;
        case FLASH_CFI_16BIT:
-               debug ("is= %4.4x %4.4x\n", flash_read16(addr), cword.w16);
+               debug("is= %4.4x %4.4x\n", flash_read16(addr), cword.w16);
                retval = (flash_read16(addr) == cword.w16);
                break;
        case FLASH_CFI_32BIT:
-               debug ("is= %8.8x %8.8x\n", flash_read32(addr), cword.w32);
+               debug("is= %8.8x %8.8x\n", flash_read32(addr), cword.w32);
                retval = (flash_read32(addr) == cword.w32);
                break;
        case FLASH_CFI_64BIT:
@@ -440,9 +440,9 @@ static int flash_isequal (flash_info_t * info, flash_sect_t sect,
                        char str1[20];
                        char str2[20];
 
-                       print_longlong (str1, flash_read64(addr));
-                       print_longlong (str2, cword.w64);
-                       debug ("is= %s %s\n", str1, str2);
+                       print_longlong(str1, flash_read64(addr));
+                       print_longlong(str2, cword.w64);
+                       debug("is= %s %s\n", str1, str2);
                }
 #endif
                retval = (flash_read64(addr) == cword.w64);
@@ -458,15 +458,15 @@ static int flash_isequal (flash_info_t * info, flash_sect_t sect,
 
 /*-----------------------------------------------------------------------
  */
-static int flash_isset (flash_info_t * info, flash_sect_t sect,
+static int flash_isset(flash_info_t * info, flash_sect_t sect,
                        uint offset, uchar cmd)
 {
        void *addr;
        cfiword_t cword;
        int retval;
 
-       addr = flash_map (info, sect, offset);
-       flash_make_cmd (info, cmd, &cword);
+       addr = flash_map(info, sect, offset);
+       flash_make_cmd(info, cmd, &cword);
        switch (info->portwidth) {
        case FLASH_CFI_8BIT:
                retval = ((flash_read8(addr) & cword.w8) == cword.w8);
@@ -491,15 +491,15 @@ static int flash_isset (flash_info_t * info, flash_sect_t sect,
 
 /*-----------------------------------------------------------------------
  */
-static int flash_toggle (flash_info_t * info, flash_sect_t sect,
+static int flash_toggle(flash_info_t * info, flash_sect_t sect,
                         uint offset, uchar cmd)
 {
        void *addr;
        cfiword_t cword;
        int retval;
 
-       addr = flash_map (info, sect, offset);
-       flash_make_cmd (info, cmd, &cword);
+       addr = flash_map(info, sect, offset);
+       flash_make_cmd(info, cmd, &cword);
        switch (info->portwidth) {
        case FLASH_CFI_8BIT:
                retval = flash_read8(addr) != flash_read8(addr);
@@ -529,7 +529,7 @@ static int flash_toggle (flash_info_t * info, flash_sect_t sect,
  * This routine checks the status of the chip and returns true if the
  * chip is busy.
  */
-static int flash_is_busy (flash_info_t * info, flash_sect_t sect)
+static int flash_is_busy(flash_info_t * info, flash_sect_t sect)
 {
        int retval;
 
@@ -537,7 +537,7 @@ static int flash_is_busy (flash_info_t * info, flash_sect_t sect)
        case CFI_CMDSET_INTEL_PROG_REGIONS:
        case CFI_CMDSET_INTEL_STANDARD:
        case CFI_CMDSET_INTEL_EXTENDED:
-               retval = !flash_isset (info, sect, 0, FLASH_STATUS_DONE);
+               retval = !flash_isset(info, sect, 0, FLASH_STATUS_DONE);
                break;
        case CFI_CMDSET_AMD_STANDARD:
        case CFI_CMDSET_AMD_EXTENDED:
@@ -545,12 +545,12 @@ static int flash_is_busy (flash_info_t * info, flash_sect_t sect)
        case CFI_CMDSET_AMD_LEGACY:
 #endif
                if (info->sr_supported) {
-                       flash_write_cmd (info, sect, info->addr_unlock1,
+                       flash_write_cmd(info, sect, info->addr_unlock1,
                                         FLASH_CMD_READ_STATUS);
-                       retval = !flash_isset (info, sect, 0,
+                       retval = !flash_isset(info, sect, 0,
                                               FLASH_STATUS_DONE);
                } else {
-                       retval = flash_toggle (info, sect, 0,
+                       retval = flash_toggle(info, sect, 0,
                                               AMD_STATUS_TOGGLE);
                }
 
@@ -558,7 +558,7 @@ static int flash_is_busy (flash_info_t * info, flash_sect_t sect)
        default:
                retval = 0;
        }
-       debug ("flash_is_busy: %d\n", retval);
+       debug("flash_is_busy: %d\n", retval);
        return retval;
 }
 
@@ -566,7 +566,7 @@ static int flash_is_busy (flash_info_t * info, flash_sect_t sect)
  *  wait for XSR.7 to be set. Time out with an error if it does not.
  *  This routine does not set the flash to read-array mode.
  */
-static int flash_status_check (flash_info_t * info, flash_sect_t sector,
+static int flash_status_check(flash_info_t * info, flash_sect_t sector,
                               ulong tout, char *prompt)
 {
        ulong start;
@@ -582,18 +582,18 @@ static int flash_status_check (flash_info_t * info, flash_sect_t sector,
 #ifdef CONFIG_SYS_LOW_RES_TIMER
        reset_timer();
 #endif
-       start = get_timer (0);
+       start = get_timer(0);
        WATCHDOG_RESET();
-       while (flash_is_busy (info, sector)) {
-               if (get_timer (start) > tout) {
-                       printf ("Flash %s timeout at address %lx data %lx\n",
+       while (flash_is_busy(info, sector)) {
+               if (get_timer(start) > tout) {
+                       printf("Flash %s timeout at address %lx data %lx\n",
                                prompt, info->start[sector],
-                               flash_read_long (info, sector, 0));
-                       flash_write_cmd (info, sector, 0, info->cmd_reset);
+                               flash_read_long(info, sector, 0));
+                       flash_write_cmd(info, sector, 0, info->cmd_reset);
                        udelay(1);
                        return ERR_TIMOUT;
                }
-               udelay (1);             /* also triggers watchdog */
+               udelay(1);              /* also triggers watchdog */
        }
        return ERR_OK;
 }
@@ -604,12 +604,12 @@ static int flash_status_check (flash_info_t * info, flash_sect_t sector,
  *
  * This routine sets the flash to read-array mode.
  */
-static int flash_full_status_check (flash_info_t * info, flash_sect_t sector,
+static int flash_full_status_check(flash_info_t * info, flash_sect_t sector,
                                    ulong tout, char *prompt)
 {
        int retcode;
 
-       retcode = flash_status_check (info, sector, tout, prompt);
+       retcode = flash_status_check(info, sector, tout, prompt);
        switch (info->vendor) {
        case CFI_CMDSET_INTEL_PROG_REGIONS:
        case CFI_CMDSET_INTEL_EXTENDED:
@@ -617,27 +617,27 @@ static int flash_full_status_check (flash_info_t * info, flash_sect_t sector,
                if ((retcode == ERR_OK)
                    && !flash_isset(info, sector, 0, FLASH_STATUS_DONE)) {
                        retcode = ERR_INVAL;
-                       printf ("Flash %s error at address %lx\n", prompt,
+                       printf("Flash %s error at address %lx\n", prompt,
                                info->start[sector]);
-                       if (flash_isset (info, sector, 0, FLASH_STATUS_ECLBS |
+                       if (flash_isset(info, sector, 0, FLASH_STATUS_ECLBS |
                                         FLASH_STATUS_PSLBS)) {
-                               puts ("Command Sequence Error.\n");
-                       } else if (flash_isset (info, sector, 0,
+                               puts("Command Sequence Error.\n");
+                       } else if (flash_isset(info, sector, 0,
                                                FLASH_STATUS_ECLBS)) {
-                               puts ("Block Erase Error.\n");
+                               puts("Block Erase Error.\n");
                                retcode = ERR_NOT_ERASED;
-                       } else if (flash_isset (info, sector, 0,
+                       } else if (flash_isset(info, sector, 0,
                                                FLASH_STATUS_PSLBS)) {
-                               puts ("Locking Error\n");
+                               puts("Locking Error\n");
                        }
-                       if (flash_isset (info, sector, 0, FLASH_STATUS_DPS)) {
-                               puts ("Block locked.\n");
+                       if (flash_isset(info, sector, 0, FLASH_STATUS_DPS)) {
+                               puts("Block locked.\n");
                                retcode = ERR_PROTECTED;
                        }
-                       if (flash_isset (info, sector, 0, FLASH_STATUS_VPENS))
-                               puts ("Vpp Low Error.\n");
+                       if (flash_isset(info, sector, 0, FLASH_STATUS_VPENS))
+                               puts("Vpp Low Error.\n");
                }
-               flash_write_cmd (info, sector, 0, info->cmd_reset);
+               flash_write_cmd(info, sector, 0, info->cmd_reset);
                udelay(1);
                break;
        default:
@@ -709,7 +709,7 @@ static int flash_status_poll(flash_info_t *info, void *src, void *dst,
 
 /*-----------------------------------------------------------------------
  */
-static void flash_add_byte (flash_info_t * info, cfiword_t * cword, uchar c)
+static void flash_add_byte(flash_info_t * info, cfiword_t * cword, uchar c)
 {
 #if defined(__LITTLE_ENDIAN) && !defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
        unsigned short  w;
@@ -755,7 +755,7 @@ static void flash_add_byte (flash_info_t * info, cfiword_t * cword, uchar c)
  * Loop through the sector table starting from the previously found sector.
  * Searches forwards or backwards, dependent on the passed address.
  */
-static flash_sect_t find_sector (flash_info_t * info, ulong addr)
+static flash_sect_t find_sector(flash_info_t * info, ulong addr)
 {
        static flash_sect_t saved_sector; /* previously found sector */
        static flash_info_t *saved_info; /* previously used flash bank */
@@ -781,7 +781,7 @@ static flash_sect_t find_sector (flash_info_t * info, ulong addr)
 
 /*-----------------------------------------------------------------------
  */
-static int flash_write_cfiword (flash_info_t * info, ulong dest,
+static int flash_write_cfiword(flash_info_t * info, ulong dest,
                                cfiword_t cword)
 {
        void *dstaddr = (void *)dest;
@@ -811,27 +811,27 @@ static int flash_write_cfiword (flash_info_t * info, ulong dest,
                return ERR_NOT_ERASED;
 
        /* Disable interrupts which might cause a timeout here */
-       flag = disable_interrupts ();
+       flag = disable_interrupts();
 
        switch (info->vendor) {
        case CFI_CMDSET_INTEL_PROG_REGIONS:
        case CFI_CMDSET_INTEL_EXTENDED:
        case CFI_CMDSET_INTEL_STANDARD:
-               flash_write_cmd (info, 0, 0, FLASH_CMD_CLEAR_STATUS);
-               flash_write_cmd (info, 0, 0, FLASH_CMD_WRITE);
+               flash_write_cmd(info, 0, 0, FLASH_CMD_CLEAR_STATUS);
+               flash_write_cmd(info, 0, 0, FLASH_CMD_WRITE);
                break;
        case CFI_CMDSET_AMD_EXTENDED:
        case CFI_CMDSET_AMD_STANDARD:
                sect = find_sector(info, dest);
-               flash_unlock_seq (info, sect);
-               flash_write_cmd (info, sect, info->addr_unlock1, AMD_CMD_WRITE);
+               flash_unlock_seq(info, sect);
+               flash_write_cmd(info, sect, info->addr_unlock1, AMD_CMD_WRITE);
                sect_found = 1;
                break;
 #ifdef CONFIG_FLASH_CFI_LEGACY
        case CFI_CMDSET_AMD_LEGACY:
                sect = find_sector(info, dest);
-               flash_unlock_seq (info, 0);
-               flash_write_cmd (info, 0, info->addr_unlock1, AMD_CMD_WRITE);
+               flash_unlock_seq(info, 0);
+               flash_write_cmd(info, 0, info->addr_unlock1, AMD_CMD_WRITE);
                sect_found = 1;
                break;
 #endif
@@ -854,10 +854,10 @@ static int flash_write_cfiword (flash_info_t * info, ulong dest,
 
        /* re-enable interrupts if necessary */
        if (flag)
-               enable_interrupts ();
+               enable_interrupts();
 
        if (!sect_found)
-               sect = find_sector (info, dest);
+               sect = find_sector(info, dest);
 
        if (use_flash_status_poll(info))
                return flash_status_poll(info, &cword, dstaddr,
@@ -869,7 +869,7 @@ static int flash_write_cfiword (flash_info_t * info, ulong dest,
 
 #ifdef CONFIG_SYS_FLASH_USE_BUFFER_WRITE
 
-static int flash_write_cfibuffer (flash_info_t * info, ulong dest, uchar * cp,
+static int flash_write_cfibuffer(flash_info_t * info, ulong dest, uchar * cp,
                                  int len)
 {
        flash_sect_t sector;
@@ -933,7 +933,7 @@ static int flash_write_cfibuffer (flash_info_t * info, ulong dest, uchar * cp,
        }
 
        src = cp;
-       sector = find_sector (info, dest);
+       sector = find_sector(info, dest);
 
        switch (info->vendor) {
        case CFI_CMDSET_INTEL_PROG_REGIONS:
@@ -941,17 +941,17 @@ static int flash_write_cfibuffer (flash_info_t * info, ulong dest, uchar * cp,
        case CFI_CMDSET_INTEL_EXTENDED:
                write_cmd = (info->vendor == CFI_CMDSET_INTEL_PROG_REGIONS) ?
                                        FLASH_CMD_WRITE_BUFFER_PROG : FLASH_CMD_WRITE_TO_BUFFER;
-               flash_write_cmd (info, sector, 0, FLASH_CMD_CLEAR_STATUS);
-               flash_write_cmd (info, sector, 0, FLASH_CMD_READ_STATUS);
-               flash_write_cmd (info, sector, 0, write_cmd);
-               retcode = flash_status_check (info, sector,
+               flash_write_cmd(info, sector, 0, FLASH_CMD_CLEAR_STATUS);
+               flash_write_cmd(info, sector, 0, FLASH_CMD_READ_STATUS);
+               flash_write_cmd(info, sector, 0, write_cmd);
+               retcode = flash_status_check(info, sector,
                                              info->buffer_write_tout,
                                              "write to buffer");
                if (retcode == ERR_OK) {
                        /* reduce the number of loops by the width of
                         * the port */
                        cnt = len >> shift;
-                       flash_write_cmd (info, sector, 0, cnt - 1);
+                       flash_write_cmd(info, sector, 0, cnt - 1);
                        while (cnt-- > 0) {
                                switch (info->portwidth) {
                                case FLASH_CFI_8BIT:
@@ -975,9 +975,9 @@ static int flash_write_cfibuffer (flash_info_t * info, ulong dest, uchar * cp,
                                        goto out_unmap;
                                }
                        }
-                       flash_write_cmd (info, sector, 0,
+                       flash_write_cmd(info, sector, 0,
                                         FLASH_CMD_WRITE_BUFFER_CONFIRM);
-                       retcode = flash_full_status_check (
+                       retcode = flash_full_status_check(
                                info, sector, info->buffer_write_tout,
                                "buffer write");
                }
@@ -1025,7 +1025,7 @@ static int flash_write_cfibuffer (flash_info_t * info, ulong dest, uchar * cp,
                        goto out_unmap;
                }
 
-               flash_write_cmd (info, sector, 0, AMD_CMD_WRITE_BUFFER_CONFIRM);
+               flash_write_cmd(info, sector, 0, AMD_CMD_WRITE_BUFFER_CONFIRM);
                if (use_flash_status_poll(info))
                        retcode = flash_status_poll(info, src - (1 << shift),
                                                    dst - (1 << shift),
@@ -1038,7 +1038,7 @@ static int flash_write_cfibuffer (flash_info_t * info, ulong dest, uchar * cp,
                break;
 
        default:
-               debug ("Unknown Command Set\n");
+               debug("Unknown Command Set\n");
                retcode = ERR_INVAL;
                break;
        }
@@ -1051,7 +1051,7 @@ out_unmap:
 
 /*-----------------------------------------------------------------------
  */
-int flash_erase (flash_info_t * info, int s_first, int s_last)
+int flash_erase(flash_info_t * info, int s_first, int s_last)
 {
        int rcode = 0;
        int prot;
@@ -1059,11 +1059,11 @@ int flash_erase (flash_info_t * info, int s_first, int s_last)
        int st;
 
        if (info->flash_id != FLASH_MAN_CFI) {
-               puts ("Can't erase unknown flash type - aborted\n");
+               puts("Can't erase unknown flash type - aborted\n");
                return 1;
        }
        if ((s_first < 0) || (s_first > s_last)) {
-               puts ("- no sectors to erase\n");
+               puts("- no sectors to erase\n");
                return 1;
        }
 
@@ -1074,10 +1074,10 @@ int flash_erase (flash_info_t * info, int s_first, int s_last)
                }
        }
        if (prot) {
-               printf ("- Warning: %d protected sectors will not be erased!\n",
+               printf("- Warning: %d protected sectors will not be erased!\n",
                        prot);
        } else if (flash_verbose) {
-               putc ('\n');
+               putc('\n');
        }
 
 
@@ -1118,35 +1118,35 @@ int flash_erase (flash_info_t * info, int s_first, int s_last)
                        case CFI_CMDSET_INTEL_PROG_REGIONS:
                        case CFI_CMDSET_INTEL_STANDARD:
                        case CFI_CMDSET_INTEL_EXTENDED:
-                               flash_write_cmd (info, sect, 0,
+                               flash_write_cmd(info, sect, 0,
                                                 FLASH_CMD_CLEAR_STATUS);
-                               flash_write_cmd (info, sect, 0,
+                               flash_write_cmd(info, sect, 0,
                                                 FLASH_CMD_BLOCK_ERASE);
-                               flash_write_cmd (info, sect, 0,
+                               flash_write_cmd(info, sect, 0,
                                                 FLASH_CMD_ERASE_CONFIRM);
                                break;
                        case CFI_CMDSET_AMD_STANDARD:
                        case CFI_CMDSET_AMD_EXTENDED:
-                               flash_unlock_seq (info, sect);
-                               flash_write_cmd (info, sect,
+                               flash_unlock_seq(info, sect);
+                               flash_write_cmd(info, sect,
                                                info->addr_unlock1,
                                                AMD_CMD_ERASE_START);
-                               flash_unlock_seq (info, sect);
-                               flash_write_cmd (info, sect, 0,
+                               flash_unlock_seq(info, sect);
+                               flash_write_cmd(info, sect, 0,
                                                 info->cmd_erase_sector);
                                break;
 #ifdef CONFIG_FLASH_CFI_LEGACY
                        case CFI_CMDSET_AMD_LEGACY:
-                               flash_unlock_seq (info, 0);
-                               flash_write_cmd (info, 0, info->addr_unlock1,
+                               flash_unlock_seq(info, 0);
+                               flash_write_cmd(info, 0, info->addr_unlock1,
                                                AMD_CMD_ERASE_START);
-                               flash_unlock_seq (info, 0);
-                               flash_write_cmd (info, sect, 0,
+                               flash_unlock_seq(info, 0);
+                               flash_write_cmd(info, sect, 0,
                                                AMD_CMD_ERASE_SECTOR);
                                break;
 #endif
                        default:
-                               debug ("Unkown flash vendor %d\n",
+                               debug("Unkown flash vendor %d\n",
                                       info->vendor);
                                break;
                        }
@@ -1166,12 +1166,12 @@ int flash_erase (flash_info_t * info, int s_first, int s_last)
                        if (st)
                                rcode = 1;
                        else if (flash_verbose)
-                               putc ('.');
+                               putc('.');
                }
        }
 
        if (flash_verbose)
-               puts (" done\n");
+               puts(" done\n");
 
        return rcode;
 }
@@ -1200,53 +1200,53 @@ static int sector_erased(flash_info_t *info, int i)
 }
 #endif /* CONFIG_SYS_FLASH_EMPTY_INFO */
 
-void flash_print_info (flash_info_t * info)
+void flash_print_info(flash_info_t * info)
 {
        int i;
 
        if (info->flash_id != FLASH_MAN_CFI) {
-               puts ("missing or unknown FLASH type\n");
+               puts("missing or unknown FLASH type\n");
                return;
        }
 
-       printf ("%s flash (%d x %d)",
+       printf("%s flash (%d x %d)",
                info->name,
                (info->portwidth << 3), (info->chipwidth << 3));
        if (info->size < 1024*1024)
-               printf ("  Size: %ld kB in %d Sectors\n",
+               printf("  Size: %ld kB in %d Sectors\n",
                        info->size >> 10, info->sector_count);
        else
-               printf ("  Size: %ld MB in %d Sectors\n",
+               printf("  Size: %ld MB in %d Sectors\n",
                        info->size >> 20, info->sector_count);
-       printf ("  ");
+       printf("  ");
        switch (info->vendor) {
                case CFI_CMDSET_INTEL_PROG_REGIONS:
-                       printf ("Intel Prog Regions");
+                       printf("Intel Prog Regions");
                        break;
                case CFI_CMDSET_INTEL_STANDARD:
-                       printf ("Intel Standard");
+                       printf("Intel Standard");
                        break;
                case CFI_CMDSET_INTEL_EXTENDED:
-                       printf ("Intel Extended");
+                       printf("Intel Extended");
                        break;
                case CFI_CMDSET_AMD_STANDARD:
-                       printf ("AMD Standard");
+                       printf("AMD Standard");
                        break;
                case CFI_CMDSET_AMD_EXTENDED:
-                       printf ("AMD Extended");
+                       printf("AMD Extended");
                        break;
 #ifdef CONFIG_FLASH_CFI_LEGACY
                case CFI_CMDSET_AMD_LEGACY:
-                       printf ("AMD Legacy");
+                       printf("AMD Legacy");
                        break;
 #endif
                default:
-                       printf ("Unknown (%d)", info->vendor);
+                       printf("Unknown (%d)", info->vendor);
                        break;
        }
-       printf (" command set, Manufacturer ID: 0x%02X, Device ID: 0x",
+       printf(" command set, Manufacturer ID: 0x%02X, Device ID: 0x",
                info->manufacturer_id);
-       printf (info->chipwidth == FLASH_CFI_16BIT ? "%04X" : "%02X",
+       printf(info->chipwidth == FLASH_CFI_16BIT ? "%04X" : "%02X",
                info->device_id);
        if ((info->device_id & 0xff) == 0x7E) {
                printf(info->chipwidth == FLASH_CFI_16BIT ? "%04X" : "%02X",
@@ -1254,17 +1254,17 @@ void flash_print_info (flash_info_t * info)
        }
        if ((info->vendor == CFI_CMDSET_AMD_STANDARD) && (info->legacy_unlock))
                printf("\n  Advanced Sector Protection (PPB) enabled");
-       printf ("\n  Erase timeout: %ld ms, write timeout: %ld ms\n",
+       printf("\n  Erase timeout: %ld ms, write timeout: %ld ms\n",
                info->erase_blk_tout,
                info->write_tout);
        if (info->buffer_size > 1) {
-               printf ("  Buffer write timeout: %ld ms, "
+               printf("  Buffer write timeout: %ld ms, "
                        "buffer size: %d bytes\n",
                info->buffer_write_tout,
                info->buffer_size);
        }
 
-       puts ("\n  Sector Start Addresses:");
+       puts("\n  Sector Start Addresses:");
        for (i = 0; i < info->sector_count; ++i) {
                if (ctrlc())
                        break;
@@ -1272,17 +1272,17 @@ void flash_print_info (flash_info_t * info)
                        putc('\n');
 #ifdef CONFIG_SYS_FLASH_EMPTY_INFO
                /* print empty and read-only info */
-               printf ("  %08lX %c %s ",
+               printf("  %08lX %c %s ",
                        info->start[i],
                        sector_erased(info, i) ? 'E' : ' ',
                        info->protect[i] ? "RO" : "  ");
 #else  /* ! CONFIG_SYS_FLASH_EMPTY_INFO */
-               printf ("  %08lX   %s ",
+               printf("  %08lX   %s ",
                        info->start[i],
                        info->protect[i] ? "RO" : "  ");
 #endif
        }
-       putc ('\n');
+       putc('\n');
        return;
 }
 
@@ -1298,9 +1298,9 @@ void flash_print_info (flash_info_t * info)
                dots -= dots_sub; \
                if ((scale > 0) && (dots <= 0)) { \
                        if ((digit % 5) == 0) \
-                               printf ("%d", digit / 5); \
+                               printf("%d", digit / 5); \
                        else \
-                               putc ('.'); \
+                               putc('.'); \
                        digit--; \
                        dots += scale; \
                } \
@@ -1315,7 +1315,7 @@ void flash_print_info (flash_info_t * info)
  * 1 - write timeout
  * 2 - Flash not erased
  */
-int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
+int write_buff(flash_info_t * info, uchar * src, ulong addr, ulong cnt)
 {
        ulong wp;
        uchar *p;
@@ -1347,16 +1347,16 @@ int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
                cword.w32 = 0;
                p = (uchar *)wp;
                for (i = 0; i < aln; ++i)
-                       flash_add_byte (info, &cword, flash_read8(p + i));
+                       flash_add_byte(info, &cword, flash_read8(p + i));
 
                for (; (i < info->portwidth) && (cnt > 0); i++) {
-                       flash_add_byte (info, &cword, *src++);
+                       flash_add_byte(info, &cword, *src++);
                        cnt--;
                }
                for (; (cnt == 0) && (i < info->portwidth); ++i)
-                       flash_add_byte (info, &cword, flash_read8(p + i));
+                       flash_add_byte(info, &cword, flash_read8(p + i));
 
-               rc = flash_write_cfiword (info, wp, cword);
+               rc = flash_write_cfiword(info, wp, cword);
                if (rc != 0)
                        return rc;
 
@@ -1373,8 +1373,8 @@ int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
                if (info->buffer_size == 1) {
                        cword.w32 = 0;
                        for (i = 0; i < info->portwidth; i++)
-                               flash_add_byte (info, &cword, *src++);
-                       if ((rc = flash_write_cfiword (info, wp, cword)) != 0)
+                               flash_add_byte(info, &cword, *src++);
+                       if ((rc = flash_write_cfiword(info, wp, cword)) != 0)
                                return rc;
                        wp += info->portwidth;
                        cnt -= info->portwidth;
@@ -1385,7 +1385,7 @@ int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
                i = buffered_size - (wp % buffered_size);
                if (i > cnt)
                        i = cnt;
-               if ((rc = flash_write_cfibuffer (info, wp, src, i)) != ERR_OK)
+               if ((rc = flash_write_cfibuffer(info, wp, src, i)) != ERR_OK)
                        return rc;
                i -= i & (info->portwidth - 1);
                wp += i;
@@ -1400,9 +1400,9 @@ int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
        while (cnt >= info->portwidth) {
                cword.w32 = 0;
                for (i = 0; i < info->portwidth; i++) {
-                       flash_add_byte (info, &cword, *src++);
+                       flash_add_byte(info, &cword, *src++);
                }
-               if ((rc = flash_write_cfiword (info, wp, cword)) != 0)
+               if ((rc = flash_write_cfiword(info, wp, cword)) != 0)
                        return rc;
                wp += info->portwidth;
                cnt -= info->portwidth;
@@ -1423,13 +1423,13 @@ int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
        cword.w32 = 0;
        p = (uchar *)wp;
        for (i = 0; (i < info->portwidth) && (cnt > 0); ++i) {
-               flash_add_byte (info, &cword, *src++);
+               flash_add_byte(info, &cword, *src++);
                --cnt;
        }
        for (; i < info->portwidth; ++i)
-               flash_add_byte (info, &cword, flash_read8(p + i));
+               flash_add_byte(info, &cword, flash_read8(p + i));
 
-       return flash_write_cfiword (info, wp, cword);
+       return flash_write_cfiword(info, wp, cword);
 }
 
 static inline int manufact_match(flash_info_t *info, u32 manu)
@@ -1475,7 +1475,7 @@ static int cfi_protect_bugfix(flash_info_t *info, long sector, int prot)
        return 0;
 }
 
-int flash_real_protect (flash_info_t * info, long sector, int prot)
+int flash_real_protect(flash_info_t * info, long sector, int prot)
 {
        int retcode = 0;
 
@@ -1502,19 +1502,19 @@ int flash_real_protect (flash_info_t * info, long sector, int prot)
                        /* U-Boot only checks the first byte */
                        if (manufact_match(info, ATM_MANUFACT)) {
                                if (prot) {
-                                       flash_unlock_seq (info, 0);
-                                       flash_write_cmd (info, 0,
+                                       flash_unlock_seq(info, 0);
+                                       flash_write_cmd(info, 0,
                                                        info->addr_unlock1,
                                                        ATM_CMD_SOFTLOCK_START);
-                                       flash_unlock_seq (info, 0);
-                                       flash_write_cmd (info, sector, 0,
+                                       flash_unlock_seq(info, 0);
+                                       flash_write_cmd(info, sector, 0,
                                                        ATM_CMD_LOCK_SECT);
                                } else {
-                                       flash_write_cmd (info, 0,
+                                       flash_write_cmd(info, 0,
                                                        info->addr_unlock1,
                                                        AMD_CMD_UNLOCK_START);
                                        if (info->device_id == ATM_ID_BV6416)
-                                               flash_write_cmd (info, sector,
+                                               flash_write_cmd(info, sector,
                                                        0, ATM_CMD_UNLOCK_SECT);
                                }
                        }
@@ -1562,12 +1562,12 @@ int flash_real_protect (flash_info_t * info, long sector, int prot)
                        break;
 #ifdef CONFIG_FLASH_CFI_LEGACY
                case CFI_CMDSET_AMD_LEGACY:
-                       flash_write_cmd (info, sector, 0, FLASH_CMD_CLEAR_STATUS);
-                       flash_write_cmd (info, sector, 0, FLASH_CMD_PROTECT);
+                       flash_write_cmd(info, sector, 0, FLASH_CMD_CLEAR_STATUS);
+                       flash_write_cmd(info, sector, 0, FLASH_CMD_PROTECT);
                        if (prot)
-                               flash_write_cmd (info, sector, 0, FLASH_CMD_PROTECT_SET);
+                               flash_write_cmd(info, sector, 0, FLASH_CMD_PROTECT_SET);
                        else
-                               flash_write_cmd (info, sector, 0, FLASH_CMD_PROTECT_CLEAR);
+                               flash_write_cmd(info, sector, 0, FLASH_CMD_PROTECT_CLEAR);
 #endif
        };
 
@@ -1577,7 +1577,7 @@ int flash_real_protect (flash_info_t * info, long sector, int prot)
         */
        flash_write_cmd(info, sector, 0, FLASH_CMD_READ_STATUS);
        if ((retcode =
-            flash_full_status_check (info, sector, info->erase_blk_tout,
+            flash_full_status_check(info, sector, info->erase_blk_tout,
                                      prot ? "protect" : "unprotect")) == 0) {
 
                info->protect[sector] = prot;
@@ -1591,7 +1591,7 @@ int flash_real_protect (flash_info_t * info, long sector, int prot)
 
                        for (i = 0; i < info->sector_count; i++) {
                                if (info->protect[i])
-                                       flash_real_protect (info, i, 1);
+                                       flash_real_protect(info, i, 1);
                        }
                }
        }
@@ -1601,17 +1601,17 @@ int flash_real_protect (flash_info_t * info, long sector, int prot)
 /*-----------------------------------------------------------------------
  * flash_read_user_serial - read the OneTimeProgramming cells
  */
-void flash_read_user_serial (flash_info_t * info, void *buffer, int offset,
+void flash_read_user_serial(flash_info_t * info, void *buffer, int offset,
                             int len)
 {
        uchar *src;
        uchar *dst;
 
        dst = buffer;
-       src = flash_map (info, 0, FLASH_OFFSET_USER_PROTECTION);
-       flash_write_cmd (info, 0, 0, FLASH_CMD_READ_ID);
-       memcpy (dst, src + offset, len);
-       flash_write_cmd (info, 0, 0, info->cmd_reset);
+       src = flash_map(info, 0, FLASH_OFFSET_USER_PROTECTION);
+       flash_write_cmd(info, 0, 0, FLASH_CMD_READ_ID);
+       memcpy(dst, src + offset, len);
+       flash_write_cmd(info, 0, 0, info->cmd_reset);
        udelay(1);
        flash_unmap(info, 0, FLASH_OFFSET_USER_PROTECTION, src);
 }
@@ -1619,15 +1619,15 @@ void flash_read_user_serial (flash_info_t * info, void *buffer, int offset,
 /*
  * flash_read_factory_serial - read the device Id from the protection area
  */
-void flash_read_factory_serial (flash_info_t * info, void *buffer, int offset,
+void flash_read_factory_serial(flash_info_t * info, void *buffer, int offset,
                                int len)
 {
        uchar *src;
 
-       src = flash_map (info, 0, FLASH_OFFSET_INTEL_PROTECTION);
-       flash_write_cmd (info, 0, 0, FLASH_CMD_READ_ID);
-       memcpy (buffer, src + offset, len);
-       flash_write_cmd (info, 0, 0, info->cmd_reset);
+       src = flash_map(info, 0, FLASH_OFFSET_INTEL_PROTECTION);
+       flash_write_cmd(info, 0, 0, FLASH_CMD_READ_ID);
+       memcpy(buffer, src + offset, len);
+       flash_write_cmd(info, 0, 0, info->cmd_reset);
        udelay(1);
        flash_unmap(info, 0, FLASH_OFFSET_INTEL_PROTECTION, src);
 }
@@ -1664,11 +1664,11 @@ static void cmdset_intel_read_jedec_ids(flash_info_t *info)
        udelay(1);
        flash_write_cmd(info, 0, 0, FLASH_CMD_READ_ID);
        udelay(1000); /* some flash are slow to respond */
-       info->manufacturer_id = flash_read_uchar (info,
+       info->manufacturer_id = flash_read_uchar(info,
                                        FLASH_OFFSET_MANUFACTURER_ID);
        info->device_id = (info->chipwidth == FLASH_CFI_16BIT) ?
-                       flash_read_word (info, FLASH_OFFSET_DEVICE_ID) :
-                       flash_read_uchar (info, FLASH_OFFSET_DEVICE_ID);
+                       flash_read_word(info, FLASH_OFFSET_DEVICE_ID) :
+                       flash_read_uchar(info, FLASH_OFFSET_DEVICE_ID);
        flash_write_cmd(info, 0, 0, FLASH_CMD_RESET);
 }
 
@@ -1682,7 +1682,7 @@ static int cmdset_intel_init(flash_info_t *info, struct cfi_qry *qry)
 #ifdef CONFIG_SYS_FLASH_PROTECTION
        /* read legacy lock/unlock bit from intel flash */
        if (info->ext_addr) {
-               info->legacy_unlock = flash_read_uchar (info,
+               info->legacy_unlock = flash_read_uchar(info,
                                info->ext_addr + 5) & 0x08;
        }
 #endif
@@ -1701,11 +1701,11 @@ static void cmdset_amd_read_jedec_ids(flash_info_t *info)
        flash_write_cmd(info, 0, info->addr_unlock1, FLASH_CMD_READ_ID);
        udelay(1000); /* some flash are slow to respond */
 
-       manuId = flash_read_uchar (info, FLASH_OFFSET_MANUFACTURER_ID);
+       manuId = flash_read_uchar(info, FLASH_OFFSET_MANUFACTURER_ID);
        /* JEDEC JEP106Z specifies ID codes up to bank 7 */
        while (manuId == FLASH_CONTINUATION_CODE && bankId < 0x800) {
                bankId += 0x100;
-               manuId = flash_read_uchar (info,
+               manuId = flash_read_uchar(info,
                        bankId | FLASH_OFFSET_MANUFACTURER_ID);
        }
        info->manufacturer_id = manuId;
@@ -1721,26 +1721,26 @@ static void cmdset_amd_read_jedec_ids(flash_info_t *info)
 
        switch (info->chipwidth){
        case FLASH_CFI_8BIT:
-               info->device_id = flash_read_uchar (info,
+               info->device_id = flash_read_uchar(info,
                                                FLASH_OFFSET_DEVICE_ID);
                if (info->device_id == 0x7E) {
                        /* AMD 3-byte (expanded) device ids */
-                       info->device_id2 = flash_read_uchar (info,
+                       info->device_id2 = flash_read_uchar(info,
                                                FLASH_OFFSET_DEVICE_ID2);
                        info->device_id2 <<= 8;
-                       info->device_id2 |= flash_read_uchar (info,
+                       info->device_id2 |= flash_read_uchar(info,
                                                FLASH_OFFSET_DEVICE_ID3);
                }
                break;
        case FLASH_CFI_16BIT:
-               info->device_id = flash_read_word (info,
+               info->device_id = flash_read_word(info,
                                                FLASH_OFFSET_DEVICE_ID);
                if ((info->device_id & 0xff) == 0x7E) {
                        /* AMD 3-byte (expanded) device ids */
-                       info->device_id2 = flash_read_uchar (info,
+                       info->device_id2 = flash_read_uchar(info,
                                                FLASH_OFFSET_DEVICE_ID2);
                        info->device_id2 <<= 8;
-                       info->device_id2 |= flash_read_uchar (info,
+                       info->device_id2 |= flash_read_uchar(info,
                                                FLASH_OFFSET_DEVICE_ID3);
                }
                break;
@@ -1771,7 +1771,7 @@ static int cmdset_amd_init(flash_info_t *info, struct cfi_qry *qry)
 }
 
 #ifdef CONFIG_FLASH_CFI_LEGACY
-static void flash_read_jedec_ids (flash_info_t * info)
+static void flash_read_jedec_ids(flash_info_t * info)
 {
        info->manufacturer_id = 0;
        info->device_id       = 0;
@@ -1866,7 +1866,7 @@ static inline int flash_detect_legacy(phys_addr_t base, int banknum)
  * detect if flash is compatible with the Common Flash Interface (CFI)
  * http://www.jedec.org/download/search/jesd68.pdf
  */
-static void flash_read_cfi (flash_info_t *info, void *buf,
+static void flash_read_cfi(flash_info_t *info, void *buf,
                unsigned int start, size_t len)
 {
        u8 *p = buf;
@@ -1890,7 +1890,7 @@ static void __flash_cmd_reset(flash_info_t *info)
 void flash_cmd_reset(flash_info_t *info)
        __attribute__((weak,alias("__flash_cmd_reset")));
 
-static int __flash_detect_cfi (flash_info_t * info, struct cfi_qry *qry)
+static int __flash_detect_cfi(flash_info_t * info, struct cfi_qry *qry)
 {
        int cfi_offset;
 
@@ -1899,21 +1899,21 @@ static int __flash_detect_cfi (flash_info_t * info, struct cfi_qry *qry)
 
        for (cfi_offset = 0; cfi_offset < ARRAY_SIZE(flash_offset_cfi);
             cfi_offset++) {
-               flash_write_cmd (info, 0, flash_offset_cfi[cfi_offset],
+               flash_write_cmd(info, 0, flash_offset_cfi[cfi_offset],
                                 FLASH_CMD_CFI);
-               if (flash_isequal (info, 0, FLASH_OFFSET_CFI_RESP, 'Q')
-                   && flash_isequal (info, 0, FLASH_OFFSET_CFI_RESP + 1, 'R')
-                   && flash_isequal (info, 0, FLASH_OFFSET_CFI_RESP + 2, 'Y')) {
+               if (flash_isequal(info, 0, FLASH_OFFSET_CFI_RESP, 'Q')
+                   && flash_isequal(info, 0, FLASH_OFFSET_CFI_RESP + 1, 'R')
+                   && flash_isequal(info, 0, FLASH_OFFSET_CFI_RESP + 2, 'Y')) {
                        flash_read_cfi(info, qry, FLASH_OFFSET_CFI_RESP,
                                        sizeof(struct cfi_qry));
                        info->interface = le16_to_cpu(qry->interface_desc);
 
                        info->cfi_offset = flash_offset_cfi[cfi_offset];
-                       debug ("device interface is %d\n",
+                       debug("device interface is %d\n",
                               info->interface);
-                       debug ("found port %d chip %d ",
+                       debug("found port %d chip %d ",
                               info->portwidth, info->chipwidth);
-                       debug ("port %d bits chip %d bits\n",
+                       debug("port %d bits chip %d bits\n",
                               info->portwidth << CFI_FLASH_SHIFT_WIDTH,
                               info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
 
@@ -1944,9 +1944,9 @@ static int __flash_detect_cfi (flash_info_t * info, struct cfi_qry *qry)
        return 0;
 }
 
-static int flash_detect_cfi (flash_info_t * info, struct cfi_qry *qry)
+static int flash_detect_cfi(flash_info_t * info, struct cfi_qry *qry)
 {
-       debug ("flash detect cfi\n");
+       debug("flash detect cfi\n");
 
        for (info->portwidth = CONFIG_SYS_FLASH_CFI_WIDTH;
             info->portwidth <= FLASH_CFI_64BIT; info->portwidth <<= 1) {
@@ -1956,7 +1956,7 @@ static int flash_detect_cfi (flash_info_t * info, struct cfi_qry *qry)
                        if (__flash_detect_cfi(info, qry))
                                return 1;
        }
-       debug ("not found\n");
+       debug("not found\n");
        return 0;
 }
 
@@ -2063,7 +2063,7 @@ static void flash_fixup_num(flash_info_t *info, struct cfi_qry *qry)
  * The following code cannot be run from FLASH!
  *
  */
-ulong flash_get_size (phys_addr_t base, int banknum)
+ulong flash_get_size(phys_addr_t base, int banknum)
 {
        flash_info_t *info = &flash_info[banknum];
        int i, j;
@@ -2087,20 +2087,20 @@ ulong flash_get_size (phys_addr_t base, int banknum)
 
        info->start[0] = (ulong)map_physmem(base, info->portwidth, MAP_NOCACHE);
 
-       if (flash_detect_cfi (info, &qry)) {
+       if (flash_detect_cfi(info, &qry)) {
                info->vendor = le16_to_cpu(get_unaligned(&(qry.p_id)));
                info->ext_addr = le16_to_cpu(get_unaligned(&(qry.p_adr)));
                num_erase_regions = qry.num_erase_regions;
 
                if (info->ext_addr) {
-                       info->cfi_version = (ushort) flash_read_uchar (info,
+                       info->cfi_version = (ushort) flash_read_uchar(info,
                                                info->ext_addr + 3) << 8;
-                       info->cfi_version |= (ushort) flash_read_uchar (info,
+                       info->cfi_version |= (ushort) flash_read_uchar(info,
                                                info->ext_addr + 4);
                }
 
 #ifdef DEBUG
-               flash_printqry (&qry);
+               flash_printqry(&qry);
 #endif
 
                switch (info->vendor) {
@@ -2145,11 +2145,11 @@ ulong flash_get_size (phys_addr_t base, int banknum)
                        break;
                }
 
-               debug ("manufacturer is %d\n", info->vendor);
-               debug ("manufacturer id is 0x%x\n", info->manufacturer_id);
-               debug ("device id is 0x%x\n", info->device_id);
-               debug ("device id2 is 0x%x\n", info->device_id2);
-               debug ("cfi version is 0x%04x\n", info->cfi_version);
+               debug("manufacturer is %d\n", info->vendor);
+               debug("manufacturer id is 0x%x\n", info->manufacturer_id);
+               debug("device id is 0x%x\n", info->device_id);
+               debug("device id2 is 0x%x\n", info->device_id2);
+               debug("cfi version is 0x%04x\n", info->cfi_version);
 
                size_ratio = info->portwidth / info->chipwidth;
                /* if the chip is x8/x16 reduce the ratio by half */
@@ -2157,7 +2157,7 @@ ulong flash_get_size (phys_addr_t base, int banknum)
                    && (info->chipwidth == FLASH_CFI_BY8)) {
                        size_ratio >>= 1;
                }
-               debug ("size_ratio %d port %d bits chip %d bits\n",
+               debug("size_ratio %d port %d bits chip %d bits\n",
                       size_ratio, info->portwidth << CFI_FLASH_SHIFT_WIDTH,
                       info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
                info->size = 1 << qry.dev_size;
@@ -2168,12 +2168,12 @@ ulong flash_get_size (phys_addr_t base, int banknum)
                        debug("[truncated from %ldMiB]", info->size >> 20);
                        info->size = max_size;
                }
-               debug ("found %d erase regions\n", num_erase_regions);
+               debug("found %d erase regions\n", num_erase_regions);
                sect_cnt = 0;
                sector = base;
                for (i = 0; i < num_erase_regions; i++) {
                        if (i > NUM_ERASE_REGIONS) {
-                               printf ("%d erase regions found, only %d used\n",
+                               printf("%d erase regions found, only %d used\n",
                                        num_erase_regions, NUM_ERASE_REGIONS);
                                break;
                        }
@@ -2186,7 +2186,7 @@ ulong flash_get_size (phys_addr_t base, int banknum)
                        tmp >>= 16;
                        erase_region_size =
                                (tmp & 0xffff) ? ((tmp & 0xffff) * 256) : 128;
-                       debug ("erase_region_count = %d erase_region_size = %d\n",
+                       debug("erase_region_count = %d erase_region_size = %d\n",
                                erase_region_count, erase_region_size);
                        for (j = 0; j < erase_region_count; j++) {
                                if (sector - base >= info->size)
@@ -2217,7 +2217,7 @@ ulong flash_get_size (phys_addr_t base, int banknum)
                                        flash_write_cmd(info, sect_cnt, 0,
                                                        FLASH_CMD_READ_ID);
                                        info->protect[sect_cnt] =
-                                               flash_isset (info, sect_cnt,
+                                               flash_isset(info, sect_cnt,
                                                             FLASH_OFFSET_PROTECT,
                                                             FLASH_STATUS_PROTECT);
                                        flash_write_cmd(info, sect_cnt, 0,
@@ -2274,7 +2274,7 @@ ulong flash_get_size (phys_addr_t base, int banknum)
                        info->portwidth >>= 1;
                }
 
-               flash_write_cmd (info, 0, 0, info->cmd_reset);
+               flash_write_cmd(info, 0, 0, info->cmd_reset);
        }
 
        return (info->size);
@@ -2362,7 +2362,7 @@ static void flash_protect_default(void)
 #endif
 }
 
-unsigned long flash_init (void)
+unsigned long flash_init(void)
 {
        unsigned long size = 0;
        int i;
@@ -2390,7 +2390,7 @@ unsigned long flash_init (void)
                size += flash_info[i].size;
                if (flash_info[i].flash_id == FLASH_UNKNOWN) {
 #ifndef CONFIG_SYS_FLASH_QUIET_TEST
-                       printf ("## Unknown flash on Bank %d "
+                       printf("## Unknown flash on Bank %d "
                                "- Size = 0x%08lx = %ld MB\n",
                                i+1, flash_info[i].size,
                                flash_info[i].size >> 20);
@@ -2422,7 +2422,7 @@ unsigned long flash_init (void)
                                 * unlock only one sector. This will
                                 * unlock all sectors.
                                 */
-                               flash_real_protect (&flash_info[i], 0, 0);
+                               flash_real_protect(&flash_info[i], 0, 0);
 
                                flash_info[i].legacy_unlock = 1;
 
@@ -2436,7 +2436,7 @@ unsigned long flash_init (void)
                                /*
                                 * No legancy unlocking -> unlock all sectors
                                 */
-                               flash_protect (FLAG_PROTECT_CLEAR,
+                               flash_protect(FLAG_PROTECT_CLEAR,
                                               flash_info[i].start[0],
                                               flash_info[i].start[0]
                                               + flash_info[i].size - 1,