source: src/linux/universal/linux-3.2/drivers/mtd/ralink/ralink_spi.c @ 31672

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

fix fs detection

File size: 21.7 KB
Line 
1/*
2 * MTD SPI driver for ST M25Pxx flash chips
3 *
4 * Author: Mike Lavender, mike@steroidmicros.com
5 *
6 * Copyright (c) 2005, Intec Automation Inc.
7 *
8 * Some parts are based on lart.c by Abraham Van Der Merwe
9 *
10 * Cleaned up and generalized based on mtd_dataflash.c
11 *
12 * This code is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
15 *
16 */
17
18#include <linux/init.h>
19#include <linux/module.h>
20#include <linux/device.h>
21#include <linux/interrupt.h>
22#include <linux/slab.h>
23#include <linux/vmalloc.h>
24#include <linux/mtd/mtd.h>
25#include <linux/mtd/partitions.h>
26#include <linux/mutex.h>
27#include <linux/delay.h>
28#include "ralink_spi.h"
29#include <linux/squashfs_fs.h>
30#include "../mtdcore.h"
31#include <linux/platform_device.h>
32
33
34
35extern u32 get_surfboard_sysclk(void) ;
36
37static struct mtd_partition rt2880_partitions[] = {
38        {
39                name:           "uboot",  /* mtdblock0 */
40                size:           0x30000,  /* 192K */
41                offset:         0,
42        }, {
43                name:           "uboot-config", /* mtdblock1 */
44                size:           0x10000,  /* 64K */
45                offset:         MTDPART_OFS_APPEND,
46                mask_flags:     0  /* force read-only */
47        }, {
48                name:           "factory-defaults", /* mtdblock2 */
49                size:           0x10000,  /* 64K */
50                offset:         MTDPART_OFS_APPEND,
51                mask_flags:     0  /* force read-only */
52        }
53        , {
54                name:           "linux", /* mtdblock3 */
55                size:           CONFIG_MTD_KERNEL_PART_SIZ,
56                offset:         0x50000,
57        },
58            {
59                name:           "rootfs", /* mtdblock4 */
60                size:           MTDPART_SIZ_FULL,
61                offset:         MTDPART_OFS_APPEND,
62        }, {
63                name:           "ddwrt", /* mtdblock4 */
64                size:           0x10000,
65                offset:         0x3f0000,
66        }, {
67                name:           "nvram", /* mtdblock4 */
68                size:           0x10000,
69                offset:         0x3f0000,
70        }};
71
72
73
74/******************************************************************************
75 * SPI FLASH elementray definition and function
76 ******************************************************************************/
77
78#define FLASH_PAGESIZE          256
79#define MX_4B_MODE                      /* MXIC 4 Byte Mode */
80
81/* Flash opcodes. */
82#define OPCODE_WREN             6       /* Write enable */
83#define OPCODE_RDSR             5       /* Read status register */
84#define OPCODE_WRSR             1       /* Write status register */
85#define OPCODE_READ             3       /* Read data bytes */
86#define OPCODE_PP               2       /* Page program */
87#define OPCODE_SE               0xD8    /* Sector erase */
88#define OPCODE_RES              0xAB    /* Read Electronic Signature */
89#define OPCODE_RDID             0x9F    /* Read JEDEC ID */
90
91/* Status Register bits. */
92#define SR_WIP                  1       /* Write in progress */
93#define SR_WEL                  2       /* Write enable latch */
94#define SR_BP0                  4       /* Block protect 0 */
95#define SR_BP1                  8       /* Block protect 1 */
96#define SR_BP2                  0x10    /* Block protect 2 */
97#define SR_EPE                  0x20    /* Erase/Program error */
98#define SR_SRWD                 0x80    /* SR write protect */
99
100
101static unsigned int spi_wait_nsec = 0;
102
103//#define SPI_DEBUG
104#if !defined (SPI_DEBUG)
105
106#define ra_inl(addr)  (*(volatile unsigned int *)(addr))
107#define ra_outl(addr, value)  (*(volatile unsigned int *)(addr) = (value))
108#define ra_dbg(args...) do {} while(0)
109//#define ra_dbg(args...) do { if (1) printk(args); } while(0)
110
111#else
112
113int ranfc_debug = 1;
114#define ra_dbg(args...) do { if (ranfc_debug) printk(args); } while(0)
115#define _ra_inl(addr)  (*(volatile unsigned int *)(addr))
116#define _ra_outl(addr, value)  (*(volatile unsigned int *)(addr) = (value))
117
118u32 ra_inl(u32 addr)
119{       
120        u32 retval = _ra_inl(addr);
121       
122        printk("%s(%x) => %x \n", __func__, addr, retval);
123
124        return retval; 
125}
126
127u32 ra_outl(u32 addr, u32 val)
128{
129        _ra_outl(addr, val);
130
131        printk("%s(%x, %x) \n", __func__, addr, val);
132
133        return val;     
134}
135
136#endif // SPI_DEBUG
137
138#define ra_aor(addr, a_mask, o_value)  ra_outl(addr, (ra_inl(addr) & (a_mask)) | (o_value))
139
140#define ra_and(addr, a_mask)  ra_aor(addr, a_mask, 0)
141#define ra_or(addr, o_value)  ra_aor(addr, -1, o_value)
142
143
144static int spic_busy_wait(void)
145{
146        do {
147                if ((ra_inl(RT2880_SPISTAT_REG) & 0x01) == 0)
148                        return 0;
149        } while (spi_wait_nsec >> 1);
150
151        printk("%s: fail \n", __func__);
152        return -1;
153}
154
155#define SPIC_READ_BYTES (1<<0)
156#define SPIC_WRITE_BYTES (1<<1)
157
158/*
159 * @cmd: command and address
160 * @n_cmd: size of command, in bytes
161 * @buf: buffer into which data will be read/written
162 * @n_buf: size of buffer, in bytes
163 * @flag: tag as READ/WRITE
164 *
165 * @return: if write_onlu, -1 means write fail, or return writing counter.
166 * @return: if read, -1 means read fail, or return reading counter.
167 */
168static int spic_transfer(const u8 *cmd, int n_cmd, u8 *buf, int n_buf, int flag)
169{
170        int retval = -1;
171
172        ra_dbg("cmd(%x): %x %x %x %x , buf:%x len:%x, flag:%s \n",
173                        n_cmd, cmd[0], cmd[1], cmd[2], cmd[3],
174                        (buf)? (*buf) : 0, n_buf,
175                        (flag == SPIC_READ_BYTES)? "read" : "write");
176       
177        // assert CS and we are already CLK normal high
178        ra_and(RT2880_SPICTL_REG, ~(SPICTL_SPIENA_HIGH));
179
180        // write command
181        for (retval = 0; retval < n_cmd; retval++) {
182                ra_outl(RT2880_SPIDATA_REG, cmd[retval]);
183                ra_or(RT2880_SPICTL_REG, SPICTL_STARTWR);
184                if (spic_busy_wait()) {
185                        retval = -1;
186                        goto end_trans;
187                }
188        }
189
190        // read / write  data
191        if (flag & SPIC_READ_BYTES) {
192                for (retval = 0; retval < n_buf; retval++) {
193                        ra_or(RT2880_SPICTL_REG, SPICTL_STARTRD);
194                        if (spic_busy_wait())
195                                goto end_trans;
196                        buf[retval] = (u8) ra_inl(RT2880_SPIDATA_REG);
197                }
198
199        }
200        else if (flag & SPIC_WRITE_BYTES) {
201                for (retval = 0; retval < n_buf; retval++) {
202                        ra_outl(RT2880_SPIDATA_REG, buf[retval]);
203                        ra_or(RT2880_SPICTL_REG, SPICTL_STARTWR);
204                        if (spic_busy_wait())
205                                goto end_trans;
206                }
207        }
208
209end_trans:
210        // de-assert CS and
211        ra_or (RT2880_SPICTL_REG, (SPICTL_SPIENA_HIGH));
212
213        return retval;
214}
215
216static int spic_read(const u8 *cmd, size_t n_cmd, u8 *rxbuf, size_t n_rx)
217{
218        return spic_transfer(cmd, n_cmd, rxbuf, n_rx, SPIC_READ_BYTES);
219}
220
221static int spic_write(const u8 *cmd, size_t n_cmd, const u8 *txbuf, size_t n_tx)
222{
223        return spic_transfer(cmd, n_cmd, (u8 *)txbuf, n_tx, SPIC_WRITE_BYTES);
224}
225
226int spic_init(void)
227{
228        // GPIO-SPI mode
229        ra_and(RALINK_REG_GPIOMODE, ~(1 << 1)); //use normal(SPI) mode instead of GPIO mode
230
231        /* reset spi block */
232        ra_or(RT2880_RSTCTRL_REG, RSTCTRL_SPI_RESET);
233        udelay(1);
234        ra_and(RT2880_RSTCTRL_REG, ~RSTCTRL_SPI_RESET);
235
236        // FIXME, clk_div should depend on spi-flash.
237        // mode 0 (SPICLKPOL = 0) & (RXCLKEDGE_FALLING = 0)
238        // mode 3 (SPICLKPOL = 1) & (RXCLKEDGE_FALLING = 0)
239        ra_outl(RT2880_SPICFG_REG, SPICFG_MSBFIRST | SPICFG_TXCLKEDGE_FALLING | CFG_CLK_DIV | SPICFG_SPICLKPOL );
240
241        // set idle state
242        ra_outl(RT2880_SPICTL_REG, SPICTL_HIZSDO | SPICTL_SPIENA_HIGH);
243
244        spi_wait_nsec = (8 * 1000 / ((get_surfboard_sysclk() / 1000 / 1000 / CFG_CLK_DIV) )) >> 1 ;
245        //printk("spi_wait_nsec: %x \n", spi_wait_nsec);
246        return 0;
247}
248
249
250
251
252/****************************************************************************/
253struct chip_info {
254        char            *name;
255        u8              id;
256        u32             jedec_id;
257        unsigned long   sector_size;
258        unsigned int    n_sectors;
259        char            addr4b;
260};
261
262static struct chip_info chips_data [] = {
263        /* REVISIT: fill in JEDEC ids, for parts that have them */
264        { "AT25DF321",          0x1f, 0x47000000, 64 * 1024, 64,  0 },
265        { "AT26DF161",          0x1f, 0x46000000, 64 * 1024, 32,  0 },
266        { "FL016AIF",           0x01, 0x02140000, 64 * 1024, 32,  0 },
267        { "FL064AIF",           0x01, 0x02160000, 64 * 1024, 128, 0 },
268        { "MX25L1605D",         0xc2, 0x2015c220, 64 * 1024, 32,  0 },
269        { "MX25L3205D",         0xc2, 0x2016c220, 64 * 1024, 64,  0 },
270        { "MX25L6405D",         0xc2, 0x2017c220, 64 * 1024, 128, 0 },
271        { "MX25L12805D",        0xc2, 0x2018c220, 64 * 1024, 256, 0 },
272#ifdef MX_4B_MODE
273        { "MX25L25635E",        0xc2, 0x2019c220, 64 * 1024, 512, 1 },
274#endif
275        { "S25FL128P",          0x01, 0x20180301, 64 * 1024, 256, 0 },
276        { "S25FL129P",          0x01, 0x20184D01, 64 * 1024, 256, 0 },
277        { "S25FL032P",          0x01, 0x02154D00, 64 * 1024, 64,  0 },
278        { "S25FL064P",          0x01, 0x02164D00, 64 * 1024, 128, 0 },
279        { "EN25F16",            0x1c, 0x31151c31, 64 * 1024, 32,  0 },
280        { "EN25F32",            0x1c, 0x31161c31, 64 * 1024, 64,  0 },
281        { "W25Q32BV",           0xef, 0x40160000, 64 * 1024, 64,  0 },
282};
283
284
285struct flash_info {
286        struct mutex            lock;
287        struct mtd_info         mtd;
288        struct chip_info        *chip;
289        u8                      command[5];
290};
291
292struct flash_info *flash;
293
294/****************************************************************************/
295
296
297static int raspi_read_devid(u8 *rxbuf, int n_rx)
298{
299        u8 code = OPCODE_RDID;
300        int retval;
301
302        retval = spic_read(&code, 1, rxbuf, n_rx);
303        if (retval != n_rx) {
304                printk("%s: ret: %x\n", __func__, retval);
305                return retval;
306        }
307        return retval;
308}
309
310/*
311 * Read the status register, returning its value in the location
312 */
313static int raspi_read_sr(u8 *val)
314{
315        ssize_t retval;
316        u8 code = OPCODE_RDSR;
317
318        retval = spic_read(&code, 1, val, 1);
319        if (retval != 1) {
320                printk("%s: ret: %x\n", __func__, retval);
321                return -EIO;
322        }
323        return 0;
324}
325
326/*
327 * write status register
328 */
329static int raspi_write_sr(u8 *val)
330{
331        ssize_t retval;
332        u8 code = OPCODE_WRSR;
333
334        retval = spic_write(&code, 1, val, 1);
335        if (retval != 1) {
336                printk("%s: ret: %x\n", __func__, retval);
337                return -EIO;
338        }
339        return 0;
340}
341
342#ifdef MX_4B_MODE
343static int raspi_4byte_mode(int enable)
344{
345        ssize_t retval;
346        u8 code;
347
348        if (enable)
349                code = 0xB7; /* EN4B, enter 4-byte mode */
350        else
351                code = 0xE9; /* EX4B, exit 4-byte mode */
352        retval = spic_read(&code, 1, 0, 0);
353        if (retval != 0) {
354                printk("%s: ret: %x\n", __func__, retval);
355                return -1;
356        }
357        return 0;
358}
359#endif
360
361/*
362 * Set write enable latch with Write Enable command.
363 * Returns negative if error occurred.
364 */
365static inline int raspi_write_enable(void)
366{
367        u8 code = OPCODE_WREN;
368
369        return spic_write(&code, 1, NULL, 0);
370}
371
372/*
373 * Set all sectors (global) unprotected if they are protected.
374 * Returns negative if error occurred.
375 */
376static inline int raspi_unprotect(void)
377{
378        u8 sr = 0;
379
380        if (raspi_read_sr(&sr) < 0) {
381                printk("%s: read_sr fail: %x\n", __func__, sr);
382                return -1;
383        }
384
385        if ((sr & (SR_BP0 | SR_BP1 | SR_BP2)) != 0) {
386                sr = 0;
387                raspi_write_sr(&sr);
388        }
389        return 0;
390}
391
392/*
393 * Service routine to read status register until ready, or timeout occurs.
394 * Returns non-zero if error.
395 */
396static int raspi_wait_ready(int sleep_ms)
397{
398        int count;
399        int sr = 0;
400
401        /*int timeout = sleep_ms * HZ / 1000;
402        while (timeout)
403                timeout = schedule_timeout (timeout);*/
404
405        /* one chip guarantees max 5 msec wait here after page writes,
406         * but potentially three seconds (!) after page erase.
407         */
408        for (count = 0;  count < ((sleep_ms+1) *1000); count++) {
409                if ((raspi_read_sr((u8 *)&sr)) < 0)
410                        break;
411                else if (!(sr & (SR_WIP | SR_EPE))) {
412                        return 0;
413                }
414
415                udelay(500);
416                /* REVISIT sometimes sleeping would be best */
417        }
418
419        printk("%s: read_sr fail: %x\n", __func__, sr);
420        return -EIO;
421}
422
423
424/*
425 * Erase one sector of flash memory at offset ``offset'' which is any
426 * address within the sector which should be erased.
427 *
428 * Returns 0 if successful, non-zero otherwise.
429 */
430static int raspi_erase_sector(u32 offset)
431{
432
433        /* Wait until finished previous write command. */
434        if (raspi_wait_ready(950))
435                return -EIO;
436
437        /* Send write enable, then erase commands. */
438        raspi_write_enable();
439        raspi_unprotect();
440
441#ifdef MX_4B_MODE
442        if (flash->chip->addr4b) {
443                raspi_4byte_mode(1);
444                flash->command[0] = OPCODE_SE;
445                flash->command[1] = offset >> 24;
446                flash->command[2] = offset >> 16;
447                flash->command[3] = offset >> 8;
448                flash->command[4] = offset;
449                spic_write(flash->command, 5, 0 , 0);
450                raspi_4byte_mode(0);
451                return 0;
452        }
453#endif
454
455        /* Set up command buffer. */
456        flash->command[0] = OPCODE_SE;
457        flash->command[1] = offset >> 16;
458        flash->command[2] = offset >> 8;
459        flash->command[3] = offset;
460
461        spic_write(flash->command, 4, 0 , 0);
462        return 0;
463}
464
465int raspi_set_lock (struct mtd_info *mtd, loff_t to, uint64_t len, int set)
466{
467        u32 page_offset, page_size;
468        int retval;
469
470        /*  */
471        while (len > 0) {
472                /* FIXME: 4b mode ? */
473                /* write the next page to flash */
474                flash->command[0] = (set == 0)? 0x39 : 0x36;
475                flash->command[1] = to >> 16;
476                flash->command[2] = to >> 8;
477                flash->command[3] = to;
478
479                raspi_wait_ready(1);
480                       
481                raspi_write_enable();
482
483                retval = spic_write(flash->command, 4, 0, 0);
484                       
485                if (retval < 0) {
486                        return -EIO;
487                }
488                       
489                page_offset = (to & (mtd->erasesize-1));
490                page_size = mtd->erasesize - page_offset;
491                               
492                len -= mtd->erasesize;
493                to += mtd->erasesize;
494        }
495
496        return 0;
497       
498}
499
500
501/****************************************************************************/
502
503/*
504 * MTD implementation
505 */
506
507/*
508 * Erase an address range on the flash chip.  The address range may extend
509 * one or more erase sectors.  Return an error is there is a problem erasing.
510 */
511static int ramtd_erase(struct mtd_info *mtd, struct erase_info *instr)
512{
513        u32 addr,len;
514
515        //printk("%s: addr:%x len:%x\n", __func__, instr->addr, instr->len);
516        /* sanity checks */
517        if (instr->addr + instr->len > flash->mtd.size)
518                return -EINVAL;
519        if ((((size_t)instr->addr) % mtd->erasesize) != 0 || (((size_t)instr->len) % mtd->erasesize) != 0) {
520                return -EINVAL;
521        }
522
523        addr = instr->addr;
524        len = instr->len;
525
526        mutex_lock(&flash->lock);
527
528        /* now erase those sectors */
529        while (len > 0) {
530                if (raspi_erase_sector(addr)) {
531                        instr->state = MTD_ERASE_FAILED;
532                        mutex_unlock(&flash->lock);
533                        return -EIO;
534                }
535
536                addr += mtd->erasesize;
537                len -= mtd->erasesize;
538        }
539
540        mutex_unlock(&flash->lock);
541
542        instr->state = MTD_ERASE_DONE;
543        mtd_erase_callback(instr);
544
545        return 0;
546}
547
548/*
549 * Read an address range from the flash chip.  The address range
550 * may be any size provided it is within the physical boundaries.
551 */
552static int ramtd_read(struct mtd_info *mtd, loff_t from, size_t len,
553        size_t *retlen, u_char *buf)
554{
555        size_t readlen;
556
557        //printk("%s: from:%llx len:%x\n", __func__, from, len);
558        /* sanity checks */
559        if (len == 0)
560                return 0;
561
562        if (from + len > flash->mtd.size)
563                return -EINVAL;
564
565        /* Byte count starts at zero. */
566        if (retlen)
567                *retlen = 0;
568
569        mutex_lock(&flash->lock);
570
571        /* Wait till previous write/erase is done. */
572        if (raspi_wait_ready(1)) {
573                /* REVISIT status return?? */
574                mutex_unlock(&flash->lock);
575                return -EIO;
576        }
577
578        /* NOTE: OPCODE_FAST_READ (if available) is faster... */
579
580        /* Set up the write data buffer. */
581        flash->command[0] = OPCODE_READ;
582#ifdef MX_4B_MODE
583        if (flash->chip->addr4b) {
584                raspi_4byte_mode(1);
585                flash->command[1] = from >> 24;
586                flash->command[2] = from >> 16;
587                flash->command[3] = from >> 8;
588                flash->command[4] = from;
589                readlen = spic_read(flash->command, 5, buf, len);
590                raspi_4byte_mode(0);
591        }
592        else
593#endif
594        {
595                flash->command[1] = from >> 16;
596                flash->command[2] = from >> 8;
597                flash->command[3] = from;
598                readlen = spic_read(flash->command, 4, buf, len);
599        }
600        mutex_unlock(&flash->lock);
601
602        if (retlen)
603                *retlen = readlen;
604
605        if (readlen != len)
606                return -EIO;
607
608        return 0;
609}
610
611inline int ramtd_lock (struct mtd_info *mtd, loff_t to, uint64_t len)
612{
613        return raspi_set_lock(mtd, to, len, 1);
614}
615
616inline int ramtd_unlock (struct mtd_info *mtd, loff_t to, uint64_t len)
617{
618        return raspi_set_lock(mtd, to, len, 0);
619}
620
621
622/*
623 * Write an address range to the flash chip.  Data must be written in
624 * FLASH_PAGESIZE chunks.  The address range may be any size provided
625 * it is within the physical boundaries.
626 */
627static int ramtd_write(struct mtd_info *mtd, loff_t to, size_t len,
628        size_t *retlen, const u_char *buf)
629{
630        u32 page_offset, page_size;
631        int retval;
632
633        //printk("%s: to:%llx len:%x\n", __func__, to, len);
634        if (retlen)
635                *retlen = 0;
636
637        /* sanity checks */
638        if (!len)
639                return(0);
640
641        if (to + len > flash->mtd.size)
642                return -EINVAL;
643
644        mutex_lock(&flash->lock);
645
646        /* Wait until finished previous write command. */
647        if (raspi_wait_ready(2)) {
648                mutex_unlock(&flash->lock);
649                return -1;
650        }
651
652        raspi_write_enable();
653
654        /* Set up the opcode in the write buffer. */
655        flash->command[0] = OPCODE_PP;
656#ifdef MX_4B_MODE
657        if (flash->chip->addr4b) {
658                flash->command[1] = to >> 24;
659                flash->command[2] = to >> 16;
660                flash->command[3] = to >> 8;
661                flash->command[4] = to;
662        }
663        else
664#endif
665        {
666                flash->command[1] = to >> 16;
667                flash->command[2] = to >> 8;
668                flash->command[3] = to;
669        }
670
671        /* what page do we start with? */
672        page_offset = to % FLASH_PAGESIZE;
673
674#ifdef MX_4B_MODE
675        raspi_4byte_mode(1);
676#endif
677        /* write everything in PAGESIZE chunks */
678        while (len > 0) {
679                page_size = min_t(size_t, len, FLASH_PAGESIZE-page_offset);
680                page_offset = 0;
681
682                /* write the next page to flash */
683#ifdef MX_4B_MODE
684                if (flash->chip->addr4b) {
685                        flash->command[1] = to >> 24;
686                        flash->command[2] = to >> 16;
687                        flash->command[3] = to >> 8;
688                        flash->command[4] = to;
689                }
690                else
691#endif
692                {
693                        flash->command[1] = to >> 16;
694                        flash->command[2] = to >> 8;
695                        flash->command[3] = to;
696                }
697
698                raspi_wait_ready(3);
699                raspi_write_enable();
700                raspi_unprotect();
701
702#ifdef MX_4B_MODE
703                if (flash->chip->addr4b)
704                        retval = spic_write(flash->command, 5, buf, page_size);
705                else
706#endif
707                        retval = spic_write(flash->command, 4, buf, page_size);
708                //printk("%s : to:%llx page_size:%x ret:%x\n", __func__, to, page_size, retval);
709
710                if (retval > 0) {
711                        if (retlen)
712                                *retlen += retval;
713                               
714                        if (retval < page_size) {
715                                mutex_unlock(&flash->lock);
716                                printk("%s: retval:%x return:%x page_size:%x \n",
717                                       __func__, retval, retval, page_size);
718                                return -EIO;
719                        }
720                }
721
722                len -= page_size;
723                to += page_size;
724                buf += page_size;
725        }
726
727#ifdef MX_4B_MODE
728        raspi_4byte_mode(0);
729#endif
730
731        mutex_unlock(&flash->lock);
732
733        return 0;
734}
735
736
737/****************************************************************************/
738
739/*
740 * SPI device driver setup and teardown
741 */
742struct chip_info *chip_prob(void)
743{
744        struct chip_info *info, *match;
745        u8 buf[5];
746        u32 jedec, weight;
747        int i;
748
749        raspi_read_devid(buf, 5);
750        jedec = (u32)((u32)(buf[1] << 24) | ((u32)buf[2] << 16) | ((u32)buf[3] <<8) | (u32)buf[4]);
751
752        printk("deice id : %x %x %x %x %x (%x)\n", buf[0], buf[1], buf[2], buf[3], buf[4], jedec);
753       
754        // FIXME, assign default as AT25D
755        weight = 0xffffffff;
756        match = &chips_data[0];
757        for (i = 0; i < ARRAY_SIZE(chips_data); i++) {
758                info = &chips_data[i];
759                if (info->id == buf[0]) {
760                        if (info->jedec_id == jedec)
761                                return info;
762
763                        if (weight > (info->jedec_id ^ jedec)) {
764                                weight = info->jedec_id ^ jedec;
765                                match = info;
766                        }
767                }
768        }
769        printk("Warning: un-recognized chip ID, please update SPI driver!\n");
770
771        return match;
772}
773
774#define BOOT_FROM_NOR   0
775#define BOOT_FROM_NAND  2
776#define BOOT_FROM_SPI   3
777
778
779extern int ra_check_flash_type(void);
780
781/*
782 * board specific setup should have ensured the SPI clock used here
783 * matches what the READ command supports, at least until this driver
784 * understands FAST_READ (for clocks over 25 MHz).
785 */
786static int __devinit raspi_prob(void)
787{
788        struct chip_info                *chip;
789        unsigned                        i;
790        struct squashfs_super_block *sb;
791#ifdef CONFIG_ROOTFS_IN_FLASH_NO_PADDING
792        loff_t offs;
793        struct __image_header {
794                uint8_t unused[60];
795                uint32_t ih_ksz;
796        } hdr;
797#endif
798        printk(KERN_INFO "ralink spi driver\n");       
799        if(ra_check_flash_type()!=BOOT_FROM_SPI) { /* SPI */
800            return 0;
801        }
802
803        chip = chip_prob();
804       
805        flash = kzalloc(sizeof *flash, GFP_KERNEL);
806        if (!flash)
807                return -ENOMEM;
808
809        mutex_init(&flash->lock);
810
811        flash->chip = chip;
812        memset(&flash->mtd, 0, sizeof(struct mtd_info));
813
814        flash->mtd.name = "raspi";
815        flash->mtd.type = MTD_NORFLASH;
816        flash->mtd.writesize = 1;
817        flash->mtd.flags = MTD_CAP_NORFLASH;
818        flash->mtd.size = chip->sector_size * chip->n_sectors;
819        flash->mtd.erasesize = chip->sector_size;
820        flash->mtd.erase = ramtd_erase;
821        flash->mtd.read = ramtd_read;
822        flash->mtd.write = ramtd_write;
823        flash->mtd.lock = ramtd_lock;
824        flash->mtd.unlock = ramtd_unlock;
825        flash->mtd.owner = THIS_MODULE;
826
827
828        printk("%s(%02x %04x) (%d Kbytes)\n",
829               chip->name, chip->id, chip->jedec_id, flash->mtd.size / 1024);
830
831        printk("mtd .name = %s, .size = 0x%.8x (%uM) "
832                        ".erasesize = 0x%.8x (%uK) .numeraseregions = %d\n",
833                flash->mtd.name,
834                flash->mtd.size, flash->mtd.size / (1024*1024),
835                flash->mtd.erasesize, flash->mtd.erasesize / 1024,
836                flash->mtd.numeraseregions);
837
838        if (flash->mtd.numeraseregions)
839                for (i = 0; i < flash->mtd.numeraseregions; i++)
840                        printk("mtd.eraseregions[%d] = { .offset = 0x%.8x, "
841                                ".erasesize = 0x%.8x (%uK), "
842                                ".numblocks = %d }\n",
843                                i, flash->mtd.eraseregions[i].offset,
844                                flash->mtd.eraseregions[i].erasesize,
845                                flash->mtd.eraseregions[i].erasesize / 1024,
846                                flash->mtd.eraseregions[i].numblocks);
847
848                char *buf = vmalloc(4096);
849                int offset = 0;
850                int bootsize = 0x50000;
851                int nvramsize = flash->mtd.erasesize;
852                            while((offset+flash->mtd.erasesize)<flash->mtd.size)
853                            {
854                            int retlen;
855                            flash->mtd.read(&flash->mtd,offset,sizeof(struct squashfs_super_block), &retlen, buf);
856                            if (*((__u32 *) buf) == SQUASHFS_MAGIC)
857                                    {
858                                        sb = (struct squashfs_super_block *)buf;
859                                        int len;
860
861                                        printk(KERN_EMERG "\nfound squashfs at %X with %d len\n",offset, le64_to_cpu(sb->bytes_used));
862                                        rt2880_partitions[3].size=(((flash->mtd.size)-nvramsize)-bootsize);                                     
863                                        rt2880_partitions[4].offset = offset;                                   
864                                        rt2880_partitions[4].size = rt2880_partitions[3].size-(offset-bootsize);                                       
865                                        len = offset + le64_to_cpu(sb->bytes_used);
866                                        len += (flash->mtd.erasesize - 1);
867                                        len &= ~(flash->mtd.erasesize - 1);
868                                        rt2880_partitions[6].offset = flash->mtd.size - nvramsize;                                     
869                                        rt2880_partitions[6].size = flash->mtd.erasesize;                                       
870                                        rt2880_partitions[5].offset = len;                                     
871                                        rt2880_partitions[5].size = rt2880_partitions[6].offset - len;                                 
872                                        break;
873                                    }
874                            offset+=4096;
875                            }
876                vfree(buf);
877        return add_mtd_partitions(&flash->mtd, rt2880_partitions, ARRAY_SIZE(rt2880_partitions));
878}
879
880static void __devexit raspi_remove(void)
881{
882        /* Clean up MTD stuff. */
883        del_mtd_partitions(&flash->mtd);
884
885        kfree(flash);
886       
887        flash = NULL;
888}
889
890int raspi_init(void)
891{
892        spic_init();
893        return raspi_prob();
894}
895
896
897module_init(raspi_init);
898module_exit(raspi_remove);
899
900MODULE_LICENSE("GPL");
901MODULE_AUTHOR("Mike Lavender");
902MODULE_DESCRIPTION("MTD SPI driver for ST M25Pxx flash chips");
Note: See TracBrowser for help on using the repository browser.