Davinci DM6446 Linux 内核分析——board-evm.c

http://www.61ic.com/Article/DaVinci/DM644X/201201/40304.html

/**************************************************************************
* Included Files
**************************************************************************/

#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/major.h>
#include <linux/root_dev.h>
#include <linux/dma-mapping.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/serial.h>
#include <linux/usb_musb.h>
#include <linux/mtd/nand.h>
#include <linux/serial_8250.h>
#include <linux/davinci_mmc.h>
#include <linux/nand_davinci.h>

#include <asm/setup.h>
#include <asm/io.h>
#include <asm/mach-types.h>

#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/flash.h>
#include <asm/arch/irqs.h>
#include <asm/arch/hardware.h>
#include <asm/arch/edma.h>
#include <linux/kgdb.h>
#include <asm/arch/cpu.h>
#include <asm/arch/mux.h>
#include "clock.h"

/*
内核在启动的时候会运行start_kernel() , 然后它会调用体系结构相关的setup_arch(&command_line), arm体系结构在arch/arm/kernel/setup.c中, 接着初始化平台相关的设备, 但在此之前, 它必须找到这块目标板的描述结构, 所以它会先通过setup_machine,其调用lookup_machine_type(nr)来查找这个结构, 参数是由u-boot传进来的, 存储在r2中. 假设它传入的是DAVINCI_EVM的nr, lookup_machine_type(nr) 就会找到本文件中到最后定义的结构体machine_desc.
start_kernel之前的linux内核启动的详细过程，可参考该文章http://blog.csdn.net/gates84/archive/2007/01/15/1483979.aspx
*/

/**************************************************************************
* Definitions
**************************************************************************/
#define DAVINCI_UART_CLK 27000000 // 串口时钟，与输入的晶振频率相同

/*
* dm644x平台采用8250兼容串口，该数据结构定义了串口的硬件资源，将填充在其platform_device结构体中，
* 即下面的serial_device中。在该platform_devic被注册后，如果其相关的驱动被注册，则会自动找到它，
* 并可调用其中的资源。plat_serial8250_port定义在include/linux/serial_8250.h文件中
*/
static struct plat_serial8250_port serial_platform_data[] = {
{
.membase = (char *)IO_ADDRESS(DAVINCI_UART0_BASE), // 串口0寄存器开始处的虚拟地址是IO_ADDRESS(0x01C20000)
.mapbase = (unsigned long)DAVINCI_UART0_BASE, // 串口0寄存器开始处的实地址是0x01C20000
.irq = IRQ_UARTINT0, // 串口0的中断号是40
.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST,
.iotype = UPIO_MEM32,
.regshift = 2,
.uartclk = DAVINCI_UART_CLK, // 串口时钟频率是27MHz
},
{
.flags = 0,
},
};

/* 见上述解释。platform_device定义在include/linux/device.h文件中
* 一般platform_device在系统启动的时候就注册了，而其相应到驱动platform_driver或device_driver可在模块中加载。
* http://hi.baidu.com/zengzhaonong/blog/item/440bb91e57e5251a413417d9.html 有关于platform_device结构体的详细解释
*/
static struct platform_device serial_device = {
.name = "serial8250", // 这个名字很重要，与对应驱动中的机构体device_driver中的.name相同，其被驱动模块用来查找设备
.id = 0, // 实例名后缀为0
.dev = {
.platform_data = serial_platform_data, // 设备的私有数据或资源
},
};

/* 该数据结构定义了USB的私有数据，主要是usb的类型和功能，musb_hdrc_platform_data定义在include/linux/device.h文件中 */
static struct musb_hdrc_platform_data usb_data[] = {
{
#if defined(CONFIG_USB_MUSB_OTG)
/* OTG requires a Mini-AB connector */
.mode = MUSB_OTG, // OTG类型的usb模块，既可以作usb设备也可以作主机usb使用
#elif defined(CONFIG_USB_MUSB_PERIPHERAL)
.mode = MUSB_PERIPHERAL,
#elif defined(CONFIG_USB_MUSB_HOST) // usb设备
.mode = MUSB_HOST, // 主机usb，类似于电脑的usb功能
#endif
.set_vbus = NULL,
/* irlml6401 switches 5V */
.power = 255, /* sustains 3.0+ Amps (!) */
.potpgt = 4, /* ~8 msec */
.multipoint = 1, // 1个收发端口
}, /* Need Multipoint support */
};

/* 该数据结构定义了USB的硬件资源， resource定义在include/linux/ioport.h文件中 */
static struct resource usb_resources[] = {
{
/* physical address */
.start = DAVINCI_USB_OTG_BASE, // USB_OTG寄存器起始处的实地址是0x01C20000
.end = DAVINCI_USB_OTG_BASE + 0x5ff, // USB_OTG寄存器末尾处的实地址是0x01C20000
.flags = IORESOURCE_MEM, // 标识为IO地址资源
},
{
.start = IRQ_USBINT, // USB_OTG中断号是12
.flags = IORESOURCE_IRQ, // 标识为中断资源
},
};

static u64 usb_dmamask = DMA_32BIT_MASK;

/* usb的platform_device结构体，用于注册usb设备*/
static struct platform_device usb_dev = {
.name = "musb_hdrc", // 与对应驱动中的名字相同,用于绑定驱动
.id = -1, // -1表示只有一个实例，无数字后缀
.dev = {
.platform_data = usb_data, // USB的私有数据
.dma_mask = &usb_dmamask, // 32位的dma
.coherent_dma_mask = DMA_32BIT_MASK,
},
.resource = usb_resources, // USB的硬件资源
.num_resources = ARRAY_SIZE(usb_resources),
};

/* 返回cpu的类型：DaVinci EVM*/
/**************************************************************************
* Public Functions
**************************************************************************/
int cpu_type(void)
{
return MACH_TYPE_DAVINCI_EVM;
}

/* 串口初始化，主要的工作是打开串口时钟，定义在arch/arm/mach-davinci/serial.c文件中*/
extern void davinci_serial_init(struct platform_device *pdev);

/*如果在menuconfig中配置了使用nand启动系统，则下面的的代码将会被编译。
* mtd_partition定义在include/linux/mtd/partitions.h文件中
*/
#if defined (CONFIG_MTD_NAND_DAVINCI) || defined(CONFIG_MTD_NAND_DAVINCI_MODULE)
static struct mtd_partition nand_partitions[] = {
/* bootloader (U-Boot, etc) in first sector */
{
.name = "bootloader", // bootloader，一般使用u-boot
.offset = 0, // 从mtd分区开始地址的偏移量是0
.size = SZ_256K, // 分区大小是256K
.mask_flags = 0, /* force read-only */ // 只读
},
/* bootloader params in the next sector */
{
.name = "params", // 存放bootloader的参数
.offset = MTDPART_OFS_APPEND, // 从上一分区（bootloader分区）开始
.size = SZ_128K,
.mask_flags = MTD_WRITEABLE, /* force read-only */ // 可写
},
/* kernel */
{
.name = "kernel", // 存放内核
.offset = MTDPART_OFS_APPEND,
.size = SZ_4M,
.mask_flags = 0,
},
/* file system */
{
.name = "filesystem", // 存放文件系统
.offset = MTDPART_OFS_APPEND,
.size = MTDPART_SIZ_FULL, // 整个分区的剩余存储空间
.mask_flags = 0,
}
};

/* nand platform device 私有数据，用于描述nand flash banks
* nand_davinci_platform_data定义在include/linux/nand_davinci.h文件中
*/
static struct nand_davinci_platform_data nand_data = {
.options = 0,
.eccmode = NAND_ECC_HW3_512, // 校验模式
.cle_mask = 0x10,
.ale_mask = 0x08,
.bbt_td = NULL,
.bbt_md = NULL,
.parts = nand_partitions, // 分区信息
.nr_parts = ARRAY_SIZE(nand_partitions),
};

/* 定义了nand设备使用的硬件资源 */
static struct resource nand_resources[] = {
[0] = { /* First memory resource is AEMIF control registers */
.start = DM644X_ASYNC_EMIF_CNTRL_BASE,
.end = DM644X_ASYNC_EMIF_CNTRL_BASE + SZ_4K - 1,
.flags = IORESOURCE_MEM,
},
[1] = { /* Second memory resource is NAND I/O window */
.start = DAVINCI_ASYNC_EMIF_DATA_CE0_BASE,
.end = DAVINCI_ASYNC_EMIF_DATA_CE0_BASE + SZ_16K - 1,
.flags = IORESOURCE_MEM,
},
};

/* nand platform_device ,用于注册nand device到platform总线 */
static struct platform_device nand_device = {
.name = "nand_davinci",
.id = 0,
.dev = {
.platform_data = &nand_data,
},

.num_resources = ARRAY_SIZE(nand_resources),
.resource = nand_resources,
};
#endif

/*如果在menuconfig中配置了使用nor启动系统，则下面的的代码将会被编译。
* mtd_partition定义在include/linux/mtd/partitions.h文件中
*/
#if defined (CONFIG_MTD_DAVINCI_NOR) || defined(CONFIG_MTD_DAVINCI_NOR_MODULE)
static struct mtd_partition davinci_evm_nor_partitions[] = {
/* bootloader (U-Boot, etc) in first sector */
{
.name = "bootloader",
.offset = 0,
.size = SZ_128K,
.mask_flags = 0
},
/* bootloader params in the next sector */
{
.name = "params",
.offset = MTDPART_OFS_APPEND,
.size = SZ_128K,
.mask_flags = MTD_WRITEABLE, /* force read-only */
},
/* kernel */
{
.name = "kernel",
.offset = MTDPART_OFS_APPEND,
.size = SZ_4M,
.mask_flags = 0
},
/*cramfs file system */
{
.name = "cramfs",
.offset = MTDPART_OFS_APPEND,
.size = SZ_2M,
.mask_flags = 0
},
/* jffs2 file system */
{
.name = "jffs2", // jffs2文件分区
.offset = MTDPART_OFS_APPEND,
.size = MTDPART_SIZ_FULL,
.mask_flags = 0
}
};

/* nor platform device 私有数据，用于描述nor flash banks
* flash_platform_data定义在include/asm-arm/mach/flash.h文件中
*/
static struct flash_platform_data davinci_evm_flash_data = {
.map_name = "cfi_probe",
.width = 2,
.parts = davinci_evm_nor_partitions,
.nr_parts = ARRAY_SIZE(davinci_evm_nor_partitions),
};

/* 定义了nor设备使用的硬件资源 */
/* NOTE: CFI probe will correctly detect flash part as 32M, but EMIF
;* limits addresses to 16M, so using addresses past 16M will wrap */
static struct resource davinci_evm_flash_resource = {
.start = DAVINCI_ASYNC_EMIF_DATA_CE0_BASE,
.end = DAVINCI_ASYNC_EMIF_DATA_CE0_BASE + SZ_16M - 1,
.flags = IORESOURCE_MEM,
};

/* nor platform_device ,用于注册nor device到platform总线 */
static struct platform_device davinci_evm_flash_device = {
.name = "nor_davinci",
.id = 0,
.dev = {
.platform_data = &davinci_evm_flash_data,
},

.num_resources = 1,
.resource = &davinci_evm_flash_resource,
};
#endif

/* 定义了mmc设备使用的硬件资源 */
#if defined(CONFIG_MMC_DAVINCI) || defined(CONFIG_MMC_DAVINCI_MODULE)
static struct resource mmc0_resources[] = {
[0] = { /* registers */ // 寄存器
.start = DAVINCI_MMC_SD_BASE,
.end = DAVINCI_MMC_SD_BASE + SZ_1K - 1,
.flags = IORESOURCE_MEM,
},
[1] = { /* interrupt */ // 中断号
.start = IRQ_MMCINT,
.end = IRQ_MMCINT,
.flags = IORESOURCE_IRQ,
},
[2] = { /* dma rx */ // dma 接收寄存器
.start = DAVINCI_DMA_MMCRXEVT,
.end = DAVINCI_DMA_MMCRXEVT,
.flags = IORESOURCE_DMA,
},
[3] = { /* dma tx */ // dma 发送寄存器
.start = DAVINCI_DMA_MMCTXEVT,
.end = DAVINCI_DMA_MMCTXEVT,
.flags = IORESOURCE_DMA,
},
};

/* mmc platform device 私有数据，用于描述mmc flash banks
* davinci_mmc_platform_data定义在include/linux/davinci_mmc.h文件中
*/
static struct davinci_mmc_platform_data mmc0_platform_data = {
.mmc_clk = "MMCSDCLK0", // 用于获mmc取时钟
.rw_threshold = 32,
.use_4bit_mode = 1,
};

/* mmc platform_device ,用于注册mmc0_device到platform总线 */
static struct platform_device mmc0_device = {
.name = "mmc",
.id = 0,
.dev = {
.platform_data = &mmc0_platform_data,
},

.num_resources = ARRAY_SIZE(mmc0_resources),
.resource = mmc0_resources,
};

/* 开启mmc模块的电源*/
static void setup_mmc(void)
{
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_MMC_SD0, 1);
}
#else
#define setup_mmc()
#endif

/* platform_device指针数组 */
static struct platform_device *davinci_evm_devices[] __initdata = {
&serial_device,
&usb_dev,
#if defined (CONFIG_MTD_NAND_DAVINCI) || defined(CONFIG_MTD_NAND_DAVINCI_MODULE)
&nand_device,
#endif

#if defined (CONFIG_MTD_DAVINCI_NOR) || defined(CONFIG_MTD_DAVINCI_NOR_MODULE)
&davinci_evm_flash_device,
#endif

#if defined(CONFIG_MMC_DAVINCI) || defined(CONFIG_MMC_DAVINCI_MODULE)
&mmc0_device,
#endif
};

/* 用于设置fiq,irq 的优先级*/
/* FIQ are pri 0-1; otherwise 2-7, with 7 lowest priority */
static const u8 dm644x_default_priorities[DAVINCI_N_AINTC_IRQ] = {
[IRQ_VDINT0] = 2,
[IRQ_VDINT1] = 6,
[IRQ_VDINT2] = 6,
[IRQ_HISTINT] = 6,
[IRQ_H3AINT] = 6,
[IRQ_PRVUINT] = 6,
[IRQ_RSZINT] = 6,
[IRQ_VFOCINT] = 7,
[IRQ_VENCINT] = 6,
[IRQ_ASQINT] = 6,
[IRQ_IMXINT] = 6,
[IRQ_VLCDINT] = 6,
[IRQ_USBINT] = 4,
[IRQ_EMACINT] = 4,
[IRQ_IEEE1394INT] = 7,
[IRQ_IEEE1394WK] = 7,
[IRQ_CCINT0] = 5, /* dma */
[IRQ_CCERRINT] = 5, /* dma */
[IRQ_TCERRINT0] = 5, /* dma */
[IRQ_TCERRINT] = 5, /* dma */
[IRQ_PSCINT] = 7,
[21] = 7,
[IRQ_IDE] = 4,
[IRQ_HPIINT] = 7,
[IRQ_MBXINT] = 7,
[IRQ_MBRINT] = 7,
[IRQ_MMCINT] = 7,
[IRQ_SDIOINT] = 7,
[IRQ_HPIINT] = 7,
[IRQ_DDRINT] = 7,
[IRQ_AEMIFINT] = 7,
[IRQ_VLQINT] = 4,
[IRQ_TINT0_TINT12] = 2, /* clockevent */
[IRQ_TINT0_TINT34] = 2, /* clocksource */
[IRQ_TINT1_TINT12] = 7, /* DSP timer */
[IRQ_TINT1_TINT34] = 7, /* system tick */
[IRQ_PWMINT0] = 7,
[IRQ_PWMINT1] = 7,
[IRQ_PWMINT2] = 7,
[IRQ_I2C] = 3,
[IRQ_UARTINT0] = 3,
[IRQ_UARTINT1] = 3,
[IRQ_UARTINT2] = 3,
[IRQ_SPINT0] = 3,
[IRQ_SPINT1] = 3,
[45] = 7,
[IRQ_DSP2ARM0] = 4,
[IRQ_DSP2ARM1] = 4,
[IRQ_GPIO0] = 7,
[IRQ_GPIO1] = 7,
[IRQ_GPIO2] = 7,
[IRQ_GPIO3] = 7,
[IRQ_GPIO4] = 7,
[IRQ_GPIO5] = 7,
[IRQ_GPIO6] = 7,
[IRQ_GPIO7] = 7,
[IRQ_GPIOBNK0] = 7,
[IRQ_GPIOBNK1] = 7,
[IRQ_GPIOBNK2] = 7,
[IRQ_GPIOBNK3] = 7,
[IRQ_GPIOBNK4] = 7,
[IRQ_COMMTX] = 7,
[IRQ_COMMRX] = 7,
[IRQ_EMUINT] = 7,
};

/* davinci平台初始化，主要是开启各模块到电源。dm644x平台到电源管理是分模块到，不使用到时候关掉，可降低功耗。
* 所以需要使用哪个模块，必须在程序中打开，打开后才能设置相应的寄存器。
*/
static void board_init(void)
{
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_VLYNQ, 1);

board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_VPSSMSTR, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_VPSSSLV, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_TPCC, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_TPTC0, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_TPTC1, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_GPIO, 1);

/* Turn on WatchDog timer LPSC. Needed for RESET to work */
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_TIMER2, 1);

davinci_serial_init(&serial_device); // 初始化串口
}

/* dm644x平台许多功能模块到引脚是gpio复用到，功能引脚和gpio脚是互斥的 ，
* 该函数用来设置这些引脚.
*/
static void dm644x_setup_pinmux(unsigned int id)
{
switch (id) {
case DAVINCI_LPSC_ATA:
davinci_cfg_reg(DM644X_HDIREN);
davinci_cfg_reg(DM644X_ATAEN);
break;
case DAVINCI_LPSC_MMC_SD0:
/* VDD power manipulations are done in U-Boot for CPMAC
* so applies to MMC as well
*/
/*Set up the pull register for MMC */
DAVINCI_VDD3P3V_PWDN = 0x0;
davinci_cfg_reg(DM644X_MSTK);
break;
case DAVINCI_LPSC_I2C:
davinci_cfg_reg(DM644X_I2C);
break;
case DAVINCI_LPSC_McBSP0:
davinci_cfg_reg(DM644X_MCBSP0);
break;
case DAVINCI_LPSC_PWM0:
davinci_cfg_reg(DM644X_PWM0);
break;
case DAVINCI_LPSC_PWM1:
davinci_cfg_reg(DM644X_PWM1);
break;
case DAVINCI_LPSC_PWM2:
davinci_cfg_reg(DM644X_PWM2);
break;
case DAVINCI_LPSC_VLYNQ:
davinci_cfg_reg(DM644X_VLINQEN);
davinci_cfg_reg(DM644X_VLINQWD);
break;
default:
break;

}
}

/* 用于设置各中断的优先级，
* 该指针定义在arch/arm/mach-davinci/irq.c中
*/
extern const u8 *davinci_def_priorities;

/* 初始化IO口，开启各模块电源 */
static void __init davinci_map_io(void)
{
davinci_pinmux_setup = dm644x_setup_pinmux;
davinci_def_priorities = dm644x_default_priorities;
davinci_map_common_io();

#ifdef CONFIG_KGDB_8250
early_serial_setup((struct uart_port *)
&serial_platform_data[kgdb8250_ttyS]);
kgdb8250_add_platform_port(kgdb8250_ttyS,
&serial_platform_data[kgdb8250_ttyS]);
#endif
/* Initialize the DaVinci EVM board settigs */
board_init ();
}

/* 初始化平台irq，该函数在arch/arm/mach-davinci/irq.c中定义 */
int __init davinci_gpio_irq_setup(void);

void davinci_msp430_deep_sleep(void)
{
unsigned int icstr = DAVINCI_I2C_BASE + 0x08;
unsigned int icsar = DAVINCI_I2C_BASE + 0x1C;
unsigned int iccnt = DAVINCI_I2C_BASE + 0x14;
unsigned int icdxr = DAVINCI_I2C_BASE + 0x20;
unsigned int icmdr = DAVINCI_I2C_BASE + 0x24;
u32 cnt = 0, buflen = 2;
char rtcdata[2] = { 2, 8 };
char *buffer = rtcdata;

/* check for bus busy */
while (readl(icstr) & 0x1000) ;

/* configure the count register */
writel(2, iccnt);

/* set the salve address */
writel(0x23, icsar);

/* Take I2C out of reset, configure it as master,
* set the start bit, stop bit and enable the
* transmitter */
writel(0x2e20, icmdr);

while (cnt < buflen) {
if ((readl(icstr) & 0x0010) != 0) {
writel(*buffer, icdxr);
++buffer;
++cnt;
}
}
}

/* 该驱动的初始化函数 */
static __init void evm_init(void)
{
#if defined (CONFIG_MTD_DAVINCI_NOR) || defined(CONFIG_MTD_DAVINCI_NOR_MODULE)
#if defined(CONFIG_BLK_DEV_DAVINCI) || defined(CONFIG_BLK_DEV_DAVINCI_MODULE)
#warning IDE and NOR flash are are pin-muxed. Disable IDE or NOR.
printk(KERN_WARNING "WARNING: both IDE and NOR flash are enabled, "
"but are pin-muxed.\n\t Disable IDE or NOR support.\n");
#endif
#if defined (CONFIG_MTD_NAND_DAVINCI) || defined(CONFIG_MTD_NAND_DAVINCI_MODULE)
#warning NAND and NOR flash are are pin-muxed. Disable NAND or NOR.
printk(KERN_WARNING "WARNING: both NAND and NOR flash are enabled, "
"but are pin-muxed.\n\t Disable NAND or NOR support.\n");
#endif
#endif

#if defined(CONFIG_BLK_DEV_DAVINCI) || defined(CONFIG_BLK_DEV_DAVINCI_MODULE)
#if defined (CONFIG_MTD_NAND_DAVINCI) || defined(CONFIG_MTD_NAND_DAVINCI_MODULE)
#warning IDE and NAND flash are are pin-muxed. Disable IDE or NAND.
printk(KERN_WARNING "WARNING: both IDE and NAND flash are enabled, "
"but are pin-muxed.\n\t Disable IDE or NAND support.\n");
#endif
#endif
pm_power_off = davinci_msp430_deep_sleep;
setup_mmc();
davinci_gpio_irq_setup();
platform_add_devices(davinci_evm_devices, // 注册所有已定义的platform_device
ARRAY_SIZE(davinci_evm_devices));
}

/* 初始化ARM中断控制寄存器函数
* 在arch/arm/mach-davinci/irq.c文件中定义
*/
extern void davinci_irq_init(void);

/* 系统定时器结构体，用于初始化平台的定时器 */
extern struct sys_timer davinci_timer;

/* 定义平台属性，MACHINE_START是个宏定义，用于填充平台描述符结构体machine_desc
* 它们都在include/asm-arm/mach-davinci/arch.h中定义
*
*/
MACHINE_START(DAVINCI_EVM, "DaVinci EVM")
MAINTAINER("Texas Instruments, PSP Team")
BOOT_MEM(DAVINCI_DDR_BASE, IO_PHYS, IO_VIRT) // 定义了DDR2的起始物理地址，IO寄存器的起始物理地址以及IO寄存器的到虚拟地址
BOOT_PARAMS(0x80000100) // bootloader存放启动参数到起始物理地址，系统启动会从中读取各种参数
MAPIO(davinci_map_io) // IO模块初始化，定义在本文件中
INITIRQ(davinci_irq_init)
.timer = &davinci_timer,
INIT_MACHINE(evm_init)
MACHINE_END
EXPORT_SYMBOL(cpu_type)