学习笔记

最新推荐文章于 2022-08-09 15:47:57 发布

dhmama

最新推荐文章于 2022-08-09 15:47:57 发布

阅读量454

点赞数

文章标签： debugging generator generation c flash each

本文链接：https://blog.csdn.net/dhmama/article/details/7705293

版权

飞凌nand flash驱动移植

（一）飞凌的nand驱动目录下（driver/mtd/nand）多出了一个 s3c_nand.c文件

Kconfig文件中多了几个选项：

config MTD_NAND_S3C
   tristate "NAND support for Samsung S3C"
   depends on (ARCH_S3C64XX || ARCH_S5P64XX || ARCH_S5PC1XX) && MTD_NAND
   help
      This enables the NAND flash controller on the S3C

      No board specific support is done by this driver, each board
      must advertise a platform_device for the driver to attach.

config MTD_NAND_S3C_DEBUG
   bool "S3C NAND driver debug"
   depends on MTD_NAND_S3C
   help
      Enable debugging of the S3C NAND driver

config MTD_NAND_S3C_HWECC
   bool "S3C NAND Hardware ECC"
   depends on MTD_NAND_S3C
   help
      Enable the use of the S3C's internal ECC generator when
      using NAND. Early versions of the chip have had problems with
      incorrect ECC generation, and if using these, the default of
      software ECC is preferable.

      If you lay down a device with the hardware ECC, then you will
      currently not be able to switch to software, as there is no
      implementation for ECC method used by the S3C

Makefile中多了一个编译选项：

obj-$(CONFIG_MTD_NAND_S3C) += s3c_nand.o

（二）

s3c_nand.c文件中的函数声明在 /arch/arm/plat-samsung/include/plat/regs.nand.h

和 /include/linux/mtd/partitions.h中。

arch/arm/plat-samsung/dev-nand.c中，

MTD体系结构：

在linux中提供了MTD（Memory Technology Device，内存技术设备）系统来建立Flash针对linux的统一、抽象的接口

引入MTD后，linux系统中的Flash设备驱动及接口可分为4层:

设备节点

MTD设备层

MTD原始设备层

硬件驱动层

硬件驱动层：Flash硬件驱动层负责底层硬件设备实际的读、写、擦除，Linux MTD设备的NAND型Flash驱动位于driver/mtd/nand子目录下

s3c2410对应的nand Flash驱动为s3c2410.c

MTD原始设备层：

原始设备层有两部分组成，一部分是MTD原始设备的通用代码，另一部分是各个特定的Flash的数据，例如分区。

用于描述MTD原始设备的数据结构是mtd_info，这其中定义了大量的关于MTD的数据和操作函数。

mtd_table（mtdcore.c）则是所有MTD原始设备的列表，mtd_part（mtd_part.c）是用于表示MTD原始设备分区的结构，其中包含了mtd_info，因为每一个分区都是被看成一个MTD原始设备加在mtd_table中的，mtd_part.mtd_info中的大部分数据都从该分区的主分区mtd_part->master中获得。

在drivers/mtd/maps/子目录下存放的是特定的flash的数据，每一个文件都描述了一块板子上的flash。其中调用add_mtd_device()、del_mtd_device()建立/删除 mtd_info结构并将其加入/删除mtd_table（或者调用add_mtd_partition()、del_mtd_partition() （mtdpart.c）建立/删除mtd_part结构并将mtd_part.mtd_info加入/删除mtd_table 中）。

mtd层用一个数组struct mtd_info *mtd_table[MAX_MTD_DEVICES]保存系统中所有的设备，mtd设备利用struct mtd_info 这个结构来描述，该结构中描述了存储设备的基本信息和具体操作所需要的内核函数，mtd系统的那个机制主要就是围绕这个结构来实现的。

结构体在include/linux/mtd/mtd.h中定义：

struct mtd_info {

u_char type; //MTD 设备类型

u_int32_t flags; //MTD设备属性标志

u_int32_t size; //标示了这个mtd设备的大小

u_int32_t erasesize; //MTD设备的擦除单元大小，对于NandFlash来说就是Block的大小

u_int32_t oobblock; //oob区在页内的位置，对于512字节一页的nand来说是512

u_int32_t oobsize; //oob区的大小，对于512字节一页的nand来说是16

u_int32_t ecctype; //ecc校验类型

u_int32_t eccsize; //ecc的大小

char *name; //设备的名字

int index; //设备在MTD列表中的位置

struct nand_oobinfo oobinfo; //oob区的信息，包括是否使用ecc，ecc的大小

//以下是关于mtd的一些读写函数，将在nand_base中的nand_scan中重载

int (*erase)

int (*read)

int (*write)

int (*read_ecc)

int (*write_ecc)

int (*read_oob)

void *priv;//设备私有数据指针，对于NandFlash来说指nand芯片的结构

下面看nand_chip结构，在include/linux/mtd/nand.h中定义：

struct nand_chip {

void __iomem *IO_ADDR_R; //这是nandflash的读写寄存器

void __iomem *IO_ADDR_W;

//以下都是nandflash的操作函数，这些函数将根据相应的配置进行重载

u_char (*read_byte)(struct mtd_info *mtd);

void (*write_byte)(struct mtd_info *mtd, u_char byte);

u16 (*read_word)(struct mtd_info *mtd);

void (*write_word)(struct mtd_info *mtd, u16 word);

void (*write_buf)(struct mtd_info *mtd, const u_char *buf, int len);

void (*read_buf)(struct mtd_info *mtd, u_char *buf, int len);

int (*verify_buf)(struct mtd_info *mtd, const u_char *buf, int len);

void (*select_chip)(struct mtd_info *mtd, int chip);

int (*block_bad)(struct mtd_info *mtd, loff_t ofs, int getchip);

int (*block_markbad)(struct mtd_info *mtd, loff_t ofs);

void (*hwcontrol)(struct mtd_info *mtd, int cmd);

int (*dev_ready)(struct mtd_info *mtd);

void (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr);

int (*waitfunc)(struct mtd_info *mtd, struct nand_chip *this, int state);

int (*calculate_ecc)(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code);

int (*correct_data)(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc);

void (*enable_hwecc)(struct mtd_info *mtd, int mode);

void (*erase_cmd)(struct mtd_info *mtd, int page);

int (*scan_bbt)(struct mtd_info *mtd);

int eccmode; //ecc的校验模式（软件，硬件）

int chip_delay; //芯片时序延迟参数

int page_shift; //页偏移，对于512B/页的，一般是9

u_char *data_buf; //数据缓存区

MTD原始设备层与FLASH硬件驱动之间的交互。

一个MTD原始设备可以通过mtd_part分割成数个MTD原始设备注册进mtd_table，mtd_table中的每个MTD原始设备都可以被注册成一个MTD设备，有两个函数可以完成这个工作，即 add_mtd_device函数和add_mtd_partitions函数。

其中add_mtd_device函数是把整个NAND FLASH注册进MTD Core，而add_mtd_partitions函数则是把NAND FLASH的各个分区分别注册进MTD Core。

add_mtd_partitions函数的原型是：
int add_mtd_partitions( struct mtd_info * master,

const struct mtd_partition * parts, int nbparts) ;

其中master就是这个MTD原始设备，parts即NAND的分区信息，nbparts指有几个分区。那么parts和nbparts怎么来？caorr_platform_default_nand 就是起这个作用了。static struct mtd_partition caorr_platform_default_nand[ ] = {
    [ 0] = {
               . name = "Boot Strap" ,
               . offset = 0,
               . size = 0x40000,
    } ,
    [ 1] = {
               . name = "Bootloader" ,
               . offset = MTDPART_OFS_APPEND,
               . size = 0x40000,
    } ,
    [ 2] = {
               . name = "Partition Table" ,
               . offset = MTDPART_OFS_APPEND,
               . size = 0x40000,
    } ,
    [ 3] = {
               . name = "Linux Kernel" ,
               . offset = MTDPART_OFS_APPEND,
               . size = 0x500000,
    } ,
    [ 4] = {
               . name = "Rootfs" ,
               . offset = MTDPART_OFS_APPEND,
               . size = MTDPART_SIZ_FULL,
    } ,
} ;

其中offset是分区开始的偏移地址，在后4个分区我们设为 MTDPART_OFS_APPEND，表示紧接着上一个分区，MTD Core会自动计算和处理分区地址；size是分区的大小，在最后一个分区我们设为MTDPART_SIZ_FULL，表示这个NADN剩下的所有部分。

MTD设备层：

基于MTD原始设备，linux系统可以定义出MTD的块设备（主设备号31）和字符设备（设备号90）。MTD字符设备的定义在mtdchar.c中实现，通过注册一系列file operation函数（lseek、open、close、read、write）。MTD块设备则是定义了一个描述MTD块设备的结构 mtdblk_dev，并声明了一个名为mtdblks的指针数组，这数组中的每一个mtdblk_dev和mtd_table中的每一个 mtd_info一一对应。

Flash 驱动中使用如下两个函数来注册和注销MTD 设备：

int add_mtd_device(struct mtd_info *mtd);

int del_mtd_device (struct mtd_info *mtd)

4、mtd_part 结构体分析此结构定义在 ../drivers/mtd/mtdpart.c 中

struct mtd_part {
struct mtd_info mtd; // 分区的信息（大部分由其 master 决定）
struct mtd_info *master; // 该分区的主分区
uint64_t offset; // 分区的偏移地址
struct list_head list; // 分区号
};

mtd_part 结构体由于表示分区，它在mtd_info 结构体成员用于描述该分区，它会被加入到 mtd_table （定义为 struct mtd_info *mtd_table[MAX_MTD_DEVICES]）中，

其大部分成员有 mtd_part—> 决定，各种函数也指向主分区的相应函数。

5、mtd_partition 结构体分析该结构体定义在 include/linux/mtd/partitions.h 中

struct mtd_partition {
char *name; /* identifier string */ // 标识字符串
uint64_t size; /* partition size */ // 分区大小
uint64_t offset; /* offset within the master MTD space */ // 主MTD空间内的偏移量
uint32_t mask_flags; /* master MTD flags to mask out for this partition */ // 掩码标志
struct nand_ecclayout *ecclayout; /* out of band layout for this partition (NAND only)*/
};

mtd_partttion 会在MTD 原始设备层调用 add_mtd_partitons() 时传递分区信息，并通过下面两个函数进行注册和注销分区：

int add_mtd_partitions( struct mtd_info *master, struct mtd_partition *parts, int nbparts);
int del_mtd_partitions (struct mtd_info *master);

add_mtd_partitions() 会对每一个新建立的分区建立一个新的 mtd_part 结构体，将其加入 mtd_partitions 中，并调用 add_mtd_device () 将此分区作为 MTD 设备加入 mtd_tabe。

第二、NAND Flash 驱动程序分析：

Linux 内核在 MTD的下层实现了通用NAND 驱动（主要通过 drivers/mtd/nand/nand_base.c 文件实现），因此芯片级的驱动不再需要实现 mtd_info 中的： read(), write() ,

read_oob(), write_oob 等成员函数，而主体转移到了 nand_chip 数据结构。

关键词解析：

ALE：地址锁存使能(Address Latch Enable, ALE)：当ALE为高时，在WE#信号的上升沿，地址被锁存到NAND地址寄存器中。

CLE：指令锁存使能(Command Latch Enable, CLE): 当CLE为高时，在WE#信号的上升沿，指令被锁存到NAND指令寄存器中。

BSP：Board Support Package

1、nand_chip 结构体分析该结构体定义在 ./include/linux/mtd/nand.h

struct nand_chip {
void __iomem *IO_ADDR_R; // 读 8 位 I/O 线地址，由主板决定
void __iomem *IO_ADDR_W; // 写 8 为 I/O 线地址，由主板决定
uint8_t (*read_byte)(struct mtd_info *mtd);
u16 (*read_word)(struct mtd_info *mtd);
void (*write_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
void (*read_buf)(struct mtd_info *mtd, uint8_t *buf, int len);
int (*verify_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
void (*select_chip)(struct mtd_info *mtd, int chip); // 片选芯片
int (*block_bad)(struct mtd_info *mtd, loff_t ofs, int getchip); // 是否为坏块
int (*block_markbad)(struct mtd_info *mtd, loff_t ofs); // 标记坏块
void (*cmd_ctrl)(struct mtd_info *mtd, int dat,
unsigned int ctrl); // 控制 AEL/CLE/nCE, 也用于写命令和地址
int (*dev_ready)(struct mtd_info *mtd); // 设备就绪
void (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr);
int (*waitfunc)(struct mtd_info *mtd, struct nand_chip *this);
void (*erase_cmd)(struct mtd_info *mtd, int page);
int (*scan_bbt)(struct mtd_info *mtd);
int (*errstat)(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page);
int (*write_page)(struct mtd_info *mtd, struct nand_chip *chip,
const uint8_t *buf, int page, int cached, int raw);
int chip_delay;
unsigned int options;
int page_shift;
int phys_erase_shift;
int bbt_erase_shift;
int chip_shift;
int numchips;
uint64_t chipsize;
int pagemask;
int pagebuf;
int subpagesize;
uint8_t cellinfo;
int badblockpos;
int badblockbits;
flstate_t state;
uint8_t *oob_poi;
struct nand_hw_control *controller;
struct nand_ecclayout *ecclayout;
struct nand_ecc_ctrl ecc;
struct nand_buffers *buffers;
struct nand_hw_control hwcontrol;
struct mtd_oob_ops ops;
uint8_t *bbt;
struct nand_bbt_descr *bbt_td;
struct nand_bbt_descr *bbt_md;
struct nand_bbt_descr *badblock_pattern;
void *priv;
};

MTD 使用 nand_chip 数据结构表示一个NAND Flash 芯片，这个结构体中包含了关于 NAND Flash 的地址信息、读写方法、ECC模式、硬件控制等一系列底层机制。

2、S3C6410 nand_chip 初始化与 NAND 探测

S3C6410 的 NAND 驱动以 platform 驱动的形式存在，在执行probe() 时，初始化nand_chip 实例并运行 nand_scan 扫描 NAND 设备，最后调用 add_mtd_partitions() 添加主板中定义的分区表，nand_chip 是nanf flash 驱动的核心数据结构，这个结构体重的成员直接对应这 NAND Flash 的底层操作，针对具体情况的NAND 控制器情况

分析 s3c_nand_probe 函数体对 S3C6410 nand_chip 的初始化和注册：该文件定义在 drivers/mtd/nand/s3c_nand.c 中，而在基础内核2.6.36.2 中的这个文件为s3c2410.c

所以如果你想在 Linux 2.6.36.2 的内核对 S3C6410 nand flash 控制器进行支持的话，s3c_nand.c 这个文件需要自己添加。

static int s3c_nand_probe(struct platform_device *pdev, enum s3c_cpu_type cpu_type)
{
struct s3c2410_platform_nand *plat = pdev->dev.platform_data;
struct s3c2410_nand_set *sets;
struct nand_chip *nand;
struct resource *res;
int err = 0;
int ret = 0;
int nr_sets;
int i, j, size;
#if defined(CONFIG_MTD_NAND_S3C_HWECC)
struct nand_flash_dev *type = NULL;
u_char tmp;
u_char dev_id;
#endif
/* get the clock source and enable it */
s3c_nand.clk = clk_get(&pdev->dev, "nand");
if (IS_ERR(s3c_nand.clk)) {
dev_err(&pdev->dev, "failed to get clock");
err = -ENOENT;
goto exit_error;
}
clk_enable(s3c_nand.clk);
/* allocate and map the resource */
/* currently we assume we have the one resource */
res = pdev->resource;
size = res->end - res->start + 1;
s3c_nand.area = request_mem_region(res->start, size, pdev->name);
if (s3c_nand.area == NULL) {
dev_err(&pdev->dev, "cannot reserve register region\n");
err = -ENOENT;
goto exit_error;
}
s3c_nand.cpu_type = cpu_type;
s3c_nand.device = &pdev->dev;
s3c_nand.regs = ioremap(res->start, size);
s3c_nand.platform = plat;
if (s3c_nand.regs == NULL) {
dev_err(&pdev->dev, "cannot reserve register region\n");
err = -EIO;
goto exit_error;
}
sets = (plat != NULL) ? plat->sets : NULL;
nr_sets = (plat != NULL) ? plat->nr_sets : 1;
s3c_nand.mtd_count = nr_sets;
/* allocate memory for MTD device structure and private data */
s3c_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
if (!s3c_mtd) {
printk("Unable to allocate NAND MTD dev structure.\n");
return -ENOMEM;
}
/* Get pointer to private data */
nand = (struct nand_chip *) (&s3c_mtd[1]);
/* Initialize structures */
memset((char *) s3c_mtd, 0, sizeof(struct mtd_info));
memset((char *) nand, 0, sizeof(struct nand_chip));
/* Link the private data with the MTD structure */
s3c_mtd->priv = nand;
for (i = 0; i < sets->nr_chips; i++) {
nand->IO_ADDR_R = (char *)(s3c_nand.regs + S3C_NFDATA); // 初始化 IO_ADDR_R
nand->IO_ADDR_W = (char *)(s3c_nand.regs + S3C_NFDATA); // 初始化 IO_ADDR_W
nand->cmd_ctrl = s3c_nand_hwcontrol; // 初始化 cmd_crtl()
nand->dev_ready = s3c_nand_device_ready; // 初始化 dev_read()
nand->scan_bbt = s3c_nand_scan_bbt; // 初始化 scan_bbt()
nand->options = 0;
#if defined(CONFIG_MTD_NAND_S3C_CACHEDPROG)
nand->options |= NAND_CACHEPRG;
#endif
#if defined(CONFIG_MTD_NAND_S3C_HWECC)
nand->ecc.mode = NAND_ECC_HW;
nand->ecc.hwctl = s3c_nand_enable_hwecc;
nand->ecc.calculate = s3c_nand_calculate_ecc;
nand->ecc.correct = s3c_nand_correct_data;
s3c_nand_hwcontrol(0, NAND_CMD_READID, NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
s3c_nand_hwcontrol(0, 0x00, NAND_CTRL_CHANGE | NAND_NCE | NAND_ALE);
s3c_nand_hwcontrol(0, 0x00, NAND_NCE | NAND_ALE);
s3c_nand_hwcontrol(0, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
s3c_nand_device_ready(0);
tmp = readb(nand->IO_ADDR_R); /* Maf. ID */ // 制造商ID
dev_id = tmp = readb(nand->IO_ADDR_R); /* Device ID */ // 设备ID
for (j = 0; nand_flash_ids[j].name != NULL; j++) {
if (tmp == nand_flash_ids[j].id) {
type = &nand_flash_ids[j];
break;
}
}
if (!type) {
printk("Unknown NAND Device.\n");
goto exit_error;
}
nand->cellinfo = readb(nand->IO_ADDR_R); /* the 3rd byte */ // 第3个字节
tmp = readb(nand->IO_ADDR_R); /* the 4th byte */ // 第4个字节
if (!type->pagesize) {
if (((nand->cellinfo >> 2) & 0x3) == 0) {
nand_type = S3C_NAND_TYPE_MLC_4BIT;
nand->options |= NAND_NO_SUBPAGE_WRITE; /* NOP = 1 if MLC */
nand->ecc.read_page = s3c_nand_read_page_4bit;
nand->ecc.write_page = s3c_nand_write_page_4bit;
nand->ecc.size = 512;
nand->ecc.bytes = 8; /* really 7 bytes */
if ((1024 << (tmp & 0x3)) > 512) {
nand->ecc.layout = &s3c_nand_oob_mlc_64;
} else {
nand->ecc.layout = &s3c_nand_oob_16;
}
/*
nand_type = S3C_NAND_TYPE_SLC;
nand->ecc.size = 512;
nand->ecc.bytes = 4;
if ((1024 << (tmp & 0x3)) > 512) {
nand->ecc.read_page = s3c_nand_read_page_1bit;
nand->ecc.write_page = s3c_nand_write_page_1bit;
nand->ecc.read_oob = s3c_nand_read_oob_1bit;
nand->ecc.write_oob = s3c_nand_write_oob_1bit;
nand->ecc.layout = &s3c_nand_oob_64;
} else {
nand->ecc.layout = &s3c_nand_oob_16;
}
*/
} else {
nand_type = S3C_NAND_TYPE_MLC_4BIT;
nand->options |= NAND_NO_SUBPAGE_WRITE; /* NOP = 1 if MLC */
nand->ecc.read_page = s3c_nand_read_page_4bit;
nand->ecc.write_page = s3c_nand_write_page_4bit;
nand->ecc.size = 512;
nand->ecc.bytes = 8; /* really 7 bytes */
nand->ecc.layout = &s3c_nand_oob_mlc_64;
if(dev_id == 0xd5)
{
printk("dev_id == 0xd5 select s3c_nand_oob_mlc_128\n");
nand_type = S3C_NAND_TYPE_MLC_8BIT;
nand->ecc.read_page = s3c_nand_read_page_8bit;
nand->ecc.write_page = s3c_nand_write_page_8bit;
nand->ecc.size = 512;
nand->ecc.bytes = 13; /* really 7 bytes */
nand->ecc.layout = &s3c_nand_oob_mlc_128_8bit;
}
}
} else {
nand_type = S3C_NAND_TYPE_SLC;
nand->ecc.size = 512;
nand->cellinfo = 0;
nand->ecc.bytes = 4;
nand->ecc.layout = &s3c_nand_oob_16;
}
printk("S3C NAND Driver is using hardware ECC.\n");
#else
nand->ecc.mode = NAND_ECC_SOFT;
printk("S3C NAND Driver is using software ECC.\n");
#endif
if (nand_scan(s3c_mtd, 1)) {
ret = -ENXIO;
goto exit_error;
}
/* Register the partitions */
add_mtd_partitions(s3c_mtd, sets->partitions, sets->nr_partitions); // 注册分区信息
}
pr_debug("initialized ok\n");
return 0;
exit_error:
kfree(s3c_mtd);
return ret;
}

drivers/mtd/nand/s3c_nand.c 是一个platform 驱动，加入我们需要移植 OK6410 的 NAND Flash 驱动这要在 OK6410 的BSP（板级支持包）中田间针对 NAND 的 platform 设备和分区信息即可，也就是在 arch/arm/mach-s3c64xx/mach-smdk6410.c 中添加这些信息，就可以将上面的NAND Flash 驱动移植成功。

参考文献：设备驱动开发详解（第2版）华清远见宋宝华著 http://www.linuxidc.com/Linux/2011-04/35312.htm

NAND Flash驱动移植方法、可以参考我的上篇文章：http://www.linuxidc.com/Linux/2012-04/59293.htm

将这篇文章和上一篇文章（ http://www.linuxidc.com/Linux/2012-04/59293.htm）一起来阅读，理解 NAND Flash驱动就能容易些了

plat/map-base.h 含有LCD驱动函数的定义。

s3c_device_fimc0 在 plat-samsung/dev-fimc0.c 和 dev-fimc1.c中调用。

s3c_device_fimc0 在plat-samsung/include/devs.h中定义。

dhmama

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习笔记

飞凌nand flash驱动移植（一）飞凌的nand驱动目录下（driver/mtd/nand）多出了一个 s3c_nand.c文件Kconfig文件中多了几个选项：config MTD_NAND_S3C tristate "NAND support for Samsung S3C" depends on (ARCH_S3C64XX || ARCH_S5
复制链接

扫一扫