This puts the loop body in a new function called try_this_kernel.
As an added benefit, we can drop one level of indentation.

This change is hard to read as a patch. It gets better if one just
applies it and then looks at it with "git diff -w" or similar.

Signed-off-by: Werner Almesberger <[email protected]>

---

Index: qi/src/phase2.c
===================================================================
--- qi.orig/src/phase2.c        2009-01-08 23:20:16.000000000 -0200
+++ qi/src/phase2.c     2009-01-08 23:21:01.000000000 -0200
@@ -96,292 +96,274 @@
        return len;
 }
 
-void bootloader_second_phase(void)
+static void try_this_kernel(void)
 {
        void    (*the_kernel)(int zero, int arch, uint params);
-       int kernel = 0;
        const struct board_variant * board_variant =
                                              (this_board->get_board_variant)();
        unsigned int initramfs_len = 0;
        static char commandline_rootfs_append[512] = "";
+       static void * last_block_init = NULL;
+       static int last_block_init_result = 0;
        int ret;
-       void * last_block_init = NULL;
-       int last_block_init_result = 0;
-
-       /* we try the possible kernels for this board in order */
-
-       this_kernel = &this_board->kernel_source[kernel++];
+       const char *p;
+       char * cmdline;
+       struct tag *params = (struct tag *)this_board->linux_tag_placement;
+       void * kernel_dram = (void *)this_board->linux_mem_start + 0x8000;
+       unsigned long crc;
+       image_header_t  *hdr;
+       u32 kernel_size;
+
+       partition_offset_blocks = 0;
+       partition_length_blocks = 0;
+
+       /* eat leading white space */
+       for (p = this_board->commandline_board; *p == ' '; p++);
+
+       puts("\nTrying kernel: ");
+       puts(this_kernel->name);
+       puts("\n");
 
-       while (this_kernel->name) {
-               const char *p;
-               char * cmdline;
-               struct tag *params = (struct tag 
*)this_board->linux_tag_placement;
-               void * kernel_dram = (void *)this_board->linux_mem_start + 
0x8000;
-               unsigned long crc;
-               image_header_t  *hdr;
-               u32 kernel_size;
-
-               partition_offset_blocks = 0;
-               partition_length_blocks = 0;
-
-               /* eat leading white space */
-               for (p = this_board->commandline_board; *p == ' '; p++);
-
-               puts("\nTrying kernel: ");
-               puts(this_kernel->name);
-               puts("\n");
+       indicate(UI_IND_MOUNT_PART);
 
-               indicate(UI_IND_MOUNT_PART);
+       /* if this device needs initializing, try to init it */
+       if (this_kernel->block_init) {
+               /*
+                * cache result to limit attempts for same
+                * block device to one time
+                */
+               if (this_kernel->block_init != last_block_init)
+                       last_block_init_result = (this_kernel->block_init)();
 
-               /* if this device needs initializing, try to init it */
-               if (this_kernel->block_init) {
-                       /*
-                        * cache result to limit attempts for same
-                        * block device to one time
-                        */
+               if (last_block_init_result) {
+                       puts("block device init failed\n");
                        if (this_kernel->block_init != last_block_init)
-                               last_block_init_result =
-                                                   (this_kernel->block_init)();
-
-                       if (last_block_init_result) {
-                               puts("block device init failed\n");
-                               if (this_kernel->block_init != last_block_init)
-                                       indicate(UI_IND_MOUNT_FAIL);
-                               this_kernel = &this_board->
-                                                       kernel_source[kernel++];
-                               last_block_init = this_kernel->block_init;
-                               continue;
-                       }
-                       last_block_init = this_kernel->block_init;
+                               indicate(UI_IND_MOUNT_FAIL);
+                       last_block_init = this_kernel[1].block_init;
+                       return;
                }
+               last_block_init = this_kernel->block_init;
+       }
 
-               /* if there's a partition table implied, parse it, otherwise
-                * just use a fixed offset
-                */
-               if (this_kernel->partition_index) {
-                       unsigned char *p = kernel_dram;
+       /* if there's a partition table implied, parse it, otherwise
+        * just use a fixed offset
+        */
+       if (this_kernel->partition_index) {
+               unsigned char *p = kernel_dram;
 
-                       if ((int)this_kernel->block_read(kernel_dram, 0, 4)
-                                                                         < 0) {
-                               puts("Bad partition read\n");
-                               this_kernel = &this_board->
-                                                       kernel_source[kernel++];
-                               indicate(UI_IND_MOUNT_FAIL);
-                               continue;
-                       }
+               if ((int)this_kernel->block_read(kernel_dram, 0, 4) < 0) {
+                       puts("Bad partition read\n");
+                       indicate(UI_IND_MOUNT_FAIL);
+                       return;
+               }
 
-                       if ((p[0x1fe] != 0x55) || (p[0x1ff] != 0xaa)) {
-                               puts("partition signature missing\n");
-                               this_kernel = &this_board->
-                                                       kernel_source[kernel++];
-                               indicate(UI_IND_MOUNT_FAIL);
-                               continue;
-                       }
+               if ((p[0x1fe] != 0x55) || (p[0x1ff] != 0xaa)) {
+                       puts("partition signature missing\n");
+                       indicate(UI_IND_MOUNT_FAIL);
+                       return;
+               }
 
-                       p += 0x1be + 8 + (0x10 *
-                                           (this_kernel->partition_index - 1));
+               p += 0x1be + 8 + (0x10 * (this_kernel->partition_index - 1));
 
-                       partition_offset_blocks = (((u32)p[3]) << 24) |
-                                                 (((u32)p[2]) << 16) |
-                                                 (((u32)p[1]) << 8) |
-                                                 p[0];
-                       partition_length_blocks = (((u32)p[7]) << 24) |
-                                                 (((u32)p[6]) << 16) |
-                                                 (((u32)p[5]) << 8) |
-                                                 p[4];
-
-                       puts("    Partition: ");
-                       printdec(this_kernel->partition_index);
-                       puts(" start +");
-                       printdec(partition_offset_blocks);
-                       puts(" 512-byte blocks, size ");
-                       printdec(partition_length_blocks / 2048);
-                       puts(" MiB\n");
-
-               } else
-                       partition_offset_blocks =
-                                 this_kernel->offset_blocks512_if_no_partition;
-
-               /* does he want us to skip this? */
-
-               ret = read_file(this_board->noboot, kernel_dram, 512);
-               if (ret != -1) {
-                       /* -2 (mount fail) should make us give up too */
-                       if (ret >= 0) {
-                               puts("    (Skipping on finding ");
-                               puts(this_board->noboot);
-                               puts(")\n");
-                               indicate(UI_IND_SKIPPING);
-                       }
-                       this_kernel = &this_board->kernel_source[kernel++];
-                       continue;
+               partition_offset_blocks = (((u32)p[3]) << 24) |
+                                         (((u32)p[2]) << 16) |
+                                         (((u32)p[1]) << 8) |
+                                         p[0];
+               partition_length_blocks = (((u32)p[7]) << 24) |
+                                         (((u32)p[6]) << 16) |
+                                         (((u32)p[5]) << 8) |
+                                         p[4];
+
+               puts("    Partition: ");
+               printdec(this_kernel->partition_index);
+               puts(" start +");
+               printdec(partition_offset_blocks);
+               puts(" 512-byte blocks, size ");
+               printdec(partition_length_blocks / 2048);
+               puts(" MiB\n");
+
+       } else
+               partition_offset_blocks =
+                         this_kernel->offset_blocks512_if_no_partition;
+
+       /* does he want us to skip this? */
+
+       ret = read_file(this_board->noboot, kernel_dram, 512);
+       if (ret != -1) {
+               /* -2 (mount fail) should make us give up too */
+               if (ret >= 0) {
+                       puts("    (Skipping on finding ");
+                       puts(this_board->noboot);
+                       puts(")\n");
+                       indicate(UI_IND_SKIPPING);
                }
+               return;
+       }
 
-               /* is there a commandline append file? */
+       /* is there a commandline append file? */
 
-               commandline_rootfs_append[0] = '\0';
-               read_file(this_board->append, (u8 *)commandline_rootfs_append,
-                                                                          512);
+       commandline_rootfs_append[0] = '\0';
+       read_file(this_board->append, (u8 *)commandline_rootfs_append, 512);
 
-               indicate(UI_IND_KERNEL_PULL);
+       indicate(UI_IND_KERNEL_PULL);
 
-               /* pull the kernel image */
+       /* pull the kernel image */
 
-               if (read_file(this_kernel->filepath, kernel_dram, 4096) < 0) {
-                       this_kernel = &this_board->kernel_source[kernel++];
-                       continue;
-               }
+       if (read_file(this_kernel->filepath, kernel_dram, 4096) < 0)
+               return;
 
-               hdr = (image_header_t *)kernel_dram;
+       hdr = (image_header_t *)kernel_dram;
 
-               if (__be32_to_cpu(hdr->ih_magic) != IH_MAGIC) {
-                       puts("bad magic ");
-                       print32(hdr->ih_magic);
-                       puts("\n");
-                       this_kernel = &this_board->kernel_source[kernel++];
-                       continue;
-               }
+       if (__be32_to_cpu(hdr->ih_magic) != IH_MAGIC) {
+               puts("bad magic ");
+               print32(hdr->ih_magic);
+               puts("\n");
+               return;
+       }
 
-               puts("        Found: \"");
-               puts((const char *)hdr->ih_name);
-               puts("\"\n         Size: ");
-               printdec(__be32_to_cpu(hdr->ih_size) >> 10);
-               puts(" KiB\n");
-
-               kernel_size = ((__be32_to_cpu(hdr->ih_size) +
-                                 sizeof(image_header_t) + 2048) & ~(2048 - 1));
-
-               if (read_file(this_kernel->filepath, kernel_dram,
-                                                            kernel_size) < 0) {
-                       this_kernel = &this_board->kernel_source[kernel++];
-                       indicate(UI_IND_KERNEL_PULL_FAIL);
-                       continue;
-               }
+       puts("        Found: \"");
+       puts((const char *)hdr->ih_name);
+       puts("\"\n         Size: ");
+       printdec(__be32_to_cpu(hdr->ih_size) >> 10);
+       puts(" KiB\n");
+
+       kernel_size = ((__be32_to_cpu(hdr->ih_size) +
+                         sizeof(image_header_t) + 2048) & ~(2048 - 1));
+
+       if (read_file(this_kernel->filepath, kernel_dram, kernel_size) < 0) {
+               indicate(UI_IND_KERNEL_PULL_FAIL);
+               return;
+       }
 
-               indicate(UI_IND_KERNEL_PULL_OK);
+       indicate(UI_IND_KERNEL_PULL_OK);
 
-               /* initramfs if needed */
+       /* initramfs if needed */
 
-               if (this_kernel->initramfs_filepath) {
-                       indicate(UI_IND_INITRAMFS_PULL);
-                       initramfs_len = 
read_file(this_kernel->initramfs_filepath,
-                             (u8 *)this_board->linux_mem_start + INITRD_OFFSET,
-                                                             16 * 1024 * 1024);
-                       if (initramfs_len < 0) {
-                               puts("initramfs load failed\n");
-                               this_kernel = 
&this_board->kernel_source[kernel++];
-                               indicate(UI_IND_INITRAMFS_PULL_FAIL);
-                               continue;
-                       }
-                       indicate(UI_IND_INITRAMFS_PULL_OK);
+       if (this_kernel->initramfs_filepath) {
+               indicate(UI_IND_INITRAMFS_PULL);
+               initramfs_len = read_file(this_kernel->initramfs_filepath,
+                     (u8 *)this_board->linux_mem_start + INITRD_OFFSET,
+                                                     16 * 1024 * 1024);
+               if (initramfs_len < 0) {
+                       puts("initramfs load failed\n");
+                       indicate(UI_IND_INITRAMFS_PULL_FAIL);
+                       return;
                }
+               indicate(UI_IND_INITRAMFS_PULL_OK);
+       }
 
-               /*
-                * It's good for now to know that our kernel is intact from
-                * the storage before we jump into it and maybe crash silently
-                * even though it costs us some time
-                */
-               crc = crc32(0, kernel_dram + sizeof(image_header_t),
+       /*
+        * It's good for now to know that our kernel is intact from
+        * the storage before we jump into it and maybe crash silently
+        * even though it costs us some time
+        */
+       crc = crc32(0, kernel_dram + sizeof(image_header_t),
                                                   __be32_to_cpu(hdr->ih_size));
-               if (crc != __be32_to_cpu(hdr->ih_dcrc)) {
-                       puts("\nKernel CRC ERROR: read 0x");
-                       print32(crc);
-                       puts(" vs hdr CRC 0x");
-                       print32(__be32_to_cpu(hdr->ih_dcrc));
-                       puts("\n");
-                       this_kernel = &this_board->kernel_source[kernel++];
-                       continue;
-               }
-
-               the_kernel = (void (*)(int, int, uint))
-                                       (((char *)hdr) + 
sizeof(image_header_t));
-
-               /* first tag */
-               params->hdr.tag = ATAG_CORE;
-               params->hdr.size = tag_size (tag_core);
-               params->u.core.flags = 0;
-               params->u.core.pagesize = 0;
-               params->u.core.rootdev = 0;
-               params = tag_next(params);
-
-               /* revision tag */
-               params->hdr.tag = ATAG_REVISION;
-               params->hdr.size = tag_size (tag_revision);
-               params->u.revision.rev = board_variant->machine_revision;
-               params = tag_next(params);
+       if (crc != __be32_to_cpu(hdr->ih_dcrc)) {
+               puts("\nKernel CRC ERROR: read 0x");
+               print32(crc);
+               puts(" vs hdr CRC 0x");
+               print32(__be32_to_cpu(hdr->ih_dcrc));
+               puts("\n");
+               return;
+       }
 
-               /* memory tags */
-               params->hdr.tag = ATAG_MEM;
-               params->hdr.size = tag_size (tag_mem32);
-               params->u.mem.start = this_board->linux_mem_start;
-               params->u.mem.size = this_board->linux_mem_size;
-               params = tag_next(params);
+       the_kernel = (void (*)(int, int, uint))
+                               (((char *)hdr) + sizeof(image_header_t));
 
-               if (this_kernel->initramfs_filepath) {
-                       /* INITRD2 tag */
-                       params->hdr.tag = ATAG_INITRD2;
-                       params->hdr.size = tag_size (tag_initrd);
-                       params->u.initrd.start = this_board->linux_mem_start +
+       /* first tag */
+       params->hdr.tag = ATAG_CORE;
+       params->hdr.size = tag_size (tag_core);
+       params->u.core.flags = 0;
+       params->u.core.pagesize = 0;
+       params->u.core.rootdev = 0;
+       params = tag_next(params);
+
+       /* revision tag */
+       params->hdr.tag = ATAG_REVISION;
+       params->hdr.size = tag_size (tag_revision);
+       params->u.revision.rev = board_variant->machine_revision;
+       params = tag_next(params);
+
+       /* memory tags */
+       params->hdr.tag = ATAG_MEM;
+       params->hdr.size = tag_size (tag_mem32);
+       params->u.mem.start = this_board->linux_mem_start;
+       params->u.mem.size = this_board->linux_mem_size;
+       params = tag_next(params);
+
+       if (this_kernel->initramfs_filepath) {
+               /* INITRD2 tag */
+               params->hdr.tag = ATAG_INITRD2;
+               params->hdr.size = tag_size (tag_initrd);
+               params->u.initrd.start = this_board->linux_mem_start +
                                                              INITRD_OFFSET;
-                       params->u.initrd.size = initramfs_len;
-                       params = tag_next(params);
-               }
+               params->u.initrd.size = initramfs_len;
+               params = tag_next(params);
+       }
 
-               /* kernel commandline */
+       /* kernel commandline */
 
-               cmdline = params->u.cmdline.cmdline;
-               cmdline += strlen(strcpy(cmdline, p));
-               if (this_kernel->commandline_append)
+       cmdline = params->u.cmdline.cmdline;
+       cmdline += strlen(strcpy(cmdline, p));
+       if (this_kernel->commandline_append)
+               cmdline += strlen(strcpy(cmdline,
+                                     this_kernel->commandline_append));
+               if (commandline_rootfs_append[0])
                        cmdline += strlen(strcpy(cmdline,
-                                             this_kernel->commandline_append));
-                       if (commandline_rootfs_append[0])
-                               cmdline += strlen(strcpy(cmdline,
-                                             commandline_rootfs_append));
+                                     commandline_rootfs_append));
 
-               /*
-                * if he's still holding down the UI_ACTION_SKIPKERNEL key
-                * now we finished loading the kernel, take it to mean he wants
-                * to have the debugging options added to the commandline
-                */
+       /*
+        * if he's still holding down the UI_ACTION_SKIPKERNEL key
+        * now we finished loading the kernel, take it to mean he wants
+        * to have the debugging options added to the commandline
+        */
 
-               if (this_board->commandline_board_debug &&
-                                                       this_board->get_ui_keys)
-                       if ((this_board->get_ui_keys)() & UI_ACTION_SKIPKERNEL)
-                               cmdline += strlen(strcpy(cmdline, this_board->
-                                                     commandline_board_debug));
-
-               params->hdr.tag = ATAG_CMDLINE;
-               params->hdr.size = (sizeof (struct tag_header) +
-                       strlen(params->u.cmdline.cmdline) + 1 + 4) >> 2;
+       if (this_board->commandline_board_debug && this_board->get_ui_keys)
+               if ((this_board->get_ui_keys)() & UI_ACTION_SKIPKERNEL)
+                       cmdline += strlen(strcpy(cmdline, this_board->
+                                             commandline_board_debug));
+
+       params->hdr.tag = ATAG_CMDLINE;
+       params->hdr.size = (sizeof (struct tag_header) +
+               strlen(params->u.cmdline.cmdline) + 1 + 4) >> 2;
+
+       puts("      Cmdline: ");
+       puts(params->u.cmdline.cmdline);
+       puts("\n");
+
+       params = tag_next (params);
+
+       /* needs to always be the last tag */
+       params->hdr.tag = ATAG_NONE;
+       params->hdr.size = 0;
 
-               puts("      Cmdline: ");
-               puts(params->u.cmdline.cmdline);
-               puts("\n");
-
-               params = tag_next (params);
+       /* give board implementation a chance to shut down
+        * anything it may have going on, leave GPIO set for Linux
+        */
+       if (this_board->close)
+               (this_board->close)();
 
-               /* needs to always be the last tag */
-               params->hdr.tag = ATAG_NONE;
-               params->hdr.size = 0;
+       puts ("Starting --->\n\n");
+       indicate(UI_IND_KERNEL_START);
 
-               /* give board implementation a chance to shut down
-                * anything it may have going on, leave GPIO set for Linux
-                */
-               if (this_board->close)
-                       (this_board->close)();
+       /*
+       * ooh that's it, we're gonna try boot this image!
+       * never mind the cache, Linux will take care of it
+       */
+       the_kernel(0, this_board->linux_machine_id,
+                                       this_board->linux_tag_placement);
 
-               puts ("Starting --->\n\n");
-               indicate(UI_IND_KERNEL_START);
+       /* we won't come back here no matter what */
+}
 
-               /*
-               * ooh that's it, we're gonna try boot this image!
-               * never mind the cache, Linux will take care of it
-               */
-               the_kernel(0, this_board->linux_machine_id,
-                                               
this_board->linux_tag_placement);
+void bootloader_second_phase(void)
+{
+       /* we try the possible kernels for this board in order */
 
-               /* we won't come back here no matter what */
-       }
+       for (this_kernel = this_board->kernel_source; this_kernel->name;
+           this_kernel++)
+               try_this_kernel();
 
        /* none of the kernels worked out */
 

-- 

Reply via email to