NAND FLASH驱动

最新推荐文章于 2022-10-07 16:47:37 发布
最新推荐文章于 2022-10-07 16:47:37 发布
阅读量587 收藏
点赞数
文章标签： flash struct c io timer structure
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangkaiblog/article/details/7538828
版权 
S3C6410的 NAND 驱动以 platform驱动的形式存在。
 
static int __init s3c_nand_init(void)
{
	printk("S3C NAND Driver, (c) 2008 Samsung Electronics\n");

	platform_driver_register(&s3c2450_nand_driver);
	platform_driver_register(&s3c6400_nand_driver);
	return platform_driver_register(&s3c6410_nand_driver);
}

static void __exit s3c_nand_exit(void)
{
	platform_driver_unregister(&s3c2450_nand_driver);
	platform_driver_unregister(&s3c6400_nand_driver);
	platform_driver_unregister(&s3c6410_nand_driver);
}





 
static struct platform_driver s3c6410_nand_driver = {
	.probe		= s3c6410_nand_probe,
	.remove		= s3c_nand_remove,
	.suspend	= s3c_nand_suspend,
	.resume		= s3c_nand_resume,
	.driver		= {
		.name	= "s3c6410-nand",
		.owner	= THIS_MODULE,
	},
};



static int s3c6410_nand_probe(struct platform_device *dev)
{
	return s3c_nand_probe(dev, TYPE_S3C6410);
}


 


其中：


enum s3c_cpu_type {
	TYPE_S3C2450,	/* including s3c2416 */
	TYPE_S3C6400,
	TYPE_S3C6410,	/* including s3c6430/31 */
};




 


/* s3c_nand_probe
 *
 * called by device layer when it finds a device matching
 * one our driver can handled. This code checks to see if
 * it can allocate all necessary resources then calls the
 * nand layer to look for devices
 */
static int s3c_nand_probe(struct platform_device *pdev, enum s3c_cpu_type cpu_type)
{	
	struct s3c_nand_mtd_info *plat_info = pdev->dev.platform_data;
	struct mtd_partition *partition_info = (struct mtd_partition *)plat_info->partition;
	struct nand_chip *nand;
	struct resource *res;
	int err = 0;
	int ret = 0;
	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;

	//申请I/O内存，设备通常会提供一组寄存器来用于控制设备、读写设备和获取设备状态，这些寄存器为与I/O空间，也可能位于内存空间。当位于IO空间时，通常称为IO端口，位于内存空间时，对应的内存空间称为 IO 内存。
	//在内核中访问I/O 内存前，需要首先使用ioremap（）函数将设备所处的物理地址映射到虚拟地址。ioremap()函数原型如下：
	void *ioremap(unsigned long offset, unsigned long size); ioremap()与vmlloc()类似，也需要建立页表，但是它并不进行vmlloc()函数中所执行的内存分配行为。ioremap()返回一个特殊的虚拟地址。。。。。在设备的物理地址被映射到虚拟地址之后，尽管尅有直接通过指针访问这些地址，但是可以使用linux内核的一组函数来完成设备内存映射的虚拟地址的读写。
	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);

	if (s3c_nand.regs == NULL) {
		dev_err(&pdev->dev, "cannot reserve register region\n");
		err = -EIO;
		goto exit_error;
	}

	/* 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 < plat_info->chip_nr; i++) {
		nand->IO_ADDR_R		= (char *)(s3c_nand.regs + S3C_NFDATA);
		nand->IO_ADDR_W		= (char *)(s3c_nand.regs + S3C_NFDATA);
		nand->cmd_ctrl		= s3c_nand_hwcontrol;
		nand->dev_ready		= s3c_nand_device_ready;		
		nand->scan_bbt		= s3c_nand_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 */
		dev_id = tmp = readb(nand->IO_ADDR_R); /* Device 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 */
		tmp = readb(nand->IO_ADDR_R);			/* the 4th byte */

		if (!type->pagesize) {
			if (((nand->cellinfo >> 2) & 0x3) == 0) {
				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;
				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((1024 << (tmp & 0x3)) > 2048)
					nand->ecc.layout = &s3c_nand_oob_mlc_128;		
			}
		} 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;
*/
			nand_type = S3C_NAND_TYPE_MLC;
			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)
				nand->ecc.layout = &s3c_nand_oob_mlc_128;		
		}

		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, partition_info, plat_info->mtd_part_nr);
	}

	pr_debug("initialized ok\n");
	return 0;

exit_error:
	kfree(s3c_mtd);

	return ret;
}





drivers/mtd/nand/s3c_nand.c是一个platform驱动，我们在S3C6410的BSP中只需要添加相关的NAND的platform的设备和分区信息即可。




在BSP中添加相应的信息如下：[ 下面有关于这部分的分析]


static void __init smdk6410_map_io(void)
{
	s3c_device_nand.name = "s3c6410-nand";

	s3c64xx_init_io(smdk6410_iodesc, ARRAY_SIZE(smdk6410_iodesc));
	s3c24xx_init_clocks(12000000);
	s3c24xx_init_uarts(smdk6410_uartcfgs, ARRAY_SIZE(smdk6410_uartcfgs));
}




smdk6410_map_io() 在下面出现。


MACHINE_START(SMDK6410, "SMDK6410")
	/* Maintainer: Ben Dooks <ben@fluff.org> */
	.phys_io	= S3C_PA_UART & 0xfff00000,
	.io_pg_offst	= (((u32)S3C_VA_UART) >> 18) & 0xfffc,
	.boot_params	= S3C64XX_PA_SDRAM + 0x100,

	.init_irq	= s3c6410_init_irq,
	.map_io		= smdk6410_map_io,
	.init_machine	= smdk6410_machine_init,
	.timer		= &s3c24xx_timer,
MACHINE_END




 


struct platform_device s3c_device_nand = {
	.name		  = "s3c-nand",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_nand_resource),
	.resource	  = s3c_nand_resource,
};




其中关于资源地信息如下：


/* NAND Controller */

static struct resource s3c_nand_resource[] = {
	[0] = {
		.start = S3C64XX_PA_NAND,
		.end   = S3C64XX_PA_NAND + S3C64XX_SZ_NAND - 1,
		.flags = IORESOURCE_MEM,
	}
};




在宏定义的文件/* linux/arch/arm/mach-s3c6400/include/mach/map.h 中，有


/* NAND flash controller */
#define S3C64XX_PA_NAND	   	(0x70200000)
#define S3C64XX_SZ_NAND	   	SZ_1M


 


上面这些信息的出处在 




关于其大小的确定，在datashee的 Memory mapping 一节：




 


在开发板的硬件硬件手册有 更详细的说明。


***************************************************************************************************************


下面的内容参考 了ARM LINUX 静态映射分析


内核提供了一个比较重要的结构体， machine_desc,这个结构体在内核移植的过程中，起着重要的作用。内核通过它来进行体系架构相关部分的初始话。


struct machine_desc {
	/*
	 * Note! The first four elements are used
	 * by assembler code in head.S, head-common.S
	 */
	unsigned int		nr;		/* architecture number	*/
	unsigned int		phys_io;	/* start of physical io	*/
	unsigned int		io_pg_offst;	/* byte offset for io 
						 * page tabe entry	*/

	const char		*name;		/* architecture name	*/
	unsigned long		boot_params;	/* tagged list		*/

	unsigned int		video_start;	/* start of video RAM	*/
	unsigned int		video_end;	/* end of video RAM	*/

	unsigned int		reserve_lp0 :1;	/* never has lp0	*/
	unsigned int		reserve_lp1 :1;	/* never has lp1	*/
	unsigned int		reserve_lp2 :1;	/* never has lp2	*/
	unsigned int		soft_reboot :1;	/* soft reboot		*/
	void			(*fixup)(struct machine_desc *,
					 struct tag *, char **,
					 struct meminfo *);
	void			(*map_io)(void);/* IO mapping function	*/
	void			(*init_irq)(void);
	struct sys_timer	*timer;		/* system tick timer	*/
	void			(*init_machine)(void);
};




machine_desc 通过宏 MACHINE_START 进行初始化。


MACHINE_START(SMDK6410, "SMDK6410")
	/* Maintainer: Ben Dooks <ben@fluff.org> */
	.phys_io	= S3C_PA_UART & 0xfff00000,
	.io_pg_offst	= (((u32)S3C_VA_UART) >> 18) & 0xfffc,
	.boot_params	= S3C64XX_PA_SDRAM + 0x100,

	.init_irq	= s3c6410_init_irq,
	.map_io		= smdk6410_map_io,
	.init_machine	= smdk6410_machine_init,
	.timer		= &s3c24xx_timer,
MACHINE_END





其中 MACHINE_START 宏定义如下：


#define MACHINE_START(_type,_name)			\
static const struct machine_desc __mach_desc_##_type	\
 __used							\
 __attribute__((__section__(".arch.info.init"))) = {	\
	.nr		= MACH_TYPE_##_type,		\
	.name		= _name,

#define MACHINE_END				\
};
 
其中，MACHINE_TYPE 宏的是用了 GCC 扩展。在预编译时，进行字符替换。
 
在mach-types.h文件中 
 


#define MACH_TYPE_SMDK6410             1626


上面 map_io函数，即是，内核提供给用户创建IO资源到内核虚拟地址静态映射表的 接口函数。在系统初始化 ，被调用


start_kernel（）->setup_arch(&command_line)->paging_init(mdesc)>devicemaps_init()-> mdesc->map_io() 中调用。


 


而init_irq 的初始化流程为：


start_kernrl()->init_IRQ()->init_arch_irq()->setup_arch()->init_arch_irq


而上面的init_arch_irq 指针的赋值则在    


start_kernel()->setup_arch（）-》


	 * Set up various architecture-specific pointers
	 */
	init_arch_irq = mdesc->init_irq;
	system_timer = mdesc->timer;
	init_machine = mdesc->init_machine;




接下来，继续分析 smdk6410_map_io（）


static void __init smdk6410_map_io(void)
{
	s3c_device_nand.name = "s3c6410-nand";

	s3c64xx_init_io(smdk6410_iodesc, ARRAY_SIZE(smdk6410_iodesc));
	s3c24xx_init_clocks(12000000);
	s3c24xx_init_uarts(smdk6410_uartcfgs, ARRAY_SIZE(smdk6410_uartcfgs));
}


 


/* read cpu identification code */

void __init s3c64xx_init_io(struct map_desc *mach_desc, int size)
{
	unsigned long idcode;

	/* initialise the io descriptors we need for initialisation */
	iotable_init(s3c_iodesc, ARRAY_SIZE(s3c_iodesc));
	iotable_init(mach_desc, size);

	idcode = __raw_readl(S3C_VA_SYS + 0x118);
	s3c_init_cpu(idcode, cpu_ids, ARRAY_SIZE(cpu_ids));
}





 


/*
 * Create the architecture specific mappings
 */
void __init iotable_init(struct map_desc *io_desc, int nr)
{
	int i;

	for (i = 0; i < nr; i++)
		create_mapping(io_desc + i);
}




由上可知， smdk6410_map_io（）最终 调用create_mapping（）建立映射表。其参数为：


struct map_desc {
	unsigned long virtual;
	unsigned long pfn;
	unsigned long length;
	unsigned int type;
};


 


create_mapping（）就是根据 map_desc提供的信息创建线性映射表的。


。。。。。。。


来看下，S3C6410是怎么创建map_desc结构体的。


/* Initial IO mappings */

static struct map_desc s3c6410_iodesc[] __initdata = {
	IODESC_ENT(LCD),
	IODESC_ENT(SROMC),
	IODESC_ENT(HOSTIFB),
	IODESC_ENT(OTG),
	IODESC_ENT(OTGSFR),
};


 


#define IODESC_ENT(x) { (unsigned long)S3C64XX_VA_##x, __phys_to_pfn(S3C64XX_PA_##x), S3C64XX_SZ_##x, MT_DEVICE }





展开后，等价于：


static struct map_desc s3c6410_iodesc[] __initdata = {
	.virtual    S3C64XX_VA_GPIO),
	.pfn        __phys_to_pfn(S3C64XX_PA_GPIO),
	.length     S3C64XX_SZ_GPIO,
	.type      MTD_DEVICE,
......................
	};


 




至此，我们已经清楚看到了GPIO被静态映射的过程，由于我么在前面的静态映射中，已经做好了相关的映射，所以 在写GPIO相关的驱动的时候。可以直接配置引脚的原因。


s3c_gpio_cfgpin(S3C64XX_GPN(0), S3C_GPIO_SFN(1));


 


2、最终还会调用s3c_init_cpu（）->cpu->map_io( );

static struct cpu_table *cpu;










 


static struct cpu_table *cpu;
 
 
/* per-cpu initialisation function table. */

struct cpu_table {
	unsigned long	idcode;
	unsigned long	idmask;
	void		(*map_io)(void);
	void		(*init_uarts)(struct s3c2410_uartcfg *cfg, int no);
	void		(*init_clocks)(int xtal);
	int		(*init)(void);
	const char	*name;
};




在cpu.c文件
 
/* table of supported CPUs */
static const char name_s3c6400[] = "S3C6400";
static const char name_s3c6410[] = "S3C6410";
 
static struct cpu_table cpu_ids[] __initdata = {
	{
		.idcode		= 0x36400000,
		.idmask		= 0xfffff000,
		.map_io		= s3c6400_map_io,
		.init_clocks	= s3c6400_init_clocks,
		.init_uarts	= s3c6400_init_uarts,
		.init		= s3c6400_init,
		.name		= name_s3c6400,
	}, {
		.idcode		= 0x36410100,
		.idmask		= 0xffffff00,
		.map_io		= s3c6410_map_io,
		.init_clocks	= s3c6410_init_clocks,
		.init_uarts	= s3c6410_init_uarts,
		.init		= s3c6410_init,
		.name		= name_s3c6410,
	},
};

 
/* s3c6410_map_io
 *
 * register the standard cpu IO areas
*/

void __init s3c6410_map_io(void)
{
	iotable_init(s3c6410_iodesc, ARRAY_SIZE(s3c6410_iodesc));

	/* initialise device information early */
	s3c6410_default_sdhci0();
	s3c6410_default_sdhci1();

	/* the i2c devices are directly compatible with s3c2440 */
	s3c_i2c0_setname("s3c2440-i2c");
	s3c_i2c1_setname("s3c2440-i2c");

	/* set our idle function */
	s3c64xx_idle = s3c6410_idle;
}

 
 
/* Initial IO mappings */

static struct map_desc s3c6410_iodesc[] __initdata = {
	IODESC_ENT(LCD),
	IODESC_ENT(SROMC),
	IODESC_ENT(HOSTIFB),
	IODESC_ENT(OTG),
	IODESC_ENT(OTGSFR),
};

 
和前面分析是一样的情况：

/* Initial IO mappings */
static struct map_desc s3c6410_iodesc[] __initdata = {
LCD\SROMC HOSTIFB\ OTG\ OTGSFR.等的静态映射都看 的清楚明白了了。





                

        

        

    

  


    

      

        

            

              
                
                  王凯Android
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
linux_NandFlash_driver_超详细分析

				
			

			

				

					flymachine的专栏
				

				

					11-06
					
					1683
					
				

			

		

		

			
				
今天学习了NandFlash的驱动，硬件操作非常简单，就是这个linux下的驱动比较复杂，主要还是MTD层的问题，用了一下午时间整理出来一份详细的分析，只是分析函数结构和调用关系，具体代码实现就不看了，里面有N个结构体，搞得我头大。
 
我用linux2.6.25内核，2440板子，先从启动信息入手。
内核启动信息，NAND部分：
S3C24XX NAND Driver, (c) 2004

			
		

	



                

              
                



	

		

			

				
					
nandflash驱动

				
			

			

				

					wangxiandou的博客
				

				

					10-07
					
					363
					
				

			

		

		

			
				
nand flash 驱动

			
		

	



                


  
              

                


	

		

			

				
					
Nandflash 驱动

				
			

			

				

					老鹏
				

				

					06-18
					
					1577
					
				

			

		

		

			
				
1. 基本知识

jz2440 中使用的nandflash的型号是 K9F2G08U0M



图中可以看到这个nandflash的结构是：

1页 = (2k + 64) 字节

1块 = 64个页 = ( 2k + 64) x 64 = 128k + 4k 字节

1个设备 = 2048个块 = ...



对于某个字节的访问，地址的组成如上图，是分5个周期发送的，其中 Column是列，R...

			
		

	





	

		

			

				
					
Linux下nandflash驱动

					
最新发布

				
			

			

				

					wangxiandou的博客
				

				

					10-07
					
					630
					
				

			

		

		

			
				
linux nand 

			
		

	



		

			
		



	

		

			

				
					
第19课：nand flash驱动

				
			

			

				

					赶紧十八丶
				

				

					10-24
					
					2574
					
				

			

		

		

			
				
1、参考自带的nand flash驱动,位于drivers/mtd/nand/s3c2410.c中

1.1 为什么nand在mtd目录下？

因为mtd(memory technology device存储技术设备)是用于访问memory设备（ROM、flash ）的Linux的子系统。MTD的主要目的是为了使新的memory设备的驱动更加简单，为此它在硬件和上层之间提供了一个抽象的接口。

1.2首先来看s3c2410.c的入口函数:


static int __init ...

			
		

	





	

		

			

				
					
十七、Linux驱动之nand flash驱动

				
			

			

				

					墨、白的博客
				

				

					12-05
					
					2361
					
				

			

		

		

			
				
1. 基本概念

    Nand-flash存储器是flash存储器的一种，其内部采用非线性宏单元模式，为固态大容量内存的实现提供了廉价有效的解决方案。Nand-flash存储器具有容量较大，改写速度快等优点，适用于大量数据的存储，因而在业界得到了越来越广泛的应用，如嵌入式产品中包括数码相机、MP3随身听记忆卡、体积小巧的U盘等。

2. 硬件分析

    本人使用的是韦东山老师的JZ2440...

			
		

	





	

		

			

				
					
NAND flash驱动程序（1）

				
			

			

				

					lee_jimmy的博客
				

				

					01-27
					
					1838
					
				

			

		

		

			
				
前言

       前面我们已经写过一个块设备驱动程序，用内存来模拟块设备。假如我们想写一个NAND FLASH驱动程序，又应该怎么做呢？我们先看一下kernel代码中别人现成的驱动程序，分析一下流程框架，总结出一个套路，我们就能开始写自己的驱动程序了。

       之前写过一个裸板的nand flash程序：NAND FLASH的读操作及原理，可以参考一下。

正文

       我参考...

			
		

	





	

		

			

				
					
nandflash驱动详解

					
热门推荐

				
			

			

				

					whuzm08的专栏
				

				

					05-23
					
					1万+
					
				

			

		

		

			
				
架构图+-----------+   system bus    +-------------------+      CLE, io[8:0]     +-------------------+ |    cpu        |←------------→  |   nand controler  | ←--------------→   |        nand flash     |+-...

			
		

	





	

		

			

				
					
SPI nandflash 驱动程序

				
			

			

				

					qq_40545297的博客
				

				

					10-22
					
					7358
					
				

			

		

		

			
				
nandflash有并行的，有串行方式的，8脚的SPI nandflash是众多工程师的首选，不占地方容量又大，这里奉上我总结的SPI nandflash驱动程序，不包含坏块管理机制：

H源文件：


#include "stdint.h"



#define MX35LF2G14AC            1



/*** MX35 series command hex code defi...

			
		

	





	

		

			

				
					
《Linux驱动：nand flash驱动看这一篇就够了》

				
			

			

				

					qq_40709487的博客
				

				

					09-11
					
					2673
					
				

			

		

		

			
				
nand flash驱动开发总结，涉及到s3c2440芯片nand flash控制器的设置及操作、K9F2G08U0C nand flash的设置及操作、平台总线-驱动-设备模型等相关知识。系统启动，内核初始化时加载mtdchar模块，调用init_mtdchar，将 struct mtd_notifier 结构注册到mtd_notifiers链表中，供后续nand flash驱动程序使用。if(!

			
		

	





	

		

			

				
					
linux nand flash驱动编写

				
			

			

				

					01-20
				

			

		

		

			
				
对于linux嵌入式来说，开始uboot的加载是硬件完成的，中期的kernel加载是由uboot中的nand flash驱动完成的，而后期的rootfs加载，这就要靠kernel自己来完成了。当然，这次还是以三星s3c芯片为例进行说明。 1、nand ...

			
		

	





	

		

			

				
					
stm32 nand flash 驱动代码

				
			

			

				

					03-10
				

			

		

		

			
				
在本文中，我们将深入探讨如何使用STM32的FSMC（Flexible Static Memory Controller，灵活静态存储器控制器）来驱动NAND Flash，特别是针对K9F1G08型号的NAND Flash。  NAND Flash是一种非易失性存储器，常用于存储...

			
		

	





	

		

			

				
					
嵌入式Linux中的Nand Flash驱动详解.pdf

				
			

			

				

					09-06
				

			

		

		

			
				
嵌入式Linux中的Nand Flash驱动详解  嵌入式Linux系统中的Nand Flash驱动是非常重要的，Nand Flash是一种广泛应用于嵌入式设备中的存储技术。该文详细地解释了Nand Flash驱动的实现机制，从设备的注册到驱动加载对...

			
		

	





	

		

			

				
					
基于VxWorks的NAND FLASH驱动程序设计

				
			

			

				

					10-24
				

			

		

		

			
				
【基于VxWorks的NAND FLASH驱动程序设计】  在当今电子技术日新月异的时代，计算机技术也得到了显著进步，催生了许多创新技术。尽管如此，计算机的核心架构——冯·诺依曼结构依然占据主导地位，其中存储器扮演着至...

			
		

	





	

		

			

				
					
基于VxWorks的三星 NAND FLASH驱动程序设计

				
			

			

				

					10-26
				

			

		

		

			
				
【基于VxWorks的三星NAND FLASH驱动程序设计】  在嵌入式系统开发中，存储设备的选择至关重要，尤其是在VxWorks操作系统环境下。通常，对于小容量且操作简单的NOR FLASH，实现文件系统较为常见。然而，随着技术的...

			
		

	





	

		

			

				
					
K8s 很难么？带你从头到尾捋一遍，不信你学不会

				
			

			

				

					民工哥的博客
				

				

					02-23
					
					9044
					
				

			

		

		

			
				
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...

			
		

	





	

		

			

				
					
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）

				
			

			

				

					北豼不太皮的博客
				

				

					02-21
					
					3586
					
				

			

		

		

			
				
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础
一、学习目标



二、了解单片机STM32F401RET6






4、STM32F401RE特征



三、C语言基础
1.数据类型
常用2的次方：

2^7 = 128
2^8 = 256
2^15 = 32768
2^16= 65536
51单片机常见的数据类型：
char:      占内存1字节   取值范围：-128~127   -2^7 ~ 2

			
		

	





	

		

			

				
					
Android开发（1） | Fragment 的应用——新闻应用

				
			

			

				

					Jormungand_V的博客
				

				

					02-21
					
					7093
					
				

			

		

		

			
				
文章目录

news_item.xml：
<TextView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/news_title"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:lines="1"
    android:ellipsize="

			
		

	





	

		

			

				
					
系统学习 TypeScript（四）——变量声明的初步学习

				
			

			

				

					编程三昧
				

				

					02-25
					
					1735
					
				

			

		

		

			
				
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。

			
		

	





	

		

			

				
					
Linux下NandFlash驱动开发指南

				
			

			

				

					
				

			

		

		

			
				
如何编写Nandflash驱动  在本文中，我们将详细介绍Nandflash硬件原理、s3c2440的nandflash控制器说明，以及如何编写Linux下的Nandflash驱动。  **Nandflash硬件原理**  Nandflash是一种非易失性存储器（Non-Volatile...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值