痞子衡嵌入式:实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形(有预取)


  大家好,我是痞子衡,是正经搞技术的痞子。今天痞子衡给大家介绍的是实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形

  上一篇文章 《实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形(无缓存)》 里痞子衡抓取了Cache和Prefetch全部关闭下的AHB读访问对应的Flash端时序波形图,相信大家对最基本的FlexSPI读访问支持有了感性认识。根据那篇文章我们知道,没有缓存加持的Flash访问,效率是相当低的。应用程序中对同一Flash地址空间的重复访问,FlexSPI底层每次都机械似的再读一次Flash,这就算了,甚至于代码中的大数据块的Flash读访问还会被拆分成多个不高于8byte的小数据块访问时序(每个CS有效期间前20个SCK周期都不是数据序列),这实在是浪费了太多时间(SCK周期)。

  针对这种同一Flash地址空间的重复访问低效情况,FlexSPI模块中集成了预取(Prefetch)技术,今天痞子衡就来继续测一测开启Prefetch功能下的Flash AHB读访问情形(注意本文不涉及内核的L1 Cache技术):

一、FlexSPI的预取功能

  FlexSPI模块内部一共有4个AHB RX Buffer,总大小是1KB(针对i.MXRT1050而言),用户可以自由配置这四个Buffer,这些AHB RX Buffer可以特殊指定给具体AHB master,并且还可以配置各自优先级,具体可以查阅芯片参考手册FlexSPI章节的 AHB RX Buffer Management 小节。

  这些AHB RX Buffer就是专门为Prefetch功能准备的,有了AHB RX Buffer,FlexSPI模块就可以在用户程序代码之上做些优化工作。比如代码中发生了Flash访问操作,在一次CS有效周期内FlexSPI直接按相应AHB RX Buffer长度来读取数据缓存下来,而不是按照代码中指定的读取长度,这样可以大大减少因AHB Burst Read策略导致的CS信号拆分情况,而且如果下次同一master要取的数据恰好在AHB RX Buffer里,FlexSPI就不用再重新去Flash里读取数据了。

  Prefetch功能说起来就上面那么简单的一段话,但是细细分析这段话,其实还是有如下一些小疑问在里面的,这些疑问痞子衡将用测试结果来给你解答。

  • 疑问1: 发生预取操作时,AHB RX Buffer是从哪里开始缓存?一定是代码里实际指定的Flash读取操作起始地址吗?
  • 疑问2: 一旦发生了预取操作,一定是持续到当前AHB RX Buffer满才会中止吗?有没有被打断的可能性?

  关于AHB RX Buffer的配置,有很多种不同的策略,痞子衡今天要测的主要是BootROM里启用的一种最简单直接的策略,即AHB RX Buffer 0 - 2全部关掉,仅启用AHB RX Buffer 3,总1KB RX Buffer空间全部给这个AHB RX Buffer 3,所有master均通过AHB RX Buffer 3来访问Flash,且访问优先级一致。

二、Prefetch实验准备

  参考文章 《实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形(无缓存)》 里的第一小节 实验准备,本次实验需要做一样的准备工作。

三、Prefetch实验代码

  参考文章 《实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形(无缓存)》 里的第二小节 实验代码,本次实验代码关于工程和链接文件方面是一样的设置,但是具体测试函数改成如下ramfunc型函数 test_prefetch_read()。关于Prefetch这次会有很多种不同测试,while(1)语句前的系统配置保持不变,while(1)里面的语句可根据实际测试情况去调整:

#if (defined(__ICCARM__))
#pragma optimize = none
__ramfunc 
#endif
void test_prefetch_read(void)
{
    // 系统配置
    /* Disable L1 I-Cache*/
    SCB_DisableICache();

    /* Disable L1 D-Cache*/
    SCB_DisableDCache();

    /* Enable FlexSPI AHB read prefetch */
    FLEXSPI->AHBCR |= (FLEXSPI_AHBCR_PREFETCHEN_MASK | FLEXSPI_AHBCR_CACHABLEEN_MASK);
    for (uint32_t index = 0; index < FLEXSPI_AHBRXBUFCR0_COUNT; index++)
    {
        FLEXSPI->AHBRXBUFCR0[index] &= ~(FLEXSPI_AHBRXBUFCR0_BUFSZ_MASK | FLEXSPI_AHBRXBUFCR0_MSTRID_MASK | FLEXSPI_AHBRXBUFCR0_PRIORITY_MASK);
    }

    while (1)
    {
        // 测试用例代码,可按情况调整
    } 
}

四、Prefetch实验结果

4.1 循环读取同一数据块(1KB以内)

  本系列测试用例沿用上一篇文章中特殊const数据区.ahbRdBuffer设置,0x60002400 - 0x600027ff 空间的前16字节是指定的,后面区域就由IDE自由链接应用程序代码数据,我们暂不需要在IO[1:0]信号上具体观察这个区域的数据:

const uint8_t ahbRdBlock[16] @ ".ahbRdBuffer" = {
    0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
    0x20, 0x21, 0x22, 0x23, 0x30, 0x31, 0x32, 0x33,
};
// 在工程链接文件中
keep{ section .ahbRdBuffer };
place at address mem:0x60002400 { readonly section .ahbRdBuffer };
4.1.1 访问首地址按八字节对齐

  先来看最典型的测试,从八字节对齐地址 PREFETCH_TEST_START 处读取 testLen 长度的数据,该函数里第一次memcpy语句的执行便会触发Prefetch机制,当 testLen 不大于 PREFETCH_TEST_MAX_LEN(1KB) 时,Flash端时序波形图都是同一个,即仅产生一次CS低有效周期(后续循环执行均从AHB RX Buffer直接取数据了),低有效持续时间约为65.2us,按SCK周期31.6ns来算,一共有2068个SCK周期,减去读时序里固定前20个命令地址周期,剩2048个数据SCK周期(一个SCK周期传输4bit数据),即读取1KB数据:

#define PREFETCH_TEST_ALIGNMENT  (0) // 可取值 8*n
#define PREFETCH_TEST_START      (0x60002400 + PREFETCH_TEST_ALIGNMENT)
#define PREFETCH_TEST_MAX_LEN    (0x400)
uint32_t testLen = 0x1;  // 可取值 1 - 0x400
void test_prefetch_read(void)
{
    // 略去系统配置
    testLen = (testLen > PREFETCH_TEST_MAX_LEN) ? PREFETCH_TEST_MAX_LEN : testLen;
    while (1)
    {
        memcpy((void *)0x20200000, (void *)PREFETCH_TEST_START, testLen);
    } 
}

4.1.2 访问首地址非八字节对齐,长度小于1KB - 对齐字节

  第二个测试是 PREFETCH_TEST_START 地址并非八字节对齐,这种情况下如果 testLen 不大于1KB - PREFETCH_TEST_ALIGNMENT,那么Flash端时序波形图还是同一个,并且跟上一种测试情况结果是一样的,均是读取1KB数据。放大初始时序图来看,代码中实际Flash读取起始地址是0x60002407,但是FlexSPI的Prefetch机制会将其按八字节向前对齐到0x60002400来读取(实际传输时序里是0x002400三字节地址,输出数据是0x00、0x01、0x02...),这也意味着AHB RX Buffer存储的数据永远是从八字节地址对齐处开始的(回答了第一节里的疑问1)

#define PREFETCH_TEST_ALIGNMENT  (7) // 可取值 1 - 7
#define PREFETCH_TEST_START      (0x60002400 + PREFETCH_TEST_ALIGNMENT)
#define PREFETCH_TEST_MAX_LEN    (0x400 - PREFETCH_TEST_ALIGNMENT)
uint32_t testLen = 0x1;  // 可取值 1 - PREFETCH_TEST_MAX_LEN
void test_prefetch_read(void)
{
    // 略去系统配置
    testLen = (testLen > PREFETCH_TEST_MAX_LEN) ? PREFETCH_TEST_MAX_LEN : testLen;
    while (1)
    {
        memcpy((void *)0x20200000, (void *)PREFETCH_TEST_START, testLen);
    } 
}

4.2 循环读取同一数据块(大于1KB)

  为了便于分辨IO[1:0]上的数据去帮助分析本系列测试用例结果,此处我们需要拓展下特殊const数据区.ahbRdBuffer设置如下:

const uint8_t ahbRdBlock1[1024] @ ".ahbRdBuffer1" = {
    // 正顺序
    0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
    0x20, 0x21, 0x22, 0x23, 0x30, 0x31, 0x32, 0x33,
    // 倒顺序
    0x33, 0x32, 0x31, 0x30, 0x23, 0x22, 0x21, 0x20,
    0x13, 0x12, 0x11, 0x10, 0x03, 0x02, 0x01, 0x00,
};
const uint8_t ahbRdBlock2[1024] @ ".ahbRdBuffer2" = {
    // 正插序
    0x01, 0x00, 0x03, 0x02, 0x11, 0x10, 0x13, 0x12, 
    0x21, 0x20, 0x23, 0x22, 0x31, 0x30, 0x33, 0x32, 
    // 倒插序
    0x32, 0x33, 0x30, 0x31, 0x22, 0x23, 0x20, 0x21, 
    0x12, 0x13, 0x10, 0x11, 0x02, 0x03, 0x00, 0x01, 
};
// 在工程链接文件中
keep{ section .ahbRdBuffer1, section .ahbRdBuffer2 };
place at address mem:0x60002400 { readonly section .ahbRdBuffer1 };
place at address mem:0x60002800 { readonly section .ahbRdBuffer2 };
4.2.1 访问首地址按八字节对齐

  第三个测试是从八字节对齐地址 PREFETCH_TEST_START 处读取 testLen 长度的数据,testLen大于1KB,这种情况下我们在Flash端看到了周期性的波形图,这说明1KB的AHB RX Buffer不足以缓存此时代码里的数据访问需求,因此AHB RX Buffer被不断地清除和重新缓存。放大时序图来看,一个完整周期内,第一个CS有效期间读取了0x60002400开始的1KB数据,第二个CS有效期间读取了0x60002800开始的15个字节数据(总有效时间1.55us),痞子衡知道你肯定觉得奇怪,测试testLen设的是0x401,为何第二个CS期间Prefetch机制缓存的是15个字节?既不是1KB,也不是1byte。这其实是因为第二次CS有效期间的Prefetch操作被下一次while(1)回来的数据访问需求打断了,所以这意味着一旦Prefetch操作被使能,Prefetch机制会尝试缓存到填满AHB RX Buffer,但如果在Buffer满之前有全新的数据访问需求发生,当前Prefetch操作会被中止,Buffer清空,重新开始下一次Prefetch操作(这里回答了第一节里的疑问2)。

#define PREFETCH_TEST_ALIGNMENT  (0) // 可取值 8*n
#define PREFETCH_TEST_START      (0x60002400 + PREFETCH_TEST_ALIGNMENT)
#define PREFETCH_TEST_MIN_LEN    (0x400)
uint32_t testLen = 0x401;  // 可取值 0x401 - 0x800
void test_prefetch_read(void)
{
    // 略去系统配置
    testLen = (testLen <= PREFETCH_TEST_MIN_LEN) ? (PREFETCH_TEST_MIN_LEN + testLen) : testLen;
    while (1)
    {
        memcpy((void *)0x20200000, (void *)PREFETCH_TEST_START, testLen);
    } 
}

  基于上面的分析,我们追加一个实验,在memcpy语句后面加一点软延时,保证第二次CS有效期间Prefetch操作有足够的时间去将AHB RX Buffer填满,我们知道1KB的Flash数据读取约耗时65.2us,我们就延时70us以上试试看,果然这次看到第二个CS也同样持续了65.2us。

void test_prefetch_read(void)
{
    // 略去系统配置
    while (1)
    {
        memcpy((void *)0x20200000, (void *)0x60002400, 0x401);
        SDK_DelayAtLeastUs(70, SystemCoreClock);
    } 
}

4.2.2 访问首地址非八字节对齐

  第四个测试是从非八字节对齐地址处读取超过 1KB 长度的数据,结合4.1节的测试结果,我们可以将代码中的实际语句 memcpy((void *)0x20200001, (void *)0x60002401, 0x401); 做等效转换为 memcpy((void *)0x20200000, (void *)0x60002400, 0x402);,这里就不多贴结果图了。

void test_prefetch_read(void)
{
    // 略去系统配置
    while (1)
    {
        memcpy((void *)0x20200001, (void *)0x60002401, 0x401);
        // 从Flash端信号传输来看,几乎等效于如下语句
        //memcpy((void *)0x20200000, (void *)0x60002400, 0x402);
    } 
}

4.3 循环读取两个不同数据块(1KB以内)

  最后一个实验是循环读取两个不连续数据块,有了前面的测试结果,这个测试的结果也在意料之中了,每个CS持续时间约17us(大约537个SCK周期),实际传输略多于256个byte的数据,这也是符合Prefetch操作会被中止的分析的。如果想看到完整的1KB缓存,memcpy后需要插入至少48.2us以上的软延时。

void test_prefetch_read(void)
{
    // 略去系统配置
    while (1)
    {
        memcpy((void *)0x20200000, (void *)0x60002400, 0x100);
        memcpy((void *)0x20200400, (void *)0x60002800, 0x100);
    } 
}

  至此,实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形痞子衡便介绍完毕了,掌声在哪里~~~

欢迎订阅

文章会同时发布到我的 博客园主页CSDN主页知乎主页微信公众号 平台上。

微信搜索"痞子衡嵌入式"或者扫描下面二维码,就可以在手机上第一时间看了哦。

  最后欢迎关注痞子衡个人微信公众号【痞子衡嵌入式】,一个专注嵌入式技术的公众号,跟着痞子衡一起玩转嵌入式。

痞子衡嵌入式-微信二维码 痞子衡嵌入式-微信收款二维码 痞子衡嵌入式-支付宝收款二维码

  衡杰(痞子衡),目前就职于恩智浦MCU系统部门,担任嵌入式系统应用工程师。

  专栏内所有文章的转载请注明出处:http://www.cnblogs.com/henjay724/

  与痞子衡进一步交流或咨询业务合作请发邮件至 hengjie1989@foxmail.com

  可以关注痞子衡的Github主页 https://github.com/JayHeng,有很多好玩的嵌入式项目。

  关于专栏文章有任何疑问请直接在博客下面留言,痞子衡会及时回复免费(划重点)答疑。

  痞子衡邮箱已被私信挤爆,技术问题不推荐私信,坚持私信请先扫码付款(5元起步)再发。


posted @ 2021-05-07 20:37  痞子衡  阅读(180)  评论(0编辑  收藏  举报