source: src/linux/universal/linux-4.9/drivers/mtd/ralink/ralink_spi.c @ 31630

Last change on this file since 31630 was 31630, checked in by brainslayer, 12 days ago

new fs is compatible with standard squashfs, just smaller

File size: 22.0 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/magic.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        { "MX25L25635E",        0xc2, 0x2019c220, 64 * 1024, 512, 1 },
273        { "S25FL256S",          0x01, 0x02194D01, 64 * 1024, 512, 1 },
274        { "S25FL128P",          0x01, 0x20180301, 64 * 1024, 256, 0 },
275        { "S25FL129P",          0x01, 0x20184D01, 64 * 1024, 256, 0 },
276        { "S25FL032P",          0x01, 0x02154D00, 64 * 1024, 64,  0 },
277        { "S25FL064P",          0x01, 0x02164D00, 64 * 1024, 128, 0 },
278        { "EN25F16",            0x1c, 0x31151c31, 64 * 1024, 32,  0 },
279        { "EN25F32",            0x1c, 0x31161c31, 64 * 1024, 64,  0 },
280        { "EN25Q32",            0x1c, 0x30161c30, 64 * 1024, 64,  0 }, //EN25Q32B
281        { "EN25F64",            0x1c, 0x20171c20, 64 * 1024, 128, 0 }, //EN25P64
282        { "EN25Q64",            0x1c, 0x30171c30, 64 * 1024, 128, 0 },
283        { "W25Q32BV",           0xef, 0x30160000, 64 * 1024, 64,  0 },
284        { "W25Q32BV",           0xef, 0x40160000, 64 * 1024, 64,  0 },
285        { "W25Q64BV",           0xef, 0x40170000, 64 * 1024, 128, 0 }, //S25FL064K
286        { "W25Q128BV",          0xef, 0x40180000, 64 * 1024, 256, 0 },
287
288};
289
290
291struct flash_info {
292        struct mutex            lock;
293        struct mtd_info         mtd;
294        struct chip_info        *chip;
295        u8                      command[5];
296};
297
298struct flash_info *flash;
299
300/****************************************************************************/
301
302
303static int raspi_read_devid(u8 *rxbuf, int n_rx)
304{
305        u8 code = OPCODE_RDID;
306        int retval;
307
308        retval = spic_read(&code, 1, rxbuf, n_rx);
309        if (retval != n_rx) {
310                printk("%s: ret: %x\n", __func__, retval);
311                return retval;
312        }
313        return retval;
314}
315
316/*
317 * Read the status register, returning its value in the location
318 */
319static int raspi_read_sr(u8 *val)
320{
321        ssize_t retval;
322        u8 code = OPCODE_RDSR;
323
324        retval = spic_read(&code, 1, val, 1);
325        if (retval != 1) {
326                printk("%s: ret: %x\n", __func__, retval);
327                return -EIO;
328        }
329        return 0;
330}
331
332/*
333 * write status register
334 */
335static int raspi_write_sr(u8 *val)
336{
337        ssize_t retval;
338        u8 code = OPCODE_WRSR;
339
340        retval = spic_write(&code, 1, val, 1);
341        if (retval != 1) {
342                printk("%s: ret: %x\n", __func__, retval);
343                return -EIO;
344        }
345        return 0;
346}
347
348#ifdef MX_4B_MODE
349static int raspi_4byte_mode(int enable)
350{
351        ssize_t retval;
352        u8 code;
353
354        if (enable)
355                code = 0xB7; /* EN4B, enter 4-byte mode */
356        else
357                code = 0xE9; /* EX4B, exit 4-byte mode */
358        retval = spic_read(&code, 1, 0, 0);
359        if (retval != 0) {
360                printk("%s: ret: %x\n", __func__, retval);
361                return -1;
362        }
363        return 0;
364}
365#endif
366
367/*
368 * Set write enable latch with Write Enable command.
369 * Returns negative if error occurred.
370 */
371static inline int raspi_write_enable(void)
372{
373        u8 code = OPCODE_WREN;
374
375        return spic_write(&code, 1, NULL, 0);
376}
377
378/*
379 * Set all sectors (global) unprotected if they are protected.
380 * Returns negative if error occurred.
381 */
382static inline int raspi_unprotect(void)
383{
384        u8 sr = 0;
385
386        if (raspi_read_sr(&sr) < 0) {
387                printk("%s: read_sr fail: %x\n", __func__, sr);
388                return -1;
389        }
390
391        if ((sr & (SR_BP0 | SR_BP1 | SR_BP2)) != 0) {
392                sr = 0;
393                raspi_write_sr(&sr);
394        }
395        return 0;
396}
397
398/*
399 * Service routine to read status register until ready, or timeout occurs.
400 * Returns non-zero if error.
401 */
402static int raspi_wait_ready(int sleep_ms)
403{
404        int count;
405        int sr = 0;
406
407        /*int timeout = sleep_ms * HZ / 1000;
408        while (timeout)
409                timeout = schedule_timeout (timeout);*/
410
411        /* one chip guarantees max 5 msec wait here after page writes,
412         * but potentially three seconds (!) after page erase.
413         */
414        for (count = 0;  count < ((sleep_ms+1) *1000); count++) {
415                if ((raspi_read_sr((u8 *)&sr)) < 0)
416                        break;
417                else if (!(sr & (SR_WIP | SR_EPE))) {
418                        return 0;
419                }
420
421                udelay(500);
422                /* REVISIT sometimes sleeping would be best */
423        }
424
425        printk("%s: read_sr fail: %x\n", __func__, sr);
426        return -EIO;
427}
428
429
430/*
431 * Erase one sector of flash memory at offset ``offset'' which is any
432 * address within the sector which should be erased.
433 *
434 * Returns 0 if successful, non-zero otherwise.
435 */
436static int raspi_erase_sector(u32 offset)
437{
438
439        /* Wait until finished previous write command. */
440        if (raspi_wait_ready(950))
441                return -EIO;
442
443        /* Send write enable, then erase commands. */
444        raspi_write_enable();
445        raspi_unprotect();
446
447#ifdef MX_4B_MODE
448        if (flash->chip->addr4b) {
449                raspi_4byte_mode(1);
450                flash->command[0] = OPCODE_SE;
451                flash->command[1] = offset >> 24;
452                flash->command[2] = offset >> 16;
453                flash->command[3] = offset >> 8;
454                flash->command[4] = offset;
455                spic_write(flash->command, 5, 0 , 0);
456                raspi_4byte_mode(0);
457                return 0;
458        }
459#endif
460
461        /* Set up command buffer. */
462        flash->command[0] = OPCODE_SE;
463        flash->command[1] = offset >> 16;
464        flash->command[2] = offset >> 8;
465        flash->command[3] = offset;
466
467        spic_write(flash->command, 4, 0 , 0);
468        return 0;
469}
470
471int raspi_set_lock (struct mtd_info *mtd, loff_t to, uint64_t len, int set)
472{
473        u32 page_offset, page_size;
474        int retval;
475
476        /*  */
477        while (len > 0) {
478                /* FIXME: 4b mode ? */
479                /* write the next page to flash */
480                flash->command[0] = (set == 0)? 0x39 : 0x36;
481                flash->command[1] = to >> 16;
482                flash->command[2] = to >> 8;
483                flash->command[3] = to;
484
485                raspi_wait_ready(1);
486                       
487                raspi_write_enable();
488
489                retval = spic_write(flash->command, 4, 0, 0);
490                       
491                if (retval < 0) {
492                        return -EIO;
493                }
494                       
495                page_offset = (to & (mtd->erasesize-1));
496                page_size = mtd->erasesize - page_offset;
497                               
498                len -= mtd->erasesize;
499                to += mtd->erasesize;
500        }
501
502        return 0;
503       
504}
505
506
507/****************************************************************************/
508
509/*
510 * MTD implementation
511 */
512
513/*
514 * Erase an address range on the flash chip.  The address range may extend
515 * one or more erase sectors.  Return an error is there is a problem erasing.
516 */
517static int ramtd_erase(struct mtd_info *mtd, struct erase_info *instr)
518{
519        u32 addr,len;
520
521        //printk("%s: addr:%x len:%x\n", __func__, instr->addr, instr->len);
522        /* sanity checks */
523        if (instr->addr + instr->len > flash->mtd.size)
524                return -EINVAL;
525        if ((((size_t)instr->addr) % mtd->erasesize) != 0 || (((size_t)instr->len) % mtd->erasesize) != 0) {
526                return -EINVAL;
527        }
528
529        addr = instr->addr;
530        len = instr->len;
531
532        mutex_lock(&flash->lock);
533
534        /* now erase those sectors */
535        while (len > 0) {
536                if (raspi_erase_sector(addr)) {
537                        instr->state = MTD_ERASE_FAILED;
538                        mutex_unlock(&flash->lock);
539                        return -EIO;
540                }
541
542                addr += mtd->erasesize;
543                len -= mtd->erasesize;
544        }
545
546        mutex_unlock(&flash->lock);
547
548        instr->state = MTD_ERASE_DONE;
549        mtd_erase_callback(instr);
550
551        return 0;
552}
553
554/*
555 * Read an address range from the flash chip.  The address range
556 * may be any size provided it is within the physical boundaries.
557 */
558static int ramtd_read(struct mtd_info *mtd, loff_t from, size_t len,
559        size_t *retlen, u_char *buf)
560{
561        size_t readlen;
562
563        //printk("%s: from:%llx len:%x\n", __func__, from, len);
564        /* sanity checks */
565        if (len == 0)
566                return 0;
567
568        if (from + len > flash->mtd.size)
569                return -EINVAL;
570
571        /* Byte count starts at zero. */
572        if (retlen)
573                *retlen = 0;
574
575        mutex_lock(&flash->lock);
576
577        /* Wait till previous write/erase is done. */
578        if (raspi_wait_ready(1)) {
579                /* REVISIT status return?? */
580                mutex_unlock(&flash->lock);
581                return -EIO;
582        }
583
584        /* NOTE: OPCODE_FAST_READ (if available) is faster... */
585
586        /* Set up the write data buffer. */
587        flash->command[0] = OPCODE_READ;
588#ifdef MX_4B_MODE
589        if (flash->chip->addr4b) {
590                raspi_4byte_mode(1);
591                flash->command[1] = from >> 24;
592                flash->command[2] = from >> 16;
593                flash->command[3] = from >> 8;
594                flash->command[4] = from;
595                readlen = spic_read(flash->command, 5, buf, len);
596                raspi_4byte_mode(0);
597        }
598        else
599#endif
600        {
601                flash->command[1] = from >> 16;
602                flash->command[2] = from >> 8;
603                flash->command[3] = from;
604                readlen = spic_read(flash->command, 4, buf, len);
605        }
606        mutex_unlock(&flash->lock);
607
608        if (retlen)
609                *retlen = readlen;
610
611        if (readlen != len)
612                return -EIO;
613
614        return 0;
615}
616
617inline int ramtd_lock (struct mtd_info *mtd, loff_t to, uint64_t len)
618{
619        return raspi_set_lock(mtd, to, len, 1);
620}
621
622inline int ramtd_unlock (struct mtd_info *mtd, loff_t to, uint64_t len)
623{
624        return raspi_set_lock(mtd, to, len, 0);
625}
626
627
628/*
629 * Write an address range to the flash chip.  Data must be written in
630 * FLASH_PAGESIZE chunks.  The address range may be any size provided
631 * it is within the physical boundaries.
632 */
633static int ramtd_write(struct mtd_info *mtd, loff_t to, size_t len,
634        size_t *retlen, const u_char *buf)
635{
636        u32 page_offset, page_size;
637        int retval;
638
639        //printk("%s: to:%llx len:%x\n", __func__, to, len);
640        if (retlen)
641                *retlen = 0;
642
643        /* sanity checks */
644        if (!len)
645                return(0);
646
647        if (to + len > flash->mtd.size)
648                return -EINVAL;
649
650        mutex_lock(&flash->lock);
651
652        /* Wait until finished previous write command. */
653        if (raspi_wait_ready(2)) {
654                mutex_unlock(&flash->lock);
655                return -1;
656        }
657
658        raspi_write_enable();
659
660        /* Set up the opcode in the write buffer. */
661        flash->command[0] = OPCODE_PP;
662#ifdef MX_4B_MODE
663        if (flash->chip->addr4b) {
664                flash->command[1] = to >> 24;
665                flash->command[2] = to >> 16;
666                flash->command[3] = to >> 8;
667                flash->command[4] = to;
668        }
669        else
670#endif
671        {
672                flash->command[1] = to >> 16;
673                flash->command[2] = to >> 8;
674                flash->command[3] = to;
675        }
676
677        /* what page do we start with? */
678        page_offset = to % FLASH_PAGESIZE;
679
680#ifdef MX_4B_MODE
681        raspi_4byte_mode(1);
682#endif
683        /* write everything in PAGESIZE chunks */
684        while (len > 0) {
685                page_size = min_t(size_t, len, FLASH_PAGESIZE-page_offset);
686                page_offset = 0;
687
688                /* write the next page to flash */
689#ifdef MX_4B_MODE
690                if (flash->chip->addr4b) {
691                        flash->command[1] = to >> 24;
692                        flash->command[2] = to >> 16;
693                        flash->command[3] = to >> 8;
694                        flash->command[4] = to;
695                }
696                else
697#endif
698                {
699                        flash->command[1] = to >> 16;
700                        flash->command[2] = to >> 8;
701                        flash->command[3] = to;
702                }
703
704                raspi_wait_ready(3);
705                raspi_write_enable();
706                raspi_unprotect();
707
708#ifdef MX_4B_MODE
709                if (flash->chip->addr4b)
710                        retval = spic_write(flash->command, 5, buf, page_size);
711                else
712#endif
713                        retval = spic_write(flash->command, 4, buf, page_size);
714                //printk("%s : to:%llx page_size:%x ret:%x\n", __func__, to, page_size, retval);
715
716                if (retval > 0) {
717                        if (retlen)
718                                *retlen += retval;
719                               
720                        if (retval < page_size) {
721                                mutex_unlock(&flash->lock);
722                                printk("%s: retval:%x return:%x page_size:%x \n",
723                                       __func__, retval, retval, page_size);
724                                return -EIO;
725                        }
726                }
727
728                len -= page_size;
729                to += page_size;
730                buf += page_size;
731        }
732
733#ifdef MX_4B_MODE
734        raspi_4byte_mode(0);
735#endif
736
737        mutex_unlock(&flash->lock);
738
739        return 0;
740}
741
742
743/****************************************************************************/
744
745/*
746 * SPI device driver setup and teardown
747 */
748struct chip_info *chip_prob(void)
749{
750        struct chip_info *info, *match;
751        u8 buf[5];
752        u32 jedec, weight;
753        int i;
754
755        raspi_read_devid(buf, 5);
756        jedec = (u32)((u32)(buf[1] << 24) | ((u32)buf[2] << 16) | ((u32)buf[3] <<8) | (u32)buf[4]);
757
758        printk("device id : %x %x %x %x %x (%x)\n", buf[0], buf[1], buf[2], buf[3], buf[4], jedec);
759       
760        // FIXME, assign default as AT25D
761        weight = 0xffffffff;
762        match = &chips_data[0];
763        for (i = 0; i < ARRAY_SIZE(chips_data); i++) {
764                info = &chips_data[i];
765                if (info->id == buf[0]) {
766                        if (info->jedec_id == jedec)
767                                return info;
768
769                        if (weight > (info->jedec_id ^ jedec)) {
770                                weight = info->jedec_id ^ jedec;
771                                match = info;
772                        }
773                }
774        }
775        printk("Warning: un-recognized chip ID, please update SPI driver!\n");
776
777        return match;
778}
779
780#define BOOT_FROM_NOR   0
781#define BOOT_FROM_NAND  2
782#define BOOT_FROM_SPI   3
783
784
785extern int ra_check_flash_type(void);
786
787/*
788 * board specific setup should have ensured the SPI clock used here
789 * matches what the READ command supports, at least until this driver
790 * understands FAST_READ (for clocks over 25 MHz).
791 */
792static int raspi_prob(void)
793{
794        struct chip_info                *chip;
795        unsigned                        i;
796        struct squashfs_super_block *sb;
797#ifdef CONFIG_ROOTFS_IN_FLASH_NO_PADDING
798        loff_t offs;
799        struct __image_header {
800                uint8_t unused[60];
801                uint32_t ih_ksz;
802        } hdr;
803#endif
804        printk(KERN_INFO "ralink spi driver\n");       
805        if(ra_check_flash_type()!=BOOT_FROM_SPI) { /* SPI */
806            return 0;
807        }
808
809        chip = chip_prob();
810       
811        flash = kzalloc(sizeof *flash, GFP_KERNEL);
812        if (!flash)
813                return -ENOMEM;
814
815        mutex_init(&flash->lock);
816
817        flash->chip = chip;
818        memset(&flash->mtd, 0, sizeof(struct mtd_info));
819
820        flash->mtd.name = "raspi";
821        flash->mtd.type = MTD_NORFLASH;
822        flash->mtd.writesize = 1;
823        flash->mtd.flags = MTD_CAP_NORFLASH;
824        flash->mtd.size = chip->sector_size * chip->n_sectors;
825        flash->mtd.erasesize = chip->sector_size;
826        flash->mtd._erase = ramtd_erase;
827        flash->mtd._read = ramtd_read;
828        flash->mtd._write = ramtd_write;
829        flash->mtd._lock = ramtd_lock;
830        flash->mtd._unlock = ramtd_unlock;
831        flash->mtd.owner = THIS_MODULE;
832
833
834        printk("%s(%02x %04x) (%lld Kbytes)\n",
835               chip->name, chip->id, chip->jedec_id, flash->mtd.size / 1024);
836
837        printk("mtd .name = %s, .size = 0x%.8llx (%lluM) "
838                        ".erasesize = 0x%.8x (%uK) .numeraseregions = %d\n",
839                flash->mtd.name,
840                flash->mtd.size, flash->mtd.size / (1024*1024),
841                flash->mtd.erasesize, flash->mtd.erasesize / 1024,
842                flash->mtd.numeraseregions);
843
844        if (flash->mtd.numeraseregions)
845                for (i = 0; i < flash->mtd.numeraseregions; i++)
846                        printk("mtd.eraseregions[%d] = { .offset = 0x%.8llx, "
847                                ".erasesize = 0x%.8x (%uK), "
848                                ".numblocks = %d }\n",
849                                i, flash->mtd.eraseregions[i].offset,
850                                flash->mtd.eraseregions[i].erasesize,
851                                flash->mtd.eraseregions[i].erasesize / 1024,
852                                flash->mtd.eraseregions[i].numblocks);
853
854                char *buf = vmalloc(4096);
855                int offset = 0;
856                int bootsize = 0x50000;
857                int nvramsize = flash->mtd.erasesize;
858                            while((offset+flash->mtd.erasesize)<flash->mtd.size)
859                            {
860                            int retlen;
861                            mtd_read(&flash->mtd,offset,sizeof(struct squashfs_super_block), &retlen, buf);
862                            if (*((__u32 *) buf) == SQUASHFS_MAGIC)
863                                    {
864                                        sb = (struct squashfs_super_block *)buf;
865                                        int len;
866
867                                        printk(KERN_EMERG "\nfound squashfs at %X with %d len\n",offset, sb->bytes_used);
868                                        rt2880_partitions[3].size=(((flash->mtd.size)-nvramsize)-bootsize);                                     
869                                        rt2880_partitions[4].offset = offset;                                   
870                                        rt2880_partitions[4].size = rt2880_partitions[3].size-(offset-bootsize);                                       
871                                        len = offset + sb->bytes_used;
872                                        len += (flash->mtd.erasesize - 1);
873                                        len &= ~(flash->mtd.erasesize - 1);
874                                        rt2880_partitions[6].offset = flash->mtd.size - nvramsize;                                     
875                                        rt2880_partitions[6].size = flash->mtd.erasesize;                                       
876                                        rt2880_partitions[5].offset = len;                                     
877                                        rt2880_partitions[5].size = rt2880_partitions[6].offset - len;                                 
878                                        break;
879                                    }
880                            offset+=4096;
881                            }
882                vfree(buf);
883        return add_mtd_partitions(&flash->mtd, rt2880_partitions, ARRAY_SIZE(rt2880_partitions));
884}
885
886static void raspi_remove(void)
887{
888        /* Clean up MTD stuff. */
889        del_mtd_partitions(&flash->mtd);
890
891        kfree(flash);
892       
893        flash = NULL;
894}
895
896int raspi_init(void)
897{
898        spic_init();
899        return raspi_prob();
900}
901
902
903module_init(raspi_init);
904module_exit(raspi_remove);
905
906MODULE_LICENSE("GPL");
907MODULE_AUTHOR("Mike Lavender");
908MODULE_DESCRIPTION("MTD SPI driver for ST M25Pxx flash chips");
Note: See TracBrowser for help on using the repository browser.