1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * linux/drivers/mtd/rknand/rknand_base.c
4 *
5 * Copyright (C) 2005-2009 Fuzhou Rockchip Electronics
6 * ZYF <zyf@rock-chips.com>
7 *
8 *
9 */
10 #include <linux/version.h>
11 #include <linux/module.h>
12 #include <linux/sched.h>
13 #include <linux/delay.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/platform_device.h>
17 #include <linux/mtd/mtd.h>
18 #include <linux/mtd/mtd.h>
19 #include <linux/mtd/partitions.h>
20 #include <linux/mutex.h>
21 #include <linux/kthread.h>
22 #include <linux/dma-mapping.h>
23 #include <asm/dma.h>
24 #include <asm/cacheflush.h>
25 #include <linux/irq.h>
26 #include <linux/interrupt.h>
27 #include <linux/reboot.h>
28 #include <asm/io.h>
29 #include <asm/mach/flash.h>
30 //#include "api_flash.h"
31 #include "rknand_base.h"
32 #include "../mtdcore.h"
33 #include <linux/clk.h>
34 #include <linux/cpufreq.h>
35 #ifdef CONFIG_OF
36 #include <linux/of.h>
37 #endif
38
39 #define DRIVER_NAME "rk29xxnand"
40
41 const char rknand_base_version[] = "rknand_base.c version: 4.38 20120717";
42 #define NAND_DEBUG_LEVEL0 0
43 #define NAND_DEBUG_LEVEL1 1
44 #define NAND_DEBUG_LEVEL2 2
45 #define NAND_DEBUG_LEVEL3 3
46
47 int g_num_partitions = 0;
48 unsigned long SysImageWriteEndAdd = 0;
49 struct mtd_info rknand_mtd;
50 struct mtd_partition *rknand_parts;
51 struct rknand_info * gpNandInfo;
52
53 #ifdef CONFIG_MTD_NAND_RK29XX_DEBUG
54 static int s_debug = CONFIG_MTD_NAND_RK29XX_DEBUG_VERBOSE;
55 #undef NAND_DEBUG
56 #define NAND_DEBUG(n, format, arg...) \
57 if (n <= s_debug) { \
58 printk(format,##arg); \
59 }
60 #else
61 #undef NAND_DEBUG
62 #define NAND_DEBUG(n, arg...)
63 static const int s_debug = 0;
64 #endif
65
66 #include <linux/proc_fs.h>
67 #include <linux/version.h>
68 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26))
69 #define NANDPROC_ROOT (&proc_root)
70 #else
71 #define NANDPROC_ROOT NULL
72 #endif
73
74 //#define RKNAND_TRAC_EN
75 #ifdef RKNAND_TRAC_EN
76 static struct proc_dir_entry *my_trac_proc_entry;
77 #define MAX_TRAC_BUFFER_SIZE (long)(2048 * 8 * 512) //sector
78 static char grknand_trac_buf[MAX_TRAC_BUFFER_SIZE];
79 static char *ptrac_buf = grknand_trac_buf;
trac_log(long lba,int len,int mod)80 void trac_log(long lba,int len, int mod)
81 {
82 unsigned long long t;
83 unsigned long nanosec_rem;
84 t = cpu_clock(UINT_MAX);
85 nanosec_rem = do_div(t, 1000000000);
86 if(mod)
87 ptrac_buf += sprintf(ptrac_buf,"[%5lu.%06lu] W %d %d \n",(unsigned long) t, nanosec_rem / 1000,lba,len);
88 else
89 ptrac_buf += sprintf(ptrac_buf,"[%5lu.%06lu] R %d %d \n",(unsigned long) t, nanosec_rem / 1000,lba,len);
90 }
91
trac_logs(char * s)92 void trac_logs(char *s)
93 {
94 unsigned long long t;
95 unsigned long nanosec_rem;
96 t = cpu_clock(UINT_MAX);
97 nanosec_rem = do_div(t, 1000000000);
98 ptrac_buf += sprintf(ptrac_buf,"[%5lu.%06lu] %s\n",(unsigned long) t, nanosec_rem / 1000,s);
99 }
100
rkNand_trac_read(char * page,char ** start,off_t off,int count,int * eof,void * data)101 static int rkNand_trac_read(char *page, char **start, off_t off, int count, int *eof,
102 void *data)
103 {
104 char *p = page;
105 int len;
106
107 len = ptrac_buf - grknand_trac_buf - off;
108 //printk("rkNand_trac_read: page=%x,off=%x,count=%x ,len=%x \n",(int)page,(int)off,count,len);
109
110 if (len < 0)
111 len = 0;
112
113 if(len > count)
114 len = count;
115
116 memcpy(p,grknand_trac_buf + off,len);
117
118 *eof = (len < count) ? 1 : 0;
119 *start = page;
120 if(len < count)
121 ptrac_buf = grknand_trac_buf;
122 return len;
123 }
124
125 #endif
126
127 #define DATA_LEN (1024*8*2/4) //���ݿ鵥λword
128 #define SPARE_LEN (32*8*2/4) //У�����ݳ���
129 #define PAGE_LEN (DATA_LEN+SPARE_LEN) //ÿ�����ݵ�λ�ij���
130 #define MAX_BUFFER_SIZE (long)(2048 * 8) //sector
131 //long grknand_buf[MAX_BUFFER_SIZE * 512/4] __attribute__((aligned(4096)));
132 //long grknand_dma_buf[PAGE_LEN*4*5] __attribute__((aligned(4096)));
133 static struct proc_dir_entry *my_proc_entry;
134 extern int rkNand_proc_ftlread(char *page);
135 extern int rkNand_proc_bufread(char *page);
rkNand_proc_read(char * page,char ** start,off_t offset,int count,int * eof,void * data)136 static int rkNand_proc_read(char *page,
137 char **start,
138 off_t offset, int count, int *eof, void *data)
139 {
140 char *buf = page;
141 int step = offset;
142 *(int *)start = 1;
143 if(step == 0)
144 {
145 buf += sprintf(buf, "%s\n", rknand_base_version);
146 if(gpNandInfo->proc_ftlread)
147 buf += gpNandInfo->proc_ftlread(buf);
148 if(gpNandInfo->proc_bufread)
149 buf += gpNandInfo->proc_bufread(buf);
150 #ifdef RKNAND_TRAC_EN
151 buf += sprintf(buf, "trac data len:%d\n", ptrac_buf - grknand_trac_buf);
152 #endif
153 }
154 return buf - page < count ? buf - page : count;
155 }
156
157 #if 0// (LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0))
158 static void rknand_create_procfs(void)
159 {
160 /* Install the proc_fs entry */
161 my_proc_entry = create_proc_entry("rknand",
162 S_IRUGO | S_IFREG,
163 NANDPROC_ROOT);
164
165 if (my_proc_entry) {
166 my_proc_entry->write_proc = NULL;
167 my_proc_entry->read_proc = rkNand_proc_read;
168 my_proc_entry->data = NULL;
169 }
170 #ifdef RKNAND_TRAC_EN
171 /* Install the proc_fs entry */
172 my_trac_proc_entry = create_proc_entry("rknand_trac",
173 S_IRUGO | S_IFREG,
174 NANDPROC_ROOT);
175 if (my_trac_proc_entry) {
176 my_trac_proc_entry->write_proc = NULL;
177 my_trac_proc_entry->read_proc = rkNand_trac_read;
178 my_trac_proc_entry->data = NULL;
179 }
180 #endif
181 }
182 #else
183 static const struct file_operations my_proc_fops = {
184 .owner = THIS_MODULE,
185 .read = rkNand_proc_read,
186 .write = NULL,
187 };
188
rknand_create_procfs(void)189 static void rknand_create_procfs(void)
190 {
191 /* Install the proc_fs entry */
192 my_proc_entry = proc_create("rknand",
193 S_IRUGO | S_IFREG,
194 NANDPROC_ROOT,&my_proc_fops);
195 }
196 #endif
printk_write_log(long lba,int len,const u_char * pbuf)197 void printk_write_log(long lba,int len, const u_char *pbuf)
198 {
199 char debug_buf[100];
200 int i;
201 for(i=0;i<len;i++)
202 {
203 sprintf(debug_buf,"%lx :",lba+i);
204 print_hex_dump(KERN_WARNING, debug_buf, DUMP_PREFIX_NONE, 16,4, &pbuf[512*i], 8, 0);
205 }
206 }
207
rknand_read(struct mtd_info * mtd,loff_t from,size_t len,size_t * retlen,u_char * buf)208 static int rknand_read(struct mtd_info *mtd, loff_t from, size_t len,
209 size_t *retlen, u_char *buf)
210 {
211 int ret = 0;
212 int sector = len>>9;
213 int LBA = (int)(from>>9);
214 #ifdef RKNAND_TRAC_EN
215 //trac_log(LBA,sector,0);
216 #endif
217 //printk("R %d %d \n",(int)LBA,sector);
218 //if(rknand_debug)
219 // printk("rk28xxnand_read: from=%x,sector=%x,\n",(int)LBA,sector);
220 if(sector && gpNandInfo->ftl_read)
221 {
222 ret = gpNandInfo->ftl_read(LBA, sector, buf);
223 if(ret)
224 *retlen = 0;
225 }
226 return ret;
227 }
228
rknand_write(struct mtd_info * mtd,loff_t from,size_t len,size_t * retlen,const u_char * buf)229 static int rknand_write(struct mtd_info *mtd, loff_t from, size_t len,
230 size_t *retlen, const u_char *buf)
231 {
232 int ret = 0;
233 int sector = len>>9;
234 int LBA = (int)(from>>9);
235 #ifdef RKNAND_TRAC_EN
236 trac_log(LBA,sector,1);
237 #endif
238 //printk("W %d %d \n",(int)LBA,sector);
239 //return 0;
240 //printk("*");
241 //if(rknand_debug)
242 // printk(KERN_NOTICE "write: from=%lx,sector=%x\n",(int)LBA,sector);
243 //printk_write_log(LBA,sector,buf);
244 if(sector && gpNandInfo->ftl_write)// cmy
245 {
246 if(LBA < SysImageWriteEndAdd)//0x4E000)
247 {
248 //NAND_DEBUG(NAND_DEBUG_LEVEL0,">>> FtlWriteImage: LBA=0x%08X sector=%d\n",LBA, sector);
249 ret = gpNandInfo->ftl_write(LBA, sector, (void *)buf,1);
250 }
251 else
252 {
253 ret = gpNandInfo->ftl_write(LBA, sector, (void *)buf,0);
254 }
255 }
256 *retlen = len;
257 return 0;
258 }
259
rknand_diacard(struct mtd_info * mtd,loff_t from,size_t len)260 static int rknand_diacard(struct mtd_info *mtd, loff_t from, size_t len)
261 {
262 int ret = 0;
263 int sector = len>>9;
264 int LBA = (int)(from>>9);
265 //printk("rknand_diacard: from=%x,sector=%x,\n",(int)LBA,sector);
266 if(sector && gpNandInfo->ftl_discard)
267 {
268 ret = gpNandInfo->ftl_discard(LBA, sector);
269 }
270 return ret;
271 }
272
rknand_erase(struct mtd_info * mtd,struct erase_info * instr)273 static int rknand_erase(struct mtd_info *mtd, struct erase_info *instr)
274 {
275 int ret = 0;
276 if (instr->callback)
277 instr->callback(instr);
278 return ret;
279 }
280
rknand_sync(struct mtd_info * mtd)281 static void rknand_sync(struct mtd_info *mtd)
282 {
283 NAND_DEBUG(NAND_DEBUG_LEVEL0,"rk_nand_sync: \n");
284 if(gpNandInfo->ftl_sync)
285 gpNandInfo->ftl_sync();
286 }
287
288 extern void FtlWriteCacheEn(int);
rknand_panic_write(struct mtd_info * mtd,loff_t to,size_t len,size_t * retlen,const u_char * buf)289 static int rknand_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
290 {
291 int sector = len >> 9;
292 int LBA = (int)(to >> 9);
293
294 if (sector && gpNandInfo->ftl_write_panic) {
295 if(gpNandInfo->ftl_cache_en)
296 gpNandInfo->ftl_cache_en(0);
297 gpNandInfo->ftl_write_panic(LBA, sector, (void *)buf);
298 if(gpNandInfo->ftl_cache_en)
299 gpNandInfo->ftl_cache_en(1);
300 }
301 *retlen = len;
302 return 0;
303 }
304
305
GetIdBlockSysData(char * buf,int Sector)306 int GetIdBlockSysData(char * buf, int Sector)
307 {
308 if(gpNandInfo->GetIdBlockSysData)
309 return( gpNandInfo->GetIdBlockSysData( buf, Sector));
310 return 0;
311 }
312
GetSNSectorInfoBeforeNandInit(char * pbuf)313 char GetSNSectorInfoBeforeNandInit(char * pbuf)
314 {
315 char * sn_addr = ioremap(0x10501600,0x200);
316 memcpy(pbuf,sn_addr,0x200);
317 iounmap(sn_addr);
318 //print_hex_dump(KERN_WARNING, "sn:", DUMP_PREFIX_NONE, 16,1, sn_addr, 16, 0);
319 return 0;
320 }
321
GetSNSectorInfo(char * pbuf)322 char GetSNSectorInfo(char * pbuf)
323 {
324 if(gpNandInfo->GetSNSectorInfo)
325 return( gpNandInfo->GetSNSectorInfo( pbuf));
326 else
327 return GetSNSectorInfoBeforeNandInit(pbuf);
328 return 0;
329 }
330
331
GetVendor0InfoBeforeNandInit(char * pbuf)332 char GetVendor0InfoBeforeNandInit(char * pbuf)
333 {
334 char * sn_addr = ioremap(0x10501400,0x200);
335 memcpy(pbuf,sn_addr + 8,504);
336 iounmap(sn_addr);
337 //print_hex_dump(KERN_WARNING, "sn:", DUMP_PREFIX_NONE, 16,1, sn_addr, 16, 0);
338 return 0;
339 }
340
GetChipSectorInfo(char * pbuf)341 char GetChipSectorInfo(char * pbuf)
342 {
343 if(gpNandInfo->GetChipSectorInfo)
344 return( gpNandInfo->GetChipSectorInfo( pbuf));
345 return 0;
346 }
347
GetParamterInfo(char * pbuf,int len)348 int GetParamterInfo(char * pbuf , int len)
349 {
350 int ret = -1;
351 int sector = (len)>>9;
352 int LBA = 0;
353 if(sector && gpNandInfo->ftl_read)
354 {
355 ret = gpNandInfo->ftl_read(LBA, sector, pbuf);
356 }
357 return ret?-1:(sector<<9);
358 }
359
GetflashDataByLba(int lba,char * pbuf,int len)360 int GetflashDataByLba(int lba,char * pbuf , int len)
361 {
362 int ret = -1;
363 int sector = (len)>>9;
364 int LBA = lba;
365 if(sector && gpNandInfo->ftl_read)
366 {
367 ret = gpNandInfo->ftl_read(LBA, sector, pbuf);
368 }
369 return ret?-1:(sector<<9);
370 }
371
rknand_dev_cache_flush(void)372 void rknand_dev_cache_flush(void)
373 {
374 if(gpNandInfo->rknand_dev_cache_flush)
375 gpNandInfo->rknand_dev_cache_flush();
376 }
377
378
rknand_block_isbad(struct mtd_info * mtd,loff_t ofs)379 static int rknand_block_isbad(struct mtd_info *mtd, loff_t ofs)
380 {
381 return 0;
382 }
383
rknand_block_markbad(struct mtd_info * mtd,loff_t ofs)384 static int rknand_block_markbad(struct mtd_info *mtd, loff_t ofs)
385 {
386 return 0;
387 }
388
389
390 static struct clk *nandc_clk;
391 static unsigned long nandc_clk_rate = 0;
392 static struct notifier_block nandc_freq_transition;
393 /* cpufreq driver support */
rknand_nand_timing_cfg(void)394 static int rknand_nand_timing_cfg(void)
395 {
396 unsigned long newclk;
397 newclk = clk_get_rate(nandc_clk);
398 //printk("rknand_nand_timing_cfg %d",newclk);
399 if (newclk != nandc_clk_rate)
400 {
401 if(gpNandInfo->nand_timing_config)
402 {
403 nandc_clk_rate = newclk;
404 //gpNandInfo->nand_timing_config( nandc_clk_rate / 1000); // KHz
405 }
406 }
407 return 0;
408 }
409
rknand_info_init(struct rknand_info * nand_info)410 static int rknand_info_init(struct rknand_info *nand_info)
411 {
412 struct mtd_info *mtd = &rknand_mtd;
413 struct rknand_chip *rknand = &nand_info->rknand;
414
415 rknand->state = FL_READY;
416 rknand->rknand_schedule_enable = 1;
417 rknand->pFlashCallBack = NULL;
418 init_waitqueue_head(&rknand->wq);
419
420 mtd->oobsize = 0;
421 mtd->oobavail = 0;
422 mtd->ecclayout = 0;
423 mtd->erasesize = 32*0x200;
424 mtd->writesize = 8*0x200;
425
426 // Fill in remaining MTD driver data
427 mtd->type = MTD_NANDFLASH;
428 mtd->flags = (MTD_WRITEABLE|MTD_NO_ERASE);//
429 mtd->_erase = rknand_erase;
430 mtd->_point = NULL;
431 mtd->_unpoint = NULL;
432 mtd->_read = rknand_read;
433 mtd->_write = rknand_write;
434 //mtd->discard = rknand_diacard;
435 mtd->_read_oob = NULL;
436 mtd->_write_oob = NULL;
437 mtd->_panic_write = rknand_panic_write;
438
439 mtd->_sync = rknand_sync;
440 mtd->_lock = NULL;
441 mtd->_unlock = NULL;
442 mtd->_suspend = NULL;
443 mtd->_resume = NULL;
444 mtd->_block_isbad = rknand_block_isbad;
445 mtd->_block_markbad = rknand_block_markbad;
446 mtd->owner = THIS_MODULE;
447 return 0;
448 }
449
450
451 /*
452 * CMY: �����˶������з�����Ϣ��֧��
453 * ��cmdline���ṩ������Ϣ����ʹ��cmdline�ķ�����Ϣ���з���
454 * ��cmdlineû���ṩ������Ϣ����ʹ��Ĭ�ϵķ�����Ϣ(rk28_partition_info)���з���
455 */
456
457 #ifdef CONFIG_MTD_CMDLINE_PARTS
458 const char *part_probes[] = { "cmdlinepart", NULL };
459 #endif
460
rknand_add_partitions(struct rknand_info * nand_info)461 static int rknand_add_partitions(struct rknand_info *nand_info)
462 {
463 #ifdef CONFIG_MTD_CMDLINE_PARTS
464 int num_partitions = 0;
465
466 // �������н�����������Ϣ
467 num_partitions = parse_mtd_partitions(&(rknand_mtd), part_probes, &rknand_parts, 0);
468 NAND_DEBUG(NAND_DEBUG_LEVEL0,"num_partitions = %d\n",num_partitions);
469 printk("num_partitions = %d\n",num_partitions);
470 if(num_partitions > 0) {
471 int i;
472 for (i = 0; i < num_partitions; i++)
473 {
474 rknand_parts[i].offset *= 0x200;
475 rknand_parts[i].size *=0x200;
476 }
477 rknand_parts[num_partitions - 1].size = rknand_mtd.size - rknand_parts[num_partitions - 1].offset;
478
479 g_num_partitions = num_partitions;
480 //#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 0))
481 // return mtd_device_register(&rknand_mtd, rknand_parts, num_partitions);
482 //#else
483 return add_mtd_partitions(&(rknand_mtd), rknand_parts, num_partitions);
484 //#endif
485 }
486 #endif
487 g_num_partitions = 0;
488 return 0;
489 }
490
add_rknand_device(struct rknand_info * prknand_Info)491 int add_rknand_device(struct rknand_info * prknand_Info)
492 {
493 struct mtd_partition *parts;
494 int i;
495 NAND_DEBUG(NAND_DEBUG_LEVEL0,"add_rknand_device: \n");
496 printk("gpNandInfo->nandCapacity = %lx\n",gpNandInfo->nandCapacity);
497 rknand_mtd.size = (uint64_t)gpNandInfo->nandCapacity*0x200;
498
499 rknand_add_partitions(prknand_Info);
500
501 parts = rknand_parts;
502 SysImageWriteEndAdd = 0;
503 for(i=0;i<g_num_partitions;i++)
504 {
505 //printk(">>> part[%d]: name=%s offset=0x%012llx\n", i, parts[i].name, parts[i].offset);
506 if(strcmp(parts[i].name,"backup") == 0)
507 {
508 SysImageWriteEndAdd = (unsigned long)(parts[i].offset + parts[i].size)>>9;//sector
509 //printk(">>> SysImageWriteEndAdd=0x%lx\n", SysImageWriteEndAdd);
510 break;
511 }
512 }
513 if(SysImageWriteEndAdd)
514 gpNandInfo->SysImageWriteEndAdd = SysImageWriteEndAdd;
515
516 //nandc_clk = clk_get(NULL, "nandc");
517 //clk_enable(nandc_clk);
518 //rknand_nand_timing_cfg();
519
520 return 0;
521 }
522
get_rknand_device(struct rknand_info ** prknand_Info)523 int get_rknand_device(struct rknand_info ** prknand_Info)
524 {
525 *prknand_Info = gpNandInfo;
526 return 0;
527 }
528
529 EXPORT_SYMBOL(get_rknand_device);
530
rknand_dma_map_single(unsigned long ptr,int size,int dir)531 int rknand_dma_map_single(unsigned long ptr,int size,int dir)
532 {
533 return dma_map_single(NULL, ptr,size, dir?DMA_TO_DEVICE:DMA_FROM_DEVICE);
534 }
535 EXPORT_SYMBOL(rknand_dma_map_single);
536
rknand_dma_unmap_single(unsigned long ptr,int size,int dir)537 void rknand_dma_unmap_single(unsigned long ptr,int size,int dir)
538 {
539 dma_unmap_single(NULL, ptr,size, dir?DMA_TO_DEVICE:DMA_FROM_DEVICE);
540 }
541 EXPORT_SYMBOL(rknand_dma_unmap_single);
542
rknand_flash_cs_init(void)543 int rknand_flash_cs_init(void)
544 {
545
546 }
547 EXPORT_SYMBOL(rknand_flash_cs_init);
548
549
rknand_get_reg_addr(int * pNandc,int * pSDMMC0,int * pSDMMC1,int * pSDMMC2)550 int rknand_get_reg_addr(int *pNandc,int *pSDMMC0,int *pSDMMC1,int *pSDMMC2)
551 {
552 //*pNandc = ioremap(RK30_NANDC_PHYS,RK30_NANDC_SIZE);
553 //*pSDMMC0 = ioremap(SDMMC0_BASE_ADDR, 0x4000);
554 //*pSDMMC1 = ioremap(SDMMC1_BASE_ADDR, 0x4000);
555 //*pSDMMC2 = ioremap(EMMC_BASE_ADDR, 0x4000);
556 *pNandc = ioremap(0x10500000,0x4000);
557 }
558 EXPORT_SYMBOL(rknand_get_reg_addr);
559
560 static int g_nandc_irq = 27;
rknand_nandc_irq_init(int mode,void * pfun)561 int rknand_nandc_irq_init(int mode,void * pfun)
562 {
563 int ret = 0;
564 if(mode) //init
565 {
566 ret = request_irq(g_nandc_irq, pfun, 0, "nandc", NULL);
567 if(ret)
568 printk("request IRQ_NANDC irq , ret=%x.........\n", ret);
569 }
570 else //deinit
571 {
572 free_irq(g_nandc_irq, NULL);
573 }
574 return ret;
575 }
576 EXPORT_SYMBOL(rknand_nandc_irq_init);
rknand_probe(struct platform_device * pdev)577 static int rknand_probe(struct platform_device *pdev)
578 {
579 struct rknand_info *nand_info;
580 int err = 0;
581 NAND_DEBUG(NAND_DEBUG_LEVEL0,"rk_nand_probe: \n");
582 gpNandInfo = kzalloc(sizeof(struct rknand_info), GFP_KERNEL);
583 if (!gpNandInfo)
584 return -ENOMEM;
585
586 nand_info = gpNandInfo;
587 printk("rknand_probe: \n");
588
589 g_nandc_irq = platform_get_irq(pdev, 0);
590 if (g_nandc_irq < 0) {
591 dev_err(&pdev->dev, "no irq resource?\n");
592 return g_nandc_irq;
593 }
594
595 memset(gpNandInfo,0,sizeof(struct rknand_info));
596
597 gpNandInfo->bufSize = MAX_BUFFER_SIZE * 512;
598 gpNandInfo->pbuf = (char *)NULL;//grknand_buf;
599 gpNandInfo->pdmaBuf = (char *)NULL;//grknand_dma_buf;
600 //printk(" gpNandInfo->pdmaBuf=0x%x\n", gpNandInfo->pdmaBuf);
601 #ifdef CONFIG_MTD_EMMC_CLK_POWER_SAVE
602 gpNandInfo->emmc_clk_power_save_en = 1;
603 #endif
604
605 rknand_mtd.name = DRIVER_NAME;//dev_name(&pdev->dev);
606 rknand_mtd.priv = &nand_info->rknand;
607 rknand_mtd.owner = THIS_MODULE;
608
609 if(rknand_info_init(nand_info))
610 {
611 err = -ENXIO;
612 goto exit_free;
613 }
614
615 nand_info->add_rknand_device = add_rknand_device;
616 nand_info->get_rknand_device = get_rknand_device;
617
618 rknand_create_procfs();
619 return 0;
620
621 exit_free:
622 if(nand_info)
623 kfree(nand_info);
624
625 return err;
626 }
627
rknand_suspend(struct platform_device * pdev,pm_message_t state)628 static int rknand_suspend(struct platform_device *pdev, pm_message_t state)
629 {
630 gpNandInfo->rknand.rknand_schedule_enable = 0;
631 // if(gpNandInfo->rknand_suspend)
632 // gpNandInfo->rknand_suspend();
633 NAND_DEBUG(NAND_DEBUG_LEVEL0,"rknand_suspend: \n");
634 return 0;
635 }
636
rknand_resume(struct platform_device * pdev)637 static int rknand_resume(struct platform_device *pdev)
638 {
639 //if(gpNandInfo->rknand_resume)
640 // gpNandInfo->rknand_resume();
641 gpNandInfo->rknand.rknand_schedule_enable = 1;
642 NAND_DEBUG(NAND_DEBUG_LEVEL0,"rknand_resume: \n");
643 return 0;
644 }
645
rknand_shutdown(struct platform_device * pdev)646 void rknand_shutdown(struct platform_device *pdev)
647 {
648 printk("rknand_shutdown...\n");
649 gpNandInfo->rknand.rknand_schedule_enable = 0;
650 if(gpNandInfo->rknand_buffer_shutdown)
651 gpNandInfo->rknand_buffer_shutdown();
652 }
653
654 #ifdef CONFIG_OF
655 static const struct of_device_id of_rk_nandc_match[] = {
656 { .compatible = "rockchip,rk-nandc" },
657 { /* Sentinel */ }
658 };
659 #endif
660
661 static struct platform_driver rknand_driver = {
662 .probe = rknand_probe,
663 .suspend = rknand_suspend,
664 .resume = rknand_resume,
665 .shutdown = rknand_shutdown,
666 .driver = {
667 .name = DRIVER_NAME,
668 #ifdef CONFIG_OF
669 .of_match_table = of_rk_nandc_match,
670 #endif
671 .owner = THIS_MODULE,
672 },
673 };
674
675
676 MODULE_ALIAS(DRIVER_NAME);
677
rknand_init(void)678 static int __init rknand_init(void)
679 {
680 int ret;
681 NAND_DEBUG(NAND_DEBUG_LEVEL0,"rknand_init: \n");
682 ret = platform_driver_register(&rknand_driver);
683 NAND_DEBUG(NAND_DEBUG_LEVEL0,"platform_driver_register:ret = %x \n",ret);
684 return ret;
685 }
686
rknand_exit(void)687 static void __exit rknand_exit(void)
688 {
689 platform_driver_unregister(&rknand_driver);
690 }
691
692 module_init(rknand_init);
693 module_exit(rknand_exit);
694
695 MODULE_LICENSE("GPL");
696 MODULE_AUTHOR("ZYF <zyf@rock-chips.com>");
697 MODULE_DESCRIPTION("rknand driver.");
698
699
700