Fixes to compiler warnings in MSVC

firmware/lib/vboot_kernel.c

 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Functions for loading a kernel from disk.
  * (Firmware portion)
  */
 
 #include "vboot_kernel.h"
 
@@ skipping 129 matching lines @@
       return LOAD_KERNEL_RECOVERY;
     }
   } else if (is_dev) {
     /* In developer mode, we ignore the kernel subkey, and just use
      * the SHA-512 hash to verify the key block. */
     kernel_subkey = NULL;
   }
 
   do {
     /* Read GPT data */
-    gpt.sector_bytes = blba;
+    gpt.sector_bytes = (uint32_t)blba;
     gpt.drive_sectors = params->ending_lba + 1;
     if (0 != AllocAndReadGptData(&gpt)) {
       debug("Unable to read GPT data\n");
       break;
     }
 
     /* Initialize GPT library */
     if (GPT_SUCCESS != GptInit(&gpt)) {
       debug("Error parsing GPT\n");
       break;
@@ skipping 138 matching lines @@
         RSAPublicKeyFree(data_key);
         continue;
       }
 
       /* Done with the kernel signing key, so can free it now */
       RSAPublicKeyFree(data_key);
 
       /* If we're still here, the kernel is valid. */
       /* Save the first good partition we find; that's the one we'll boot */
       debug("Partiton is good.\n");
-      good_partition = gpt.current_kernel;
+      /* TODO: GPT partitions start at 1, but cgptlib starts them at 0.
+       * Adjust here, until cgptlib is fixed. */
+      good_partition = gpt.current_kernel + 1;
       params->partition_number = gpt.current_kernel;
       params->bootloader_address = preamble->bootloader_address;
       params->bootloader_size = preamble->bootloader_size;
       /* If we're in developer or recovery mode, there's no rollback
        * protection, so we can stop at the first valid kernel. */
-      if (!is_normal)
+      if (!is_normal) {
+        debug("Boot_flags = !is_normal\n");
         break;
+      }
 
       /* Otherwise, we're in normal boot mode, so we do care about the
        * key index in the TPM.  If the good partition's key version is
        * the same as the tpm, then the TPM doesn't need updating; we
        * can stop now.  Otherwise, we'll check all the other headers
        * to see if they contain a newer key. */
       if (key_version == tpm_key_version &&
-          preamble->kernel_version == tpm_kernel_version)
+          preamble->kernel_version == tpm_kernel_version) {
+        debug("Same key version\n");
         break;
+      }
     } /* while(GptNextKernelEntry) */
   } while(0);
 
   /* Free kernel buffer */
   if (kbuf)
     Free(kbuf);
 
   /* Write and free GPT data */
   WriteAndFreeGptData(&gpt);
 
   /* Handle finding a good partition */
   if (good_partition >= 0) {
+    debug("Good_partition >= 0\n");
 
     /* See if we need to update the TPM */
     if (is_normal) {
       /* We only update the TPM in normal boot mode.  In developer
        * mode, the kernel is self-signed by the developer, so we can't
        * trust the key version and wouldn't want to roll the TPM
        * forward.  In recovery mode, the TPM stays PP-unlocked, so
        * anything we write gets blown away by the firmware when we go
        * back to normal mode. */
+      debug("Boot_flags = is_normal\n");
       if ((lowest_key_version > tpm_key_version) ||
           (lowest_key_version == tpm_key_version &&
            lowest_kernel_version > tpm_kernel_version)) {
         if (0 != WriteStoredVersions(KERNEL_VERSIONS,
-                                     lowest_key_version,
-                                     lowest_kernel_version))
+                                     (uint16_t)lowest_key_version,
+                                     (uint16_t)lowest_kernel_version))
           return LOAD_KERNEL_RECOVERY;
       }
     }
 
     if (!(BOOT_FLAG_RECOVERY & params->boot_flags)) {
       /* We can lock the TPM now, since we've decided which kernel we
        * like.  If we don't find a good kernel, we leave the TPM
        * unlocked so we can try again on the next boot device.  If no
        * kernels are good, we'll reboot to recovery mode, so it's ok to
        * leave the TPM unlocked in that case too.
        *
        * If we're already in recovery mode, we need to leave PP unlocked,
        * so don't lock the kernel versions. */
+      debug("Lock kernel versions\n");
       if (0 != LockKernelVersionsByLockingPP())
         return LOAD_KERNEL_RECOVERY;
     }
 
     /* Success! */
     return LOAD_KERNEL_SUCCESS;
   }
 
   // Handle error cases
   if (found_partitions)
     return LOAD_KERNEL_INVALID;
   else
     return LOAD_KERNEL_NOT_FOUND;
 }