MTK lk源码解析2（ lk 阶段main.c中的kmain.c函数解析）

http://blog.csdn.net/xichangbao/article/details/51484564

1. kmain()。

/* called from crt0.S */

void kmain(void) __NO_RETURN __EXTERNALLY_VISIBLE;

void kmain(void)

{

    // get us into some sort of thread context

    thread_init_early(); // 初始化lk的线程系统

    // early arch stuff

    arch_early_init(); // 架构相关早期初始化，如使能mmu，cache等

    // do any super early platform initialization

    platform_early_init(); // 平台相关早期初始化，如获取板级信息，初始化时钟、中断、定时器等

    // do any super early target initialization

    target_early_init(); // 目前只有一个功能，就是初始化串口

    dprintf(INFO, "welcome to lk\n\n");

    bs_set_timestamp(BS_BL_START); // 设置bootloader初始的时间戳

    // deal with any static constructors

    dprintf(SPEW, "calling constructors\n");

    call_constructors(); // 构造函数相关初始化

    // bring up the kernel heap

    dprintf(SPEW, "initializing heap\n");

    heap_init(); // 堆初始化，用于malloc等函数的内存分配

    __stack_chk_guard_setup(); // 生成了一个随机数保存在全局变量__stack_chk_guard中

    // initialize the threading system

    dprintf(SPEW, "initializing threads\n");

    thread_init(); // 仅简单的初始化了定时器对象

    // initialize the dpc system

    dprintf(SPEW, "initializing dpc\n");

    dpc_init(); // delayed procedure call 延迟过程调用

    // initialize kernel timers

    dprintf(SPEW, "initializing timers\n");

    timer_init(); // 初始化定时器

#if (!ENABLE_NANDWRITE)

    // create a thread to complete system initialization

    dprintf(SPEW, "creating bootstrap completion thread\n");

    thread_resume(thread_create("bootstrap2", &bootstrap2, NULL, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE)); // 创建并唤醒bootstrap2线程，用于进一步完成bootloader工作

    // enable interrupts

    exit_critical_section(); // 使能中断，执行后critical_section_count等于0

    // become the idle thread

    thread_become_idle(); // 将本线程切换到idle状态

#else

        bootstrap_nandwrite();

#endif

}

2. thread_init_early()。

void thread_init_early(void)

{

    int i;

    /* initialize the run queues */

    for (i=0; i < NUM_PRIORITIES; i++)

        list_initialize(&run_queue[i]); // 初始化32个运行队列

    /* initialize the thread list */ 

    list_initialize(&thread_list); // 初始化运行队列

    /* create a thread to cover the current running state */

    thread_t *t = &bootstrap_thread; // bootstrap_thread是一个全局静态thread_t结构体

    init_thread_struct(t, "bootstrap"); // 对bootstrap_thread进行清零，设置thread魔数，设置thread name为bootstrap

    /* half construct this thread, since we're already running */

    t->priority = HIGHEST_PRIORITY; // 设置bootstrap优先级为最高优先级

    t->state = THREAD_RUNNING; // 设置bootstrap状态为正在运行

    t->saved_critical_section_count = 1; // 没看懂

    list_add_head(&thread_list, &t->thread_list_node); // 将bootstrap加入thread链表中

    current_thread = t; // 设置当前thread为bootstrap

}

3. arch_early_init()

void arch_early_init(void)

{

    /* turn off the cache */

    arch_disable_cache(UCACHE); // 禁用cache

    /* set the vector base to our exception vectors so we dont need to double map at 0 */

#if ARM_CPU_CORTEX_A8

    set_vector_base(MEMBASE); // armv8重新设置异常向量表到MEMBASE

#endif

#if ARM_WITH_MMU

    arm_mmu_init(); // 初始化mmu，lk中实现了两个arm_mmu_init() 函数，我们使用的是实现了大物理地址扩展 (LPAE)的

#endif

    /* turn the cache back on */

    arch_enable_cache(UCACHE); // 使能cache

#if ARM_WITH_NEON // NEON 技术是 ARM Cortex™-A 系列处理器的 128 位 SIMD（单指令，多数据）架构扩展，旨在为消费性多媒体应用程序提供灵活、强大的加速功能，从而显著改善用户体验。

    /* enable cp10 and cp11 */

    uint32_t val;

    __asm__ volatile("mrc    p15, 0, %0, c1, c0, 2" : "=r" (val));

    val |= (3<<22)|(3<<20);

    __asm__ volatile("mcr    p15, 0, %0, c1, c0, 2" :: "r" (val)); // 使能cp10，cp11

    isb();

    /* set enable bit in fpexc */

    __asm__ volatile("mrc  p10, 7, %0, c8, c0, 0" : "=r" (val));

    val |= (1<<30);

    __asm__ volatile("mcr  p10, 7, %0, c8, c0, 0" :: "r" (val)); //  使能Advanced SIMD and Floating-point (VFP) Extensions

#endif

#if ARM_CPU_CORTEX_A8

    /* enable the cycle count register */

    uint32_t en;

    __asm__ volatile("mrc    p15, 0, %0, c9, c12, 0" : "=r" (en)); // Performance Monitors Control Register

    en &= ~(1<<3); /* cycle count every cycle */

    en |= 1; /* enable all performance counters */

    __asm__ volatile("mcr    p15, 0, %0, c9, c12, 0" :: "r" (en));

    /* enable cycle counter */

    en = (1<<31);

    __asm__ volatile("mcr    p15, 0, %0, c9, c12, 1" :: "r" (en)); // Performance Monitors Count Enable Set register

#endif

}

void arm_mmu_init(void)

{

    /* set some mmu specific control bits:

     * access flag disabled, TEX remap disabled, mmu disabled

     */

    arm_write_cr1(arm_read_cr1() & ~((1<<29)|(1<<28)|(1<<0))); // 清除SCTLR, System Control Register（对应armv7的cp15中寄存器1）的AFE，TRE，M位关闭MMU

    platform_init_mmu_mappings(); // 初始化平台的内存映射

    /* set up the translation table base */

    arm_write_ttbr((uint32_t)mmu_l1_pagetable); // 将一级页表地址保存到协处理器cp15的c2的TTBR0, Translation Table Base Register 0

    /* set up the Memory Attribute Indirection Registers 0 and 1 */

    arm_write_mair0(MAIR0); // 设置Memory Attribute Indirection Registers 0

    arm_write_mair1(MAIR1); // 设置Memory Attribute Indirection Registers 1

    /* TTBCR.EAE = 1 & IRGN0 [9:8], ORNG0 bits [11:10]: 01 */

    arm_write_ttbcr(0x80000500); // bit[31]为1Large Physical Address Extension说明支持40位内存地址即1TB

    /* Enable TRE */

    arm_write_cr1(arm_read_cr1() | (1<<28)); // Remap enabled

    /* turn on the mmu */

    arm_write_cr1(arm_read_cr1() | 0x1); // 使能MMU

}

static mmu_section_t default_mmu_section_table[] = // 此结构体定义的内存映射都是物理内存地址等于虚拟内存地址的

{

/*       Physical addr,    Virtual addr,     Mapping type ,              Size (in MB),            Flags */

    {    0x00000000,        0x00000000,       MMU_L2_NS_SECTION_MAPPING,  512,                IOMAP_MEMORY}, // 映射0地址开始的512MB内存

    {    MEMBASE,           MEMBASE,          MMU_L2_NS_SECTION_MAPPING,  (MEMSIZE / MB),      LK_MEMORY}, // 映射加载lk的4MB内存

    {    MIPI_FB_ADDR,      MIPI_FB_ADDR,     MMU_L2_NS_SECTION_MAPPING,  40,                  LK_MEMORY}, // 映射LCD framebuffer使用的40MB内存

    {    SCRATCH_ADDR,      SCRATCH_ADDR,     MMU_L2_NS_SECTION_MAPPING,  SCRATCH_SIZE,        SCRATCH_MEMORY}, // 映射lk临时使用的内存

    {    MSM_SHARED_BASE,   MSM_SHARED_BASE,  MMU_L2_NS_SECTION_MAPPING,  MSM_SHARED_SIZE,     COMMON_MEMORY}, // 映射整个系统使用的共享内存

    {    RPMB_SND_RCV_BUF,  RPMB_SND_RCV_BUF, MMU_L2_NS_SECTION_MAPPING,  RPMB_SND_RCV_BUF_SZ, IOMAP_MEMORY}, // 不清楚是不是eMMC的rpmb

};

void platform_init_mmu_mappings(void)

{

    int i;

    int table_sz = ARRAY_SIZE(default_mmu_section_table);

    mmu_section_t kernel_mmu_section_table;

    uint64_t ddr_size = smem_get_ddr_size();

    switch(ddr_size)

    {

        case MEM_4GB:

        case MEM_3GB:

            ddr_start = 0x80000000;

            break;

        default:

            dprintf(CRITICAL, "Unsupported ddr\n");

            ASSERT(0);

    };

    kernel_mmu_section_table.paddress = ddr_start; // 物理内存地址

    kernel_mmu_section_table.vaddress = ddr_start; // 虚拟内存地址

    kernel_mmu_section_table.type = MMU_L2_NS_SECTION_MAPPING; // 使用二级页表

    kernel_mmu_section_table.size = 88; // 88MB

    kernel_mmu_section_table.flags = SCRATCH_MEMORY; //  临时使用的内存

    arm_mmu_map_entry(&kernel_mmu_section_table); // 进行内存映射；MMU现在现代计算机系统是非常重要的，提高了内存是有效使用率和不同进程间的内存隔离

    /* Map default memory needed for lk , scratch, rpmb & iomap */

    for (i = 0 ; i < table_sz; i++)

        arm_mmu_map_entry(&default_mmu_section_table[i]); // 对几个lk需要用到的内存区间进行映射

    if (scm_device_enter_dload()) // 判断是否进入下载，这段代码出现在这里，感到莫名其妙

    {

        /* TZ & Hyp memory can be mapped only while entering the download mode */

        table_sz = ARRAY_SIZE(dload_mmu_section_table);

        for (i = 0 ; i < table_sz; i++)

            arm_mmu_map_entry(&dload_mmu_section_table[i]);

    }

}

void arm_mmu_map_entry(mmu_section_t *entry)

{

    ASSERT(entry); // 断言

    if (entry->type == MMU_L1_NS_SECTION_MAPPING)

        mmu_map_l1_entry(entry);

    else if(entry->type == MMU_L2_NS_SECTION_MAPPING) // 我们使用的是二级页表

        mmu_map_l2_entry(entry);

    else

        dprintf(CRITICAL, "Invalid mapping type in the mmu table: %d\n", entry->type);

}

uint64_t mmu_l1_pagetable[ROUNDUP(L1_PT_SZ, CACHE_LINE)] __attribute__ ((aligned(4096))); /* Max is 8 */ // L1_PT_SZ = 4, 128个一级页表，4K地址对齐

uint64_t mmu_l2_pagetable[ROUNDUP(L2_PT_SZ*MMU_L2_PT_SIZE, CACHE_LINE)] __attribute__ ((aligned(4096))); /* Macro from target code * 512 */ // L2_PT_SZ = 3，MMU_L2_PT_SIZE  = 512， 3*512个二级页表，4K地址对齐

static void mmu_map_l2_entry(mmu_section_t *block)

{

    uint64_t *l2_pt = NULL;

    uint64_t  address_start;

    uint64_t  address_end;

    uint64_t  p_addr;

    /* First initialize the first level descriptor for each 1 GB

     * Bits[47:12] provide the physical base address of the level 2 page table

     *

     *    ________________________________________________________________________________

     *   |  |     |  |   |       |        |                            |       |          |

     *   |63|62-61|60| 59|58---52|51----40|39------------------------12|11----2|1------- 0|

     *   |NS| AP  |XN|PXN|Ignored|UNK|SBZP|Next-level table addr[39:12]|Ignored|Descriptor|

     *   |__|_____|__|___|_______|________|____________________________|_______|__________|

     * NS: Used only in secure state

     * AP: Access protection

     */

    /* Convert the virtual address[38:30] into an index of the L1 page table */

    address_start = (block->vaddress & LPAE_MASK) >> 30; //  使用虚拟内存地址的[39:30]bit作为一级页表索引，因此每一个一级页表可映射1GB内存空间，英文原始注释有误

     /* Check if this 1GB entry has L2 page table mapped already

     * if L1 entry hasn't mapped any L2 page table, allocate a L2 page table for it

     */

    if((mmu_l1_pagetable[address_start] & PT_TABLE_DESC_BIT) == 0) // 判断对应的1GB内存空间是否已经映射

    {

        ASSERT(avail_l2_pt); // 断言是否还剩余可用二级页表

        /* Get the first l2 empty page table and fill in the L1 PTE with a table descriptor,

         * The l2_pt address bits 12:39 are used for L1 PTE entry

         */

        l2_pt = empty_l2_pt; //  获取一个可用二级页表

        /* Bits 39.12 of the page table address are mapped into the L1 PTE entry */

        mmu_l1_pagetable[address_start] = ((uint64_t)(uintptr_t)l2_pt & 0x0FFFFFFF000) | MMU_PT_TABLE_DESCRIPTOR; // 将获取的二级可用页表内存地址的[39:12]bit（由于静态变量，其内存在lk的MEMBASE到MEMBASE+MEMSIZE之间，因此其物理内存地址等于虚拟内存地址）赋值给相应一级页表项中

        /* Advance pointer to next empty l2 page table */

        empty_l2_pt += MMU_L2_PT_SIZE; // 由于使用了一个二级页表，因此要更新剩余页表

        avail_l2_pt--; // 可用页表减1

        arch_clean_invalidate_cache_range((addr_t) mmu_l1_pagetable, L1_PT_SZ); // 刷新cache，确保一级页表的修改刷新到ddr中

    }

    else

    {

        /* Entry has L2 page table mapped already, so just get the existing L2 page table address */

        l2_pt = (uint64_t *) (uintptr_t)(mmu_l1_pagetable[address_start] & 0xFFFFFFF000); // 如果已经映射根据一级页表的索引取出二级页表的内存地址

    }

    /* Get the physical address of 2MB sections, bits 21:39 are used to populate the L2 entry */

    p_addr = block->paddress & L2_PT_MASK; // 以2MB为单位进行内存映射，因此只需要保存物理内存地址的[39:21]bit即可，同时也说明在2MB以内的偏移，物理内存地址和虚拟内存地址是相等的

    /* Start index into the L2 page table for this section using the virtual address[29:21]*/

    address_start  = (block->vaddress & L2_INDEX_MASK) >> 21; // 以虚拟内存地址的[29:21]bit作为二级页表的索引

    /* The end index for the given section. size given is in MB convert it to number of 2MB segments */

    address_end = address_start + ((block->size) >> 1); // 从1MB转换为2MB为单位

    /*

     *      ___________________________________________________________________________________________________________________

     *     |       |        |  |   |    |        |                  |        |  |  |       |       |  |             |          |

     *     |63---59|58----55|54|53 |52  |51----40|39--------------21|20----12|11|10|9     8|7     6|5 |4-----------2|  1   0   |

     *     |Ignored|Reserved|XN|PXN|Cont|UNK|SBZP|Output addr[39:21]|UNK|SBZP|nG|AF|SH[1:0]|AP[2:1]|NS|AttrIndx[2:0]|Descriptor|

     *     |_______|________|__|___|____|________|__________________|________|__|__|_______|_______|__|_____________|__________|

     */

    /* Map all the 2MB segments in the 1GB section */

    while (address_start < address_end) // 以2MB为单位进行内存映射

    {

        l2_pt[address_start] =  (p_addr) | MMU_PT_BLOCK_DESCRIPTOR | MMU_AP_FLAG | block->flags; // 将物理内存地址的[39:21]bit赋值到二级页表项中

        address_start++;

        /* Increment to the next 2MB segment in current L2 page table*/

        p_addr += SIZE_2MB;

        arm_invalidate_tlb(); // 使传输后援存储器无效，Translation Lookside Buffer

    }

    arch_clean_invalidate_cache_range((addr_t) mmu_l2_pagetable, (L2_PT_SZ*MMU_L2_PT_SIZE));  // 刷新cache，确保二级页表的修改刷新到ddr中

}

//  趁热打铁，接下来看看知道虚拟内存地址如何取到物理内存地址

uint64_t virtual_to_physical_mapping(uint32_t vaddr)

{

    uint32_t l1_index;

    uint64_t *l2_pt = NULL;

    uint32_t l2_index;

    uint32_t offset = 0;

    uint64_t paddr = 0;

    /* Find the L1 index from virtual address */

    l1_index = (vaddr & LPAE_MASK) >> 30; // 使用虚拟内存地址的[39:30]bit作为一级页表索引

    if ((mmu_l1_pagetable[l1_index] & MMU_PT_TABLE_DESCRIPTOR) == MMU_PT_TABLE_DESCRIPTOR) // 判断是否存在二级页表

    {

        /* Get the l2 page table address */

        l2_pt = (uint64_t *) (uintptr_t) (mmu_l1_pagetable[l1_index] & 0x0FFFFFFF000); // 获取二级页表的内存地址

        /* Get the l2 index from virtual address */

        l2_index = (vaddr & L2_INDEX_MASK) >> 21; // 使用虚拟内存地址的[29:21]bit作为二级页表的索引

        /* Calculate the offset from vaddr. */

        offset = vaddr & 0x1FFFFF; // 计算虚拟地址的2MB内偏移[20:0]bit

        /* Get the physical address bits from 21 to 39 */

        paddr = (l2_pt[l2_index] & L2_PT_MASK) + offset; 从二级页表中取出物理内存地址的[39:21]bit，在加上[20:0]bit的偏移，即可得到完整的物理内存地址

    } else if ((mmu_l1_pagetable[l1_index] & MMU_PT_TABLE_DESCRIPTOR) == MMU_PT_BLOCK_DESCRIPTOR) // 只使用了一级页表的情况

    {

        /* Calculate the offset from bits 0 to 30 */

        offset = vaddr & 0x3FFFFFFF;

        /* Return the entry from l1 page table */

        paddr = (mmu_l1_pagetable[l1_index] & L1_PT_INDEX) + offset;

    } else

    {

        ASSERT(0);

    }

    return paddr;

}

4. platform_early_init()。

void platform_early_init(void)

{

    board_init(); // 从共享内存中读取由xbl提供的板级信息

    platform_clock_init(); // 初始化时钟

    qgic_init(); // 初始化ARM GIC中断控制器

    qtimer_init(); // 初始化timer，只是获取了计时器的频率

    scm_init(); // 初始化Secure Channel Manager，用于和tz进行通信

}

5. target_early_init()。

void target_early_init(void)

{

#if WITH_DEBUG_UART

    uart_dm_init(8, 0, BLSP2_UART1_BASE); // 初始化串口，lk的log可以通过串口打印到终端

#endif

}

6. call_constructors()。

static void call_constructors(void) // 目前好像没有实际用到

{

    void **ctor;

    ctor = &__ctor_list;

    while(ctor != &__ctor_end) {

        void (*func)(void);

        func = (void (*)())*ctor;

        func();

        ctor++;

    }

}

7. heap_init()。

void heap_init(void)

{

    LTRACE_ENTRY;

    // set the heap range

    theheap.base = (void *)HEAP_START; // lk bss段的结束地址

    theheap.len = HEAP_LEN; // lk的内存空间结束地址减去lk bss段的结束地址，由于lk的MEMSIZE只有4MB，自身还要使用一部分，因此剩余的内存很少了

    LTRACEF("base %p size %zd bytes\n", theheap.base, theheap.len);

    // initialize the free list

    list_initialize(&theheap.free_list); // 初始化空闲的heap链表

    // create an initial free chunk

    heap_insert_free_chunk(heap_create_free_chunk(theheap.base, theheap.len)); // 现将所有heap可用内存创建一个大的chunk，然后将它插入空闲的heap链表中

    // dump heap info

//    heap_dump();

//    dprintf(INFO, "running heap tests\n");

//    heap_test();

}

8. thread_init()。

void thread_init(void)

{

#if PLATFORM_HAS_DYNAMIC_TIMER // 宏未定义，不关注

    timer_initialize(&preempt_timer);

#endif

}

9. dpc_init()。

void dpc_init(void)

{

    event_init(&dpc_event, false, 0); // 初始化一个dpc_event

    thread_resume(thread_create("dpc", &dpc_thread_routine, NULL, DPC_PRIORITY, DEFAULT_STACK_SIZE)); // 创建一个dpc thread，用于在thread退出时，做一些清除动作

}

10. timer_init()。

void timer_init(void)

{

    list_initialize(&timer_queue);

    /* register for a periodic timer tick */

    platform_set_periodic_timer(timer_tick, NULL, 10); /* 10ms */ // 设置一个间隔10ms的timer中断，timer_tick为中断处理函数

}

11. thread_create()和thread_resume()。

详见lk thread分析

12. exit_critical_section()。

static inline __ALWAYS_INLINE void exit_critical_section(void)

{

    critical_section_count--;

    if (critical_section_count == 0)

        arch_enable_ints(); // 当critical_section_count为0时使能中断

}

13. thread_become_idle()。
    

void thread_become_idle(void)

{

    thread_set_name("idle"); // 将bootstrap线程改名为idle线程

    thread_set_priority(IDLE_PRIORITY); // 将优先级降为最低

    idle_thread = current_thread; // idle_thread指向当前线程

    idle_thread_routine();

}

static void idle_thread_routine(void)

{

    for(;;)

        arch_idle();

}

FUNCTION(arch_idle)

#if ARM_CPU_CORTEX_A8

    wfi // Wait for interrupt,等待中断唤醒，进入cpu idle状态

#elif ARM_CPU_ARM1136 || ARM_CPU_ARM926

    mov    r0, #0

    mcr    p15, 0, r0, c7, c0, #4

#elif ARM_CPU_ARM7

    /* nothing to do here */

#else

#error unknown cpu

#endif

    bx    lr