source: src/linux/universal/linux-4.4/drivers/mtd/devices/wzrg450nh_flash.c @ 31672

Last change on this file since 31672 was 31672, checked in by brainslayer, 2 months ago

fix fs detection

File size: 27.3 KB
Line 
1/*
2 * This file contains glue for Atheros ar7240 spi flash interface
3 * Primitives are ar7240_spi_*
4 * mtd flash implements are ar7240_flash_*
5 */
6#include <linux/version.h>
7#include <linux/kernel.h>
8#include <linux/module.h>
9#include <linux/types.h>
10#include <linux/errno.h>
11#include <linux/slab.h>
12#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
13#include <asm/semaphore.h>
14#else
15#include <linux/semaphore.h>
16#endif
17#include <linux/squashfs_fs.h>
18#include <linux/mtd/mtd.h>
19#include <linux/mtd/partitions.h>
20#include "../mtdcore.h"
21#include <asm/delay.h>
22#include <asm/io.h>
23
24#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
25#else
26#include <asm/div64.h>
27#include <linux/jiffies.h>
28#endif
29
30
31
32
33
34#include "ar7240.h"
35#include "wzrg450nh_flash.h"
36
37#ifdef  CONFIG_BUFFALO
38#include <linux/proc_fs.h>
39#endif  //CONFIG_BUFFALO
40
41/* this is passed in as a boot parameter by bootloader */
42extern int __ath_flash_size;
43
44#ifdef  CONFIG_BUFFALO
45#undef  AR7240_FLASH_MAX_BANKS
46#define AR7240_FLASH_MAX_BANKS  2
47#endif  //CONFIG_BUFFALO
48/*
49 * statics
50 */
51#ifdef  CONFIG_BUFFALO
52static void ar7240_spi_write_enable(unsigned int cs);
53static void ar7240_spi_poll(unsigned int cs);
54static void ar7240_spi_fast_read(unsigned int cs, uint32_t addr, uint8_t *data, int len);
55static void ar7240_spi_read(unsigned int cs, uint32_t addr, uint8_t *data, int len);
56#else   //CONFIG_BUFFALO
57static void ar7240_spi_write_enable(void);
58static void ar7240_spi_poll(void);
59#endif  //CONFIG_BUFFALO
60static void ar7240_spi_write_page(uint32_t addr, uint8_t *data, int len);
61static void ar7240_spi_sector_erase(uint32_t addr);
62
63
64
65#ifdef  CONFIG_BUFFALO
66//
67//      BUFFALO EXTENTION for DIAG_LED
68//
69static  __u32   _s_lastaddr     = 0;
70static  __u32   _f_lastwrite= 0;
71static  __u32   _f_init         = 1;
72static  __u32   _f_on           = 0;
73static  __u32   _s_jiffies      = 0;
74#define _S_LASTADDR_MASK        0xFFFFC000      //16KBytes
75
76#define IS_NEW_SEQUENCE(F_WRITE)                ( ((F_WRITE)==0 && _f_lastwrite) || (jiffies-_s_jiffies)>(HZ/10) )
77
78#define DBGMSG(S)       do { printk(KERN_DEBUG "%s[%08lX]::%s\n", __FUNCTION__, jiffies, (S)); } while(0)
79
80#if 0 //        defined(CONFIG_MACH_AR7240)
81//#include      "asm/mach-ar7240/ar7240.h"
82#define DIAG_GPIO_NO                    (1<<14)
83#define DIAG_INIT(F_WRITE)              do { if(IS_NEW_SEQUENCE(F_WRITE)){_f_on=0;} while(_f_init) { ar7240_reg_rmw_set(AR7240_GPIO_OE, DIAG_GPIO_NO); _f_init=0; } } while(0)
84#define DIAG_ON()                               do { ar7240_reg_wr(AR7240_GPIO_CLEAR, DIAG_GPIO_NO); _s_jiffies=jiffies; } while(0)
85#define DIAG_OFF()                              do { ar7240_reg_wr(AR7240_GPIO_SET, DIAG_GPIO_NO); _s_jiffies=jiffies; } while(0)
86#define DIAG_BLINK()                    do { _f_on = (_f_on+1) & 0x1; if (_f_on) DIAG_ON(); else DIAG_OFF(); } while(0)
87
88#else   //defined  CONFIG_AR9100
89#define DIAG_GPIO_NO                    (1<<1)
90#define DIAG_INIT(F_WRITE)              do {  } while(0)
91#define DIAG_ON()                               do {  } while(0)
92#define DIAG_OFF()                              do {  } while(0)
93#define DIAG_BLINK()                    do {  } while(0)
94#endif  //defined  CONFIG_AR9100
95#endif  //CONFIG_BUFFALO
96
97
98#define down mutex_lock
99#define up mutex_unlock
100#define init_MUTEX mutex_init
101#define DECLARE_MUTEX(a) struct mutex a
102
103static struct mutex ar7240_flash_sem;
104
105/* GLOBAL FUNCTIONS */
106void
107ar7240_flash_spi_down(void)
108{
109        mutex_lock(&ar7240_flash_sem);
110}
111
112void
113ar7240_flash_spi_up(void)
114{
115        mutex_unlock(&ar7240_flash_sem);
116}
117
118EXPORT_SYMBOL(ar7240_flash_spi_down);
119EXPORT_SYMBOL(ar7240_flash_spi_up);
120
121#ifdef  CONFIG_BUFFALO
122u_int32_t       g_buffalo_clock_div     = 3;
123u_int32_t       g_buffalo_current_div;
124
125static  u_int32_t       ar7240_cpu_freq = 0, ar7240_ahb_freq, ar7240_ddr_freq;
126
127static  void    get_ahb_clock(void)
128{
129    uint32_t pll, pll_div, ahb_div, ddr_div, freq, ref_div;
130
131    if (ar7240_cpu_freq)
132        return;
133
134    pll = ar7240_reg_rd(AR7240_PLL_CONFIG);
135
136    pll_div  = ((pll >> PLL_DIV_SHIFT) & PLL_DIV_MASK);
137    ref_div  = (pll >> REF_DIV_SHIFT) & REF_DIV_MASK;
138    ddr_div  = ((pll >> DDR_DIV_SHIFT) & DDR_DIV_MASK) + 1;
139    ahb_div  = (((pll >> AHB_DIV_SHIFT) & AHB_DIV_MASK) + 1)*2;
140
141    freq     = pll_div * ref_div * 5000000;
142
143    ar7240_cpu_freq = freq;
144    ar7240_ddr_freq = freq/ddr_div;
145    ar7240_ahb_freq = ar7240_cpu_freq/ahb_div;
146}
147
148static void     buffalo_spi_clock_update(void)
149{
150        if (g_buffalo_clock_div != g_buffalo_current_div) {
151                if (g_buffalo_clock_div>=0 && g_buffalo_clock_div<64) {
152                        u_int32_t       last_value;
153                        ar7240_flash_spi_down();
154
155
156                        ar7240_reg_wr(AR7240_SPI_FS, 1);
157
158                        last_value      = ar7240_reg_rd(AR7240_SPI_CLOCK) & 0x3f;
159
160                        //      write value
161                        ar7240_reg_wr_nf(AR7240_SPI_CLOCK, 0x40 | (g_buffalo_clock_div & 0x3f));
162                        g_buffalo_current_div   = ar7240_reg_rd(AR7240_SPI_CLOCK) & 0x3f;
163
164
165#define         AR7240_SPI_CMD_WRITE_SR 0x1
166                        ar7240_spi_write_enable(0);
167                        ar7240_spi_bit_banger(0, AR7240_SPI_CMD_WRITE_SR);
168                        ar7240_spi_bit_banger(0, 0x0);
169                        ar7240_spi_go(0);
170                        ar7240_spi_poll(0);
171
172                        ar7240_reg_wr(AR7240_SPI_FS, 0);
173
174#if     0
175                        {
176                                unsigned long flags;
177                                //      disable interrupts
178                                local_irq_save(flags);
179                                local_irq_disable();
180
181
182                                ar7240_reg_wr_nf(AR7240_PLL_CONFIG, (ar7240_reg_rd(AR7240_PLL_CONFIG) & (~((unsigned int)PLL_CONFIG_LOCKED_MASK))));
183                                ar7240_reg_wr_nf(AR7240_CPU_CLOCK_CONTROL, CLOCK_CONTROL_RST_SWITCH_MASK|CLOCK_CONTROL_CLOCK_SWITCH_MASK);
184                                ar7240_reg_rmw_clear(AR7240_CPU_CLOCK_CONTROL, CLOCK_CONTROL_RST_SWITCH_MASK);
185
186
187                                //      wait
188                                for ( ; 0==(ar7240_reg_rd(AR7240_PLL_CONFIG) & PLL_CONFIG_LOCKED_MASK) ; )
189                                        ;
190
191
192                                //      enable interrupts
193                                local_irq_enable();
194                                local_irq_restore(flags);
195                        }
196#endif
197
198
199
200                        //      read-back
201                        printk("SPI clock changed %d --> %d\n", ar7240_ahb_freq / (2 << last_value), ar7240_ahb_freq / (2 << g_buffalo_current_div));
202
203                        ar7240_flash_spi_up();
204                }
205        }
206}
207
208//
209//      for BUFFALO debug
210//
211static  int     atoi(const char *p)
212{
213        int             ret             = 0;
214        int             minus   = 0;
215        do      {
216                if (p==NULL)
217                        break;
218
219                for (; *p==' ' ; p++)
220                        ;
221
222                if (*p=='-') {
223                        minus   = 1;
224                        p++;
225                }
226
227                for (; p && *p>='0' && *p<='9' ; p++)
228                        ret     = (ret * 10) + (*p - '0');
229        } while(0);
230
231        return  (minus ? -ret : ret);
232}
233
234
235#endif  //CONFIG_BUFFALO
236
237#define AR7240_FLASH_SIZE_2MB          (2*1024*1024)
238#define AR7240_FLASH_SIZE_4MB          (4*1024*1024)
239#define AR7240_FLASH_SIZE_8MB          (8*1024*1024)
240#define AR7240_FLASH_SIZE_16MB          (16*1024*1024)
241#define AR7240_FLASH_PG_SIZE_256B       256
242
243#ifndef ST25P28
244#define AR7240_FLASH_SECTOR_SIZE_64KB  (64*1024)
245#else
246#define AR7240_FLASH_SECTOR_SIZE_256KB  (256*1024)
247#endif
248
249#ifdef  CONFIG_BUFFALO
250#define AR7240_FLASH_SIZE_12MB         (12*1024*1024)
251#define AR7240_FLASH_SIZE_32MB         (32*1024*1024)
252#endif  //CONFIG_BUFFALO
253
254#define AR7240_FLASH_NAME               "ar7240-nor0"
255/*
256 * bank geometry
257 */
258#ifndef CONFIG_BUFFALO
259typedef struct ar7240_flash_geom {
260    uint32_t     size;
261    uint32_t     sector_size;
262    uint32_t     nsectors;
263    uint32_t     pgsize;
264} ar7240_flash_geom_t;
265
266ar7240_flash_geom_t flash_geom_tbl[AR7240_FLASH_MAX_BANKS] = {
267        {
268                .size           = AR7240_FLASH_SIZE_8MB,
269                .sector_size    = AR7240_FLASH_SECTOR_SIZE_64KB,
270                .pgsize         = AR7240_FLASH_PG_SIZE_256B
271        }
272};
273#else   //CONFIG_BUFFALO
274typedef struct ar7240_flash_geom {
275        const char *name;
276        u_int8_t         chip_id[3];
277    uint32_t     size;
278    uint32_t     sector_size;
279    uint32_t     nsectors;
280    uint32_t     pgsize;
281}ar7240_flash_geom_t;
282
283ar7240_flash_geom_t g_flash_geom_tbl[] = {
284                                        //      chip-id                                 dev-size        blk-siz         n-sec   page-siz
285          {     "S25FL064P",    { 0x01, 0x02, 0x16 },   0x00800000,     0x10000,           0,    256    }               //S25FL064P
286        , {     "M25P64V6P",    { 0x20, 0x20, 0x17 },   0x00800000,     0x10000,           0,    256    }               //S25FL064P
287        , {     "MX25L64-45E",  { 0xc2, 0x20, 0x17 },   0x00800000,     0x10000,           0,    256    }               //MX25L64-45E
288        , {     "MX25L128-45E", { 0xc2, 0x20, 0x18 },   0x01000000,     0x10000,           0,    256    }               //MX25L128-45E
289        , {     "W25Q128BV",    { 0xef, 0x40, 0x18 },   0x01000000,     0x10000,           0,    256    }               //W25Q128BV
290        , {     "S25FL128P",    { 0x01, 0x20, 0x18 },   0x01000000,     0x10000,           0,    256    }               //S25FL128P
291        , {     NULL,                   { 0x00, 0x00, 0x00 },   0x00000000,     0x00000,           0,      0    }               //dummy
292};
293
294ar7240_flash_geom_t     g_flash_geoms[AR7240_FLASH_MAX_BANKS];
295
296
297#endif  //CONFIG_BUFFALO
298
299static struct mtd_partition dir_parts[] = {
300      {name: "RedBoot", offset: 0, size:0x50000,},
301      {name: "linux", offset: 0x60000, size:0x1f90000,},
302      {name: "rootfs", offset: 0x0, size:0x2b0000,},
303      {name: "ddwrt", offset: 0x0, size:0x2b0000,},
304      {name: "nvram", offset: 0x3d0000, size:0x10000,},
305      {name: "FIS directory", offset: 0x3e0000, size:0x10000,},
306      {name: "board_config", offset: 0x3f0000, size:0x10000,},
307      {name: "fullflash", offset: 0x3f0000, size:0x10000,},
308      {name: "uboot-env", offset: 0x40000, size:0x10000,},
309      {name:NULL,},
310};
311
312
313         
314static int
315ar7240_flash_probe(void)
316{
317        return 0;
318}
319
320static int
321ar7240_flash_erase(struct mtd_info *mtd, struct erase_info *instr)
322{
323    int nsect, s_curr, s_last;
324        uint64_t  res;
325
326
327        if (instr->addr + instr->len > mtd->size)
328                return (-EINVAL);
329
330    ar7240_flash_spi_down();
331
332#       ifdef   CONFIG_BUFFALO
333        DIAG_INIT(0);
334        _f_lastwrite    = 0;
335#       endif   //CONFIG_BUFFALO
336
337        res = instr->len;
338        do_div(res, mtd->erasesize);
339        nsect = res;
340
341        if (((uint32_t)instr->len) % mtd->erasesize)
342                nsect ++;
343
344        res = instr->addr;
345        do_div(res,mtd->erasesize);
346        s_curr = res;
347
348        s_last  = s_curr + nsect;
349
350    do {
351#       ifdef   CONFIG_BUFFALO
352                DIAG_BLINK();
353#       endif   //CONFIG_BUFFALO
354
355        ar7240_spi_sector_erase(s_curr * AR7240_SPI_SECTOR_SIZE);
356    } while (++s_curr < s_last);
357
358    ar7240_spi_done();
359
360#       ifdef   CONFIG_BUFFALO
361        DIAG_OFF();
362#       endif   //CONFIG_BUFFALO
363
364    ar7240_flash_spi_up();
365
366    if (instr->callback) {
367        instr->state |= MTD_ERASE_DONE;
368        instr->callback(instr);
369    }
370
371
372
373    return 0;
374}
375
376#ifndef CONFIG_BUFFALO
377static int
378ar7240_flash_read(struct mtd_info *mtd, loff_t from, size_t len,
379                  size_t *retlen, u_char *buf)
380{
381    uint32_t addr = from | 0xbf000000;
382
383        if (!len)
384                return (0);
385        if (from + len > mtd->size)
386                return (-EINVAL);
387
388    ar7240_flash_spi_down();
389
390    memcpy(buf, (uint8_t *)(addr), len);
391    *retlen = len;
392
393    ar7240_flash_spi_up();
394
395    return 0;
396}
397#else   //CONFIG_BUFFALO
398static unsigned int     ar7240_spi_get_cs(unsigned int addr)
399{
400        if (g_flash_geoms[0].size) {
401                return  (g_flash_geoms[0].size <= addr);
402        } else {
403                return  (g_flash_geoms[1].size);
404        }
405}
406
407static int
408ar7240_flash_read_dmc(unsigned int cs, void *buf, size_t len)
409{
410        u_int8_t        *data   = buf;
411        size_t          i;
412        ar7240_flash_spi_down();
413
414        ar7240_reg_wr_nf(AR7240_SPI_FS, 1);
415        ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);
416        ar7240_spi_bit_banger(cs,AR7240_SPI_CMD_READ_DMC);
417        ar7240_spi_delay_8(cs);
418//      ar7240_spi_delay_8(cs);
419//      ar7240_spi_delay_8(cs);
420
421        for (i=0; i<len ; i++, data++) {
422                ar7240_spi_delay_8(cs);
423                *data   = (uint8_t)ar7240_reg_rd(AR7240_SPI_RD_STATUS);
424        }
425
426        ar7240_spi_done();
427
428        {
429                u_int8_t        msg[256];
430                size_t          msglen=0;
431                for (i=0 ; i<len ; i++) {
432                        if ((i%16)==0) {
433                                if (msglen)     printk("%s\n", msg);
434                                memset(msg,0,sizeof(msg));
435                                msglen  = sprintf(msg, "%04X : %02X", i, data[i]);
436                        } else {
437                                msglen  += sprintf(msg+msglen, " %02X", data[i]);
438                        }
439                }
440                if (msglen)     printk("%s\n", msg);
441        }
442
443        ar7240_flash_spi_up();
444
445        return  0;
446}
447
448static int
449ar7240_flash_read_manid(unsigned int cs, void *buf, size_t len)
450{
451        u_int8_t        *data   = buf;
452        size_t          i;
453        ar7240_flash_spi_down();
454
455        ar7240_reg_wr_nf(AR7240_SPI_FS, 1);
456        ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);
457        ar7240_spi_bit_banger(cs,AR7240_SPI_CMD_READ_MANID);
458        ar7240_spi_send_addr(cs,0);
459//      ar7240_spi_delay_8(cs);
460
461        for (i=0; i<len ; i++, data++) {
462                ar7240_spi_delay_8(cs);
463                *data   = (uint8_t)ar7240_reg_rd(AR7240_SPI_RD_STATUS);
464        }
465
466        ar7240_spi_done();
467
468        {
469                u_int8_t        msg[256];
470                size_t          msglen=0;
471                for (i=0, data=buf ; i<len ; i++) {
472                        if ((i%16)==0) {
473                                if (msglen)     printk("%s\n", msg);
474                                memset(msg,0,sizeof(msg));
475                                msglen  = sprintf(msg, "%04X : %02X", i, data[i]);
476                        } else {
477                                msglen  += sprintf(msg+msglen, " %02X", data[i]);
478                        }
479                }
480                if (msglen)     printk("%s\n", msg);
481        }
482
483        ar7240_flash_spi_up();
484
485        return  0;
486}
487
488static int
489ar7240_flash_read_id(unsigned int cs, void *buf, size_t len)
490{
491        u_int8_t        *data   = buf;
492        size_t          i;
493        ar7240_flash_spi_down();
494
495        ar7240_reg_wr_nf(AR7240_SPI_FS, 1);
496        ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);
497        ar7240_spi_bit_banger(cs,AR7240_SPI_CMD_READ_ID);
498//      ar7240_spi_delay_8(cs);
499//      ar7240_spi_delay_8(cs);
500//      ar7240_spi_delay_8(cs);
501
502        for (i=0; i<len ; i++, data++) {
503                ar7240_spi_delay_8(cs);
504                *data   = (uint8_t)ar7240_reg_rd(AR7240_SPI_RD_STATUS);
505        }
506
507        ar7240_spi_done();
508
509        {
510                u_int8_t        msg[256];
511                size_t          msglen=0;
512                for (data=buf, i=0 ; i<len ; i++) {
513                        if ((i%16)==0) {
514                                if (msglen)     printk("%s\n", msg);
515                                memset(msg,0,sizeof(msg));
516                                msglen  = sprintf(msg, "%04X : %02X", i, data[i]);
517                        } else {
518                                msglen  += sprintf(msg+msglen, " %02X", data[i]);
519                        }
520                }
521                if (msglen)     printk("%s\n", msg);
522        }
523
524        ar7240_flash_spi_up();
525
526        return  0;
527}
528
529static int
530ar7240_flash_read(struct mtd_info *mtd, loff_t from, size_t len,
531                  size_t *retlen, u_char *buf)
532{
533    uint32_t addr0, addr1;
534    size_t      len0, len1;
535
536        if (!len)
537                return (0);
538        if (from + len > mtd->size)
539                return (-EINVAL);
540
541
542    ar7240_flash_spi_down();
543
544    if (ar7240_spi_get_cs(from)) {
545        len0    = 0;
546        addr0   = 0;
547        len1    = len;
548        addr1   = (from - g_flash_geoms[0].size) | 0xbe000000;
549    } else if (ar7240_spi_get_cs(from+len)) {
550        len0    = g_flash_geoms[0].size - from;
551        addr0   = from | 0xbf000000;
552        len1    = len - len0;
553        addr1   = 0xbe000000;
554    } else {
555        len0    = len;
556        addr0   = from | 0xbf000000;
557        len1    = 0;
558        addr1   = 0;
559    }
560        if (len0)       memcpy(buf, (uint8_t *)(addr0), len0);
561//      if (len1)       memcpy(buf+len0, (uint8_t *)(addr1), len1);
562//      if (len0)       ar7240_spi_fast_read(0, addr0, buf, len0);
563        if (len1)       ar7240_spi_fast_read(1, addr1, buf+len0, len1);
564//      if (len0)       ar7240_spi_read(0, addr0, buf, len0);
565//      if (len1)       ar7240_spi_read(1, addr1, buf+len0, len1);
566//      if (len1) {
567//              if (addr1 < 0xbe200000)  ar7240_spi_read(1, addr1, buf+len0, len1);
568//              else                                     ar7240_spi_fast_read(1, addr1, buf+len0, len1);
569//      }
570
571    *retlen = len;
572
573    ar7240_flash_spi_up();
574
575    return 0;
576}
577#endif  //CONFIG_BUFFALO
578
579static int
580ar7240_flash_write(struct mtd_info *mtd, loff_t to, size_t len,
581                    size_t *retlen, const u_char *buf)
582{
583    int total = 0, len_this_lp, bytes_this_page;
584    uint32_t addr = 0;
585    u_char *mem;
586
587
588    ar7240_flash_spi_down();
589
590#       ifdef   CONFIG_BUFFALO
591        DIAG_INIT(1);
592        _f_lastwrite    = 1;
593#       endif   //CONFIG_BUFFALO
594
595        while (total < len) {
596                mem = (u_char *) (buf + total);
597                addr = to + total;
598                bytes_this_page =
599                    AR7240_SPI_PAGE_SIZE - (addr % AR7240_SPI_PAGE_SIZE);
600                len_this_lp = min(((int)len - total), bytes_this_page);
601
602#               ifdef   CONFIG_BUFFALO
603                if ( (addr&_S_LASTADDR_MASK) != _s_lastaddr) {
604                        DIAG_BLINK();
605                        _s_lastaddr     = addr&_S_LASTADDR_MASK;
606                }
607#               endif   //CONFIG_BUFFALO
608
609        ar7240_spi_write_page(addr, mem, len_this_lp);
610        total += len_this_lp;
611    }
612
613    ar7240_spi_done();
614
615#       ifdef   CONFIG_BUFFALO
616        DIAG_OFF();
617#       endif   //CONFIG_BUFFALO
618
619    ar7240_flash_spi_up();
620
621    *retlen = len;
622
623
624    return 0;
625}
626
627
628/*
629 * sets up flash_info and returns size of FLASH (bytes)
630 */
631static int __init ar7240_flash_init(void)
632{
633    int i, np;
634    ar7240_flash_geom_t *geom;
635    struct mtd_info *mtd;
636    struct mtd_partition *mtd_parts;
637    uint8_t index;
638   
639    mutex_init(&ar7240_flash_sem);
640
641#ifdef  CONFIG_BUFFALO
642    //  enable cs#1
643
644        if (is_ar7242())
645        {
646                ar7240_reg_rmw_set(AR7240_GPIO_FUNCTIONS, (1 << 13));
647        }else
648        {
649                ar7240_reg_rmw_set(AR7240_GPIO_FUNCTIONS, (1 << 12));
650        }
651
652#endif  //CONFIG_BUFFALO
653
654#ifdef  CONFIG_BUFFALO
655        get_ahb_clock();
656//      buffalo_spi_clock_update();
657#else   //CONFIG_BUFFALO
658    ar7240_reg_wr_nf(AR7240_SPI_CLOCK, 0x43);
659#endif  //CONFIG_BUFFALO
660
661
662        printk("check spi banks %d\n", AR7240_FLASH_MAX_BANKS);
663
664
665        for(i = 0; i < AR7240_FLASH_MAX_BANKS; i++) {
666                u_int8_t        chip_id[3];
667                int                     j;
668
669                struct {                                                                                //      offset
670                        u_int8_t        man_id;                                                 //      00h
671                        u_int8_t        dev_id_0;                                               //      01h
672                        u_int8_t        dev_id_1;                                               //      02h
673                        u_int8_t        dev_id_2;                                               //      03h
674                        u_int8_t        pad1[0x10 - 0x04];                              //      04h - 0fh
675                        u_int8_t        qry[3];                                                 //      10h - 12h
676                        u_int8_t        cmdset_id[2];                                   //      13h - 14h
677                        u_int8_t        addr_table[2];                                  //      15h - 16h
678                        u_int8_t        oem_cmdset_id[2];                               //      17h - 18h
679                        u_int8_t        oem_addr_table[2];                              //      19h - 1ah
680                        u_int8_t        VccMin;                                                 //      1bh
681                        u_int8_t        VccMax;                                                 //      1ch
682                        u_int8_t        VppMin;                                                 //      1dh
683                        u_int8_t        VppMax;                                                 //      1eh
684                        u_int8_t        WordWriteTimeoutTyp;                    //      1fh
685                        u_int8_t        BufWriteTimeoutTyp;                             //      20h
686                        u_int8_t        BlockEraseTimeoutTyp;                   //      21h
687                        u_int8_t        ChipEraseTimeoutTyp;                    //      22h
688                        u_int8_t        WordWriteTimeoutMax;                    //      23h
689                        u_int8_t        BufWriteTimeoutMax;                             //      24h
690                        u_int8_t        BlockEraseTimeoutMax;                   //      25h
691                        u_int8_t        ChipEraseTimeoutMax;                    //      26h
692                        u_int8_t        DevSize;                                                //      27h
693                        u_int16_t       InterfaceDesc;                                  //      28h - 29h
694                        u_int16_t       MaxBufWriteSize;                                //      2ah - 2bh
695                        u_int8_t        NumEraseRegions;                                //      2ch
696                        struct {
697                                u_int8_t        nEraseNum;                                      //      2dh, 31h, 35h, 39h
698                                u_int8_t        nEraseSiz0;                                     //      2eh, 32h, 36h, 3ah
699                                u_int8_t        nEraseSiz1;                                     //      2fh, 33h, 37h, 3bh
700                                u_int8_t        nEraseSiz2;                                     //      30h, 34h, 38h, 3ch
701                        } EraseRegionInfo[4];
702                        u_int8_t        pad2[0x40 - 0x3d];                              //      3dh - 3fh
703                        u_int8_t        pri[3];                                                 //      40h - 42h
704                        u_int8_t        MajVer;                                                 //      43h
705                        u_int8_t        MinVer;                                                 //      44h
706                        u_int8_t        SupportUnlock;                                  //      45h
707                        u_int8_t        SupportEraseSuspend;                    //      46h
708                        u_int8_t        SupportSectorProtect;                   //      47h
709                        u_int8_t        SupportSectorUnprotect;                 //      48h
710                        u_int8_t        TypeSectorProtect;                              //      49h
711                        u_int8_t        TypeSimulaneousOpe;                             //      4ah
712                        u_int8_t        TypeBurstMode;                                  //      4bh
713                        u_int8_t        TypePageMode;                                   //      4ch
714                        u_int8_t        AccSupplyMin;                                   //      4dh
715                        u_int8_t        AccSupplyMax;                                   //      4eh
716                        u_int8_t        WriteProtection;                                //      4fh
717                        u_int8_t        SupportProgramSuspend;                  //      50h
718                } cfi_buf;
719
720#if     0
721                struct  {
722                        u_int32_t       dmc_signature;                                  //      00h - 03h       0x50444653
723                        u_int8_t        dmc_MinVer;
724                        u_int8_t        dmc_MajVer;
725                        u_int8_t        nHeader;                                                //      06h
726                        u_int8_t        pad1[1];                                                //      07h
727                        u_int8_t        ;                                                               //      00h
728                        u_int8_t        ;                                                               //      00h
729                        u_int8_t        ;                                                               //      00h
730                        u_int8_t        ;                                                               //      00h
731                        u_int8_t        ;                                                               //      00h
732                        u_int8_t        ;                                                               //      00h
733                        u_int8_t        ;                                                               //      00h
734                        u_int8_t        ;                                                               //      00h
735                        u_int8_t        ;                                                               //      00h
736
737                } dmc_buf;
738#endif
739
740                memset(&chip_id[0], 0, sizeof(chip_id));
741                ar7240_flash_read_id(i, &chip_id[0], sizeof(chip_id));
742
743                for (j=0 ; j<sizeof(g_flash_geom_tbl)/sizeof(g_flash_geom_tbl[0]) ; j++) {
744                        if (memcmp(g_flash_geom_tbl[j].chip_id, chip_id, sizeof(g_flash_geom_tbl[j].chip_id))==0) {
745                                if (g_flash_geom_tbl[j].name) {
746                                        printk("found %s device on bank#%d\n", g_flash_geom_tbl[j].name, i);
747                                        g_flash_geoms[i]        = g_flash_geom_tbl[j];
748                                        if (g_flash_geoms[i].sector_size!=0 && g_flash_geoms[i].nsectors==0)
749                                                g_flash_geoms[i].nsectors       = g_flash_geoms[i].size / g_flash_geoms[i].sector_size;
750                                        break;
751                                }
752                        }
753                }
754
755#if     0
756                ar7240_flash_read_manid(i, &cfi_buf, sizeof(cfi_buf));
757                memset(&cfi_buf, 0, sizeof(cfi_buf));
758                ar7240_flash_read_id(i, &cfi_buf, sizeof(cfi_buf));
759                if (cfi_buf.qry[0]=='Q' && cfi_buf.qry[1]=='R' && cfi_buf.qry[2]=='Y') {
760                        g_flash_geoms[i].size                   = 2 << cfi_buf.DevSize;
761                        g_flash_geoms[i].sector_size    = 64 * 1024;
762                        g_flash_geoms[i].nsectors               = g_flash_geoms[i].size / g_flash_geoms[i].sector_size;
763                        g_flash_geoms[i].pgsize                 = 2 << cfi_buf.MaxBufWriteSize;
764                }
765#endif
766        }
767        printk("SPI flash size total:%d Mbytes\n", (g_flash_geoms[0].size + g_flash_geoms[1].size) >> 20);
768
769        mtd         =  kmalloc(sizeof(struct mtd_info), GFP_KERNEL);
770        if (!mtd) {
771                printk("Cant allocate mtd stuff\n");
772                return -1;
773        }
774        memset(mtd, 0, sizeof(struct mtd_info));
775
776
777        mtd->name               =   AR7240_FLASH_NAME;
778        mtd->type               =   MTD_NORFLASH;
779        mtd->flags              =   (MTD_CAP_NORFLASH|MTD_WRITEABLE);
780        mtd->size               =   g_flash_geoms[0].size + g_flash_geoms[1].size;
781        mtd->erasesize          =   g_flash_geoms[0].sector_size;
782        mtd->numeraseregions    =   0;
783        mtd->eraseregions       =   NULL;
784        mtd->owner              =   THIS_MODULE;
785        mtd->_erase              =   ar7240_flash_erase;
786        mtd->_read               =   ar7240_flash_read;
787        mtd->_write              =   ar7240_flash_write;
788        mtd->writesize          =   1;
789        mtd->priv                               = g_flash_geoms;
790
791        int offset = 0;
792        struct squashfs_super_block *sb;
793
794        char buf[512];
795        int retlen;
796        unsigned int rootsize,len;
797
798                while ((offset + mtd->erasesize) < mtd->size) {
799                        mtd_read(mtd,offset,512,&retlen,&buf[0]);
800                        if (*((__u32 *)buf) == SQUASHFS_MAGIC_SWAP) {
801                                printk(KERN_EMERG "\nfound squashfs at %X\n",offset);
802                                sb = (struct squashfs_super_block *)buf;
803                                dir_parts[2].offset = offset;
804
805                                dir_parts[2].size = le64_to_cpu(sb->bytes_used);
806                                len = dir_parts[2].offset + dir_parts[2].size;
807                                len += (mtd->erasesize - 1);
808                                len &= ~(mtd->erasesize - 1);
809                                dir_parts[2].size = (len & 0x1ffffff) - dir_parts[2].offset;
810                                dir_parts[3].offset = dir_parts[2].offset + dir_parts[2].size;
811                                dir_parts[6].offset = mtd->size - mtd->erasesize;       // board config
812                                dir_parts[6].size = mtd->erasesize;
813                                dir_parts[5].offset = dir_parts[6].offset;      //fis config
814                                dir_parts[5].size = mtd->erasesize;
815                                dir_parts[4].offset = dir_parts[5].offset - mtd->erasesize;     //nvram
816                                dir_parts[4].size = mtd->erasesize;
817                                dir_parts[3].size = dir_parts[4].offset - dir_parts[3].offset;
818                                rootsize = dir_parts[4].offset - offset;        //size of rootfs aligned to nvram offset
819                                dir_parts[1].size = (dir_parts[2].offset -dir_parts[1].offset) + rootsize;
820                                break;
821                        }
822                offset+=4096;
823                }
824                dir_parts[7].offset = 0;        // linux + nvram = phy size
825                dir_parts[7].size = mtd->size;  // linux + nvram = phy size
826                add_mtd_partitions(mtd, dir_parts, 9);
827
828    return 0;
829}
830
831static void __exit ar7240_flash_exit(void)
832{
833    /*
834     * nothing to do
835     */
836}
837
838
839/*
840 * Primitives to implement flash operations
841 */
842#ifdef  CONFIG_BUFFALO
843static void
844ar7240_spi_write_enable(unsigned int cs) 
845{
846    ar7240_reg_wr_nf(AR7240_SPI_FS, 1);                 
847    ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
848    ar7240_spi_bit_banger(cs,AR7240_SPI_CMD_WREN);             
849    ar7240_spi_go(cs);
850}
851
852static void
853ar7240_spi_read(unsigned int cs, uint32_t addr, uint8_t *data, int len)
854{
855
856        if (cs) {
857#if     1
858                ar7240_reg_wr_nf(AR7240_SPI_FS, 1);                 
859                for (; len>0 ; len--, addr++, data++) {
860                        ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
861                        ar7240_spi_bit_banger_1(0x3);       
862                        ar7240_spi_send_addr(cs,addr);
863                        ar7240_spi_delay_8(cs);
864                        *data   = (uint8_t)ar7240_reg_rd(AR7240_SPI_RD_STATUS);
865                }
866                ar7240_spi_done();
867#else
868#if     0
869                //      Ʊ€ž·ë²Ì
870                ar7240_reg_wr_nf(AR7240_SPI_FS, 1);                 
871        for (; len>0 ; len--, data++) {
872                ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
873                ar7240_spi_bit_banger_1(0x3);       
874                        ar7240_spi_send_addr(cs,addr);
875                        ar7240_spi_delay_8(cs);
876                        *data   = (uint8_t)ar7240_reg_rd(AR7240_SPI_RD_STATUS);
877        }
878        ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
879                ar7240_spi_done();
880#else
881                ar7240_reg_wr_nf(AR7240_SPI_FS, 1);                 
882        ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
883        ar7240_spi_bit_banger_1(0x3);       
884                ar7240_spi_send_addr(cs,addr);
885                ar7240_spi_delay_8(cs);
886        for (; len>0 ; len--, data++) {
887                        *data   = (uint8_t)ar7240_reg_rd(AR7240_SPI_RD_STATUS);
888        }
889        ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
890                ar7240_spi_done();
891#endif
892#endif
893        } else {
894                ar7240_reg_wr_nf(AR7240_SPI_FS, 1);                 
895        ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
896        ar7240_spi_bit_banger_0(0x3);       
897                ar7240_spi_send_addr(cs,addr);
898                ar7240_spi_delay_8(cs);
899        for (; len>0 ; len--, data++) {
900                        *data   = (uint8_t)ar7240_reg_rd(AR7240_SPI_RD_STATUS);
901        }
902                ar7240_spi_done();
903        }
904}
905
906static void
907ar7240_spi_fast_read(unsigned int cs, uint32_t addr, uint8_t *data, int len)
908{
909
910        if (cs) {
911                ar7240_reg_wr_nf(AR7240_SPI_FS, 1);                 
912                ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
913                ar7240_spi_bit_banger_1(AR7240_SPI_CMD_FAST_READ);       
914                ar7240_spi_send_addr(cs,addr);
915                ar7240_spi_delay_8(cs);
916                for (; len>0 ; len--, data++) {
917                        ar7240_spi_delay_8(cs);
918                        *data   = (uint8_t)ar7240_reg_rd(AR7240_SPI_RD_STATUS);
919                }
920                ar7240_spi_done();
921#if             0               //OK pattern
922                ar7240_reg_wr_nf(AR7240_SPI_FS, 1);                 
923                for (; len>0 ; len--, addr++, data++) {
924                        ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
925                        ar7240_spi_bit_banger_1(AR7240_SPI_CMD_FAST_READ);       
926                        ar7240_spi_send_addr(cs,addr);
927                        ar7240_spi_delay_8(cs);
928                        ar7240_spi_delay_8(cs);
929                        *data   = (uint8_t)ar7240_reg_rd(AR7240_SPI_RD_STATUS);
930                }
931                ar7240_spi_done();
932#endif  //CONFIG_BUFFALO
933
934        } else {
935                ar7240_reg_wr_nf(AR7240_SPI_FS, 1);                 
936                ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
937                ar7240_spi_bit_banger_0(AR7240_SPI_CMD_FAST_READ);       
938                ar7240_spi_send_addr(cs,addr);
939                ar7240_spi_delay_8(cs);
940                for (; len>0 ; len--, data++) {
941                        ar7240_spi_delay_8(cs);
942                        *data   = (uint8_t)ar7240_reg_rd(AR7240_SPI_RD_STATUS);
943                }
944                ar7240_spi_done();
945        }
946}
947
948static void
949ar7240_spi_poll(unsigned int cs)   
950{
951    int rd;                                                 
952
953        if (cs) {
954            do {
955                ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
956                ar7240_spi_bit_banger_1(AR7240_SPI_CMD_RD_STATUS);       
957                ar7240_spi_delay_8(cs);
958                rd = (ar7240_reg_rd(AR7240_SPI_RD_STATUS) & 1);               
959            }while(rd);
960        } else {
961            do {
962                ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
963                ar7240_spi_bit_banger_0(AR7240_SPI_CMD_RD_STATUS);       
964                ar7240_spi_delay_8(cs);
965                rd = (ar7240_reg_rd(AR7240_SPI_RD_STATUS) & 1);               
966            }while(rd);
967        }
968}
969
970static void
971ar7240_spi_write_page(uint32_t addr, uint8_t *data, int len)
972{
973    int i;
974    uint8_t ch;
975    unsigned int cs = ar7240_spi_get_cs(addr);
976
977    ar7240_spi_write_enable(cs);
978    ar7240_spi_bit_banger(cs,AR7240_SPI_CMD_PAGE_PROG);
979    ar7240_spi_send_addr(cs,addr);
980
981    if (cs) {
982            for(i = 0; i < len; i++) {
983                ch = *(data + i);
984                ar7240_spi_bit_banger_1(ch);
985            }
986    } else {
987            for(i = 0; i < len; i++) {
988                ch = *(data + i);
989                ar7240_spi_bit_banger_0(ch);
990            }
991    }
992
993
994    ar7240_spi_go(cs);
995    ar7240_spi_poll(cs);
996}
997
998static void
999ar7240_spi_sector_erase(uint32_t addr)
1000{
1001    unsigned int cs = ar7240_spi_get_cs(addr);
1002    ar7240_spi_write_enable(cs);
1003    ar7240_spi_bit_banger(cs,AR7240_SPI_CMD_SECTOR_ERASE);
1004    ar7240_spi_send_addr(cs,addr);
1005    ar7240_spi_go(cs);
1006    ar7240_spi_poll(cs);
1007}
1008#else   //CONFIG_BUFFALO
1009static void
1010ar7240_spi_write_enable() 
1011{
1012    ar7240_reg_wr_nf(AR7240_SPI_FS, 1);                 
1013    ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
1014    ar7240_spi_bit_banger(AR7240_SPI_CMD_WREN);             
1015    ar7240_spi_go();
1016}
1017
1018static void
1019ar7240_spi_poll()   
1020{
1021    int rd;                                                 
1022
1023    do {
1024        ar7240_reg_wr_nf(AR7240_SPI_WRITE, AR7240_SPI_CS_DIS);     
1025        ar7240_spi_bit_banger(AR7240_SPI_CMD_RD_STATUS);       
1026        ar7240_spi_delay_8();
1027        rd = (ar7240_reg_rd(AR7240_SPI_RD_STATUS) & 1);               
1028    }while(rd);
1029}
1030
1031static void
1032ar7240_spi_write_page(uint32_t addr, uint8_t *data, int len)
1033{
1034    int i;
1035    uint8_t ch;
1036
1037    ar7240_spi_write_enable();
1038    ar7240_spi_bit_banger(AR7240_SPI_CMD_PAGE_PROG);
1039    ar7240_spi_send_addr(addr);
1040
1041    for(i = 0; i < len; i++) {
1042        ch = *(data + i);
1043        ar7240_spi_bit_banger(ch);
1044    }
1045
1046    ar7240_spi_go();
1047    ar7240_spi_poll();
1048}
1049
1050static void
1051ar7240_spi_sector_erase(uint32_t addr)
1052{
1053        ar7240_spi_write_enable();
1054        ar7240_spi_bit_banger(AR7240_SPI_CMD_SECTOR_ERASE);
1055        ar7240_spi_send_addr(addr);
1056        ar7240_spi_go();
1057#if 0
1058        /*
1059         * Do not touch the GPIO's unnecessarily. Might conflict
1060         * with customer's settings.
1061         */
1062        display(0x7d);
1063#endif
1064        ar7240_spi_poll();
1065}
1066#endif  //CONFIG_BUFFALO
1067
1068module_init(ar7240_flash_init);
1069module_exit(ar7240_flash_exit);
Note: See TracBrowser for help on using the repository browser.