¿Es posible arrancar un teléfono Android desde una unidad USB?

Por favor aclare cuál es el objetivo previsto y por qué?

Los teléfonos Android tienen sus propios boot-loaders y no pueden ser anulados por otros medios.

No es como la BIOS de una PC donde puedes cambiar el orden de inicio para arrancar desde ciertos dispositivos como la red PXE, USB, H.D.D Primario/Secundario...

Editar:

Después de los comentarios a continuación, y en relación con la pregunta del OP

¿Hay alguna manera de arrancar un teléfono Android (por ejemplo, uno con funcionalidad USB OTG) a través de una unidad USB alimentada por bus?

El boot-loader genérico (*que reside en el conjunto de chips) no tiene conocimiento de USB, etc., ya que el lk (Little Kernel) está más preocupado por atrapar pulsaciones de teclas para cargar en cadena en la recuperación o arrancar directamente en el entorno Android (Cuando se mantiene pulsada la tecla Vol+Abajo en este caso) - en pseudo-código (esto es desde el contexto/aspecto de lk, y también las direcciones de memoria relacionadas con cómo leer las particiones están codificadas en duro en este lk para que sepa cómo procesar la lógica!)

El kernel lk es el estándar de facto de Qualcomm para los conjuntos de chips MSM (Snapdragon) y adoptado por fabricantes como Sony, Motorola, LG, Samsung y se puede encontrar en la fuente AOSP bajo bootable/bootloader.

si (¿Se ha presionado la tecla de volumen abajo?) entonces

• cargar en cadena el kernel desde la partición /recovery en una dirección específica en la memoria y saltar a ella y comenzar la ejecución, poniendo en marcha el entorno de recuperación

sino

• cargar en cadena el kernel desde la partición /system en una dirección específica en la memoria y saltar a ella y comenzar la ejecución para poner en marcha el entorno Android.

fin si.

Dado que el kernel dentro de lk es bastante limitado, considerando que la imagen binaria del kernel está grabada en el chip y por lo tanto no se puede modificar. También debería mencionarse que lk contiene el protocolo fastboot en preparación para flashear las particiones /boot, /recovery, /system y /data. Hay dos secuencias de arranque, arranque primario y arranque secundario de la siguiente manera:

• Arranque Primario -> lk (dependiendo del resultado de la lógica)
• Ir a Arranque Secundario -> /boot o /recovery

Nota: Samsung tiene predilección por el PBL/SBL (que son el Cargador de Arranque Primario y el Cargador de Arranque Secundario, respectivamente) en su jerga cuando se trata de modificación. Lo curioso de Samsung es que, en algunos dispositivos, el PBL y el SBL pueden estar encriptados (Samsung Wave GT-S8500 es un ejemplo de eso, donde portar Android a él era casi imposible debido a la DRM dentro de los cargadores de arranque, lo cual era una pesadilla para tratar y hacía que modificarlo fuera extremadamente difícil, no obstante, está funcionando más o menos a través de un exploit en el código FOTA!)

Por eso no hay facilidades adicionales como la funcionalidad OTG u cualquier otra cosa como comunicaciones serie, lectura desde SDCard, gráficos, etc., ya que haría que el kernel lk fuera más grande de lo previsto. En otras palabras, es el tamaño de kernel más pequeño posible destinado a hacer que el pseudo-código anterior funcione.

También, otra forma de verlo es esta, y esto depende de la versión de Android - la funcionalidad USB OTG se activa completamente dentro del entorno Android, es decir, cuando aparece la pantalla de inicio habitual, entonces la funcionalidad de OTG está habilitada. Desafortunadamente, no es el caso cuando se mira desde la perspectiva de lk.

Si tienes curiosidad, aquí está la entrada de Qualcomm sobre el mencionado lk que es una parte del pequeño código C que tiene incluida la ensambladora ARM y se encuentra en la fuente AOSP de JellyBean en bootable/bootloader/legacy/usbloader/main.c

int boot_linux_from_flash(void)
{
    boot_img_hdr *hdr = (void*) raw_header;
    unsigned n;
    ptentry *p;
    unsigned offset = 0;
    const char *cmdline;

    if((p = flash_find_ptn("boot")) == 0) {
        cprintf("NO BOOT PARTITION\n");
        return -1;
    }

    if(flash_read(p, offset, raw_header, 2048)) {
        cprintf("CANNOT READ BOOT IMAGE HEADER\n");
        return -1;
    }
    offset += 2048;

    if(memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
        cprintf("INVALID BOOT IMAGE HEADER\n");
        return -1;
    }

    n = (hdr->kernel_size + (FLASH_PAGE_SIZE - 1)) & (~(FLASH_PAGE_SIZE - 1));
    if(flash_read(p, offset, (void*) hdr->kernel_addr, n)) {
        cprintf("CANNOT READ KERNEL IMAGE\n");
        return -1;
    }
    offset += n;

    n = (hdr->ramdisk_size + (FLASH_PAGE_SIZE - 1)) & (~(FLASH_PAGE_SIZE - 1));
    if(flash_read(p, offset, (void*) hdr->ramdisk_addr, n)) {
        cprintf("CANNOT READ RAMDISK IMAGE\n");
        return -1;
    }
    offset += n;

    dprintf("\nestado del kernel @ %x (%d bytes)\n", hdr->kernel_addr, hdr->kernel_size);
    dprintf("estado del ramdisk @ %x (%d bytes)\n\n\n", hdr->ramdisk_addr, hdr->ramdisk_size);

    if(hdr->cmdline[0]) {
        cmdline = (char*) hdr->cmdline;
    } else {
        cmdline = board_cmdline();
        if(cmdline == 0) {
            cmdline = "mem=50M console=null";
        }
    }
    cprintf("comando = '%s'\n", cmdline);

    cprintf("\nArrancando Linux\n");

    create_atags(ADDR_TAGS, cmdline,
                 hdr->ramdisk_addr, hdr->ramdisk_size);

    boot_linux(hdr->kernel_addr);
    return 0;
}