← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/mtd/devices/m25p80.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/mtd/devices/m25p80.c
27
27
#include <linux/sched.h>
28
28
#include <linux/mod_devicetable.h>
29
29
 
 
30
#include <linux/mtd/cfi.h>
30
31
#include <linux/mtd/mtd.h>
31
32
#include <linux/mtd/partitions.h>
32
33
 
55
56
#define OPCODE_EN4B             0xb7    /* Enter 4-byte mode */
56
57
#define OPCODE_EX4B             0xe9    /* Exit 4-byte mode */
57
58
 
 
59
/* Used for Spansion flashes only. */
 
60
#define OPCODE_BRWR             0x17    /* Bank register write */
 
61
 
58
62
/* Status Register bits. */
59
63
#define SR_WIP                  1       /* Write in progress */
60
64
#define SR_WEL                  2       /* Write enable latch */
76
80
#define FAST_READ_DUMMY_BYTE 0
77
81
#endif
78
82
 
 
83
#define JEDEC_MFR(_jedec_id)    ((_jedec_id) >> 16)
 
84
 
79
85
/****************************************************************************/
80
86
 
81
87
struct m25p {
158
164
/*
159
165
 * Enable/disable 4-byte addressing mode.
160
166
 */
161
 
static inline int set_4byte(struct m25p *flash, int enable)
 
167
static inline int set_4byte(struct m25p *flash, u32 jedec_id, int enable)
162
168
{
163
 
        u8      code = enable ? OPCODE_EN4B : OPCODE_EX4B;
164
 
 
165
 
        return spi_write_then_read(flash->spi, &code, 1, NULL, 0);
 
169
        switch (JEDEC_MFR(jedec_id)) {
 
170
        case CFI_MFR_MACRONIX:
 
171
                flash->command[0] = enable ? OPCODE_EN4B : OPCODE_EX4B;
 
172
                return spi_write(flash->spi, flash->command, 1);
 
173
        default:
 
174
                /* Spansion style */
 
175
                flash->command[0] = OPCODE_BRWR;
 
176
                flash->command[1] = enable << 7;
 
177
                return spi_write(flash->spi, flash->command, 2);
 
178
        }
166
179
}
167
180
 
168
181
/*
655
668
        { "at26df161a", INFO(0x1f4601, 0, 64 * 1024, 32, SECT_4K) },
656
669
        { "at26df321",  INFO(0x1f4700, 0, 64 * 1024, 64, SECT_4K) },
657
670
 
658
 
        /* EON -- en25pxx */
 
671
        /* EON -- en25xxx */
 
672
        { "en25f32", INFO(0x1c3116, 0, 64 * 1024,  64, SECT_4K) },
659
673
        { "en25p32", INFO(0x1c2016, 0, 64 * 1024,  64, 0) },
660
674
        { "en25p64", INFO(0x1c2017, 0, 64 * 1024, 128, 0) },
661
675
 
667
681
        /* Macronix */
668
682
        { "mx25l4005a",  INFO(0xc22013, 0, 64 * 1024,   8, SECT_4K) },
669
683
        { "mx25l8005",   INFO(0xc22014, 0, 64 * 1024,  16, 0) },
 
684
        { "mx25l1606e",  INFO(0xc22015, 0, 64 * 1024,  32, SECT_4K) },
670
685
        { "mx25l3205d",  INFO(0xc22016, 0, 64 * 1024,  64, 0) },
671
686
        { "mx25l6405d",  INFO(0xc22017, 0, 64 * 1024, 128, 0) },
672
687
        { "mx25l12805d", INFO(0xc22018, 0, 64 * 1024, 256, 0) },
683
698
        { "s25sl032a",  INFO(0x010215,      0,  64 * 1024,  64, 0) },
684
699
        { "s25sl032p",  INFO(0x010215, 0x4d00,  64 * 1024,  64, SECT_4K) },
685
700
        { "s25sl064a",  INFO(0x010216,      0,  64 * 1024, 128, 0) },
 
701
        { "s25fl256s0", INFO(0x010219, 0x4d00, 256 * 1024, 128, 0) },
 
702
        { "s25fl256s1", INFO(0x010219, 0x4d01,  64 * 1024, 512, 0) },
 
703
        { "s25fl512s",  INFO(0x010220, 0x4d00, 256 * 1024, 256, 0) },
 
704
        { "s70fl01gs",  INFO(0x010221, 0x4d00, 256 * 1024, 256, 0) },
686
705
        { "s25sl12800", INFO(0x012018, 0x0300, 256 * 1024,  64, 0) },
687
706
        { "s25sl12801", INFO(0x012018, 0x0301,  64 * 1024, 256, 0) },
688
707
        { "s25fl129p0", INFO(0x012018, 0x4d00, 256 * 1024,  64, 0) },
728
747
        { "m25pe80", INFO(0x208014,  0, 64 * 1024, 16,       0) },
729
748
        { "m25pe16", INFO(0x208015,  0, 64 * 1024, 32, SECT_4K) },
730
749
 
 
750
        { "m25px32",    INFO(0x207116,  0, 64 * 1024, 64, SECT_4K) },
 
751
        { "m25px32-s0", INFO(0x207316,  0, 64 * 1024, 64, SECT_4K) },
 
752
        { "m25px32-s1", INFO(0x206316,  0, 64 * 1024, 64, SECT_4K) },
 
753
        { "m25px64",    INFO(0x207117,  0, 64 * 1024, 128, 0) },
 
754
 
731
755
        /* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
732
756
        { "w25x10", INFO(0xef3011, 0, 64 * 1024,  2,  SECT_4K) },
733
757
        { "w25x20", INFO(0xef3012, 0, 64 * 1024,  4,  SECT_4K) },
801
825
        struct m25p                     *flash;
802
826
        struct flash_info               *info;
803
827
        unsigned                        i;
 
828
        struct mtd_partition            *parts = NULL;
 
829
        int                             nr_parts = 0;
804
830
 
805
831
        /* Platform data helps sort out which chip type we have, as
806
832
         * well as how this board partitions it.  If we don't have
865
891
         * up with the software protection bits set
866
892
         */
867
893
 
868
 
        if (info->jedec_id >> 16 == 0x1f ||
869
 
            info->jedec_id >> 16 == 0x89 ||
870
 
            info->jedec_id >> 16 == 0xbf) {
 
894
        if (JEDEC_MFR(info->jedec_id) == CFI_MFR_ATMEL ||
 
895
            JEDEC_MFR(info->jedec_id) == CFI_MFR_INTEL ||
 
896
            JEDEC_MFR(info->jedec_id) == CFI_MFR_SST) {
871
897
                write_enable(flash);
872
898
                write_sr(flash, 0);
873
899
        }
885
911
        flash->mtd.read = m25p80_read;
886
912
 
887
913
        /* sst flash chips use AAI word program */
888
 
        if (info->jedec_id >> 16 == 0xbf)
 
914
        if (JEDEC_MFR(info->jedec_id) == CFI_MFR_SST)
889
915
                flash->mtd.write = sst_write;
890
916
        else
891
917
                flash->mtd.write = m25p80_write;
911
937
                /* enable 4-byte addressing if the device exceeds 16MiB */
912
938
                if (flash->mtd.size > 0x1000000) {
913
939
                        flash->addr_width = 4;
914
 
                        set_4byte(flash, 1);
 
940
                        set_4byte(flash, info->jedec_id, 1);
915
941
                } else
916
942
                        flash->addr_width = 3;
917
943
        }
942
968
        /* partitions should match sector boundaries; and it may be good to
943
969
         * use readonly partitions for writeprotected sectors (BP2..BP0).
944
970
         */
945
 
        if (mtd_has_partitions()) {
946
 
                struct mtd_partition    *parts = NULL;
947
 
                int                     nr_parts = 0;
948
 
 
949
 
                if (mtd_has_cmdlinepart()) {
950
 
                        static const char *part_probes[]
951
 
                                        = { "cmdlinepart", NULL, };
952
 
 
953
 
                        nr_parts = parse_mtd_partitions(&flash->mtd,
954
 
                                        part_probes, &parts, 0);
955
 
                }
956
 
 
957
 
                if (nr_parts <= 0 && data && data->parts) {
958
 
                        parts = data->parts;
959
 
                        nr_parts = data->nr_parts;
960
 
                }
 
971
        if (mtd_has_cmdlinepart()) {
 
972
                static const char *part_probes[]
 
973
                        = { "cmdlinepart", NULL, };
 
974
 
 
975
                nr_parts = parse_mtd_partitions(&flash->mtd,
 
976
                                                part_probes, &parts, 0);
 
977
        }
 
978
 
 
979
        if (nr_parts <= 0 && data && data->parts) {
 
980
                parts = data->parts;
 
981
                nr_parts = data->nr_parts;
 
982
        }
961
983
 
962
984
#ifdef CONFIG_MTD_OF_PARTS
963
 
                if (nr_parts <= 0 && spi->dev.of_node) {
964
 
                        nr_parts = of_mtd_parse_partitions(&spi->dev,
965
 
                                        spi->dev.of_node, &parts);
966
 
                }
 
985
        if (nr_parts <= 0 && spi->dev.of_node) {
 
986
                nr_parts = of_mtd_parse_partitions(&spi->dev,
 
987
                                                   spi->dev.of_node, &parts);
 
988
        }
967
989
#endif
968
990
 
969
 
                if (nr_parts > 0) {
970
 
                        for (i = 0; i < nr_parts; i++) {
971
 
                                DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
972
 
                                        "{.name = %s, .offset = 0x%llx, "
973
 
                                                ".size = 0x%llx (%lldKiB) }\n",
974
 
                                        i, parts[i].name,
975
 
                                        (long long)parts[i].offset,
976
 
                                        (long long)parts[i].size,
977
 
                                        (long long)(parts[i].size >> 10));
978
 
                        }
979
 
                        flash->partitioned = 1;
980
 
                        return add_mtd_partitions(&flash->mtd, parts, nr_parts);
 
991
        if (nr_parts > 0) {
 
992
                for (i = 0; i < nr_parts; i++) {
 
993
                        DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
 
994
                              "{.name = %s, .offset = 0x%llx, "
 
995
                              ".size = 0x%llx (%lldKiB) }\n",
 
996
                              i, parts[i].name,
 
997
                              (long long)parts[i].offset,
 
998
                              (long long)parts[i].size,
 
999
                              (long long)(parts[i].size >> 10));
981
1000
                }
982
 
        } else if (data && data->nr_parts)
983
 
                dev_warn(&spi->dev, "ignoring %d default partitions on %s\n",
984
 
                                data->nr_parts, data->name);
 
1001
                flash->partitioned = 1;
 
1002
        }
985
1003
 
986
 
        return add_mtd_device(&flash->mtd) == 1 ? -ENODEV : 0;
 
1004
        return mtd_device_register(&flash->mtd, parts, nr_parts) == 1 ?
 
1005
                -ENODEV : 0;
987
1006
}
988
1007
 
989
1008
 
993
1012
        int             status;
994
1013
 
995
1014
        /* Clean up MTD stuff. */
996
 
        if (mtd_has_partitions() && flash->partitioned)
997
 
                status = del_mtd_partitions(&flash->mtd);
998
 
        else
999
 
                status = del_mtd_device(&flash->mtd);
 
1015
        status = mtd_device_unregister(&flash->mtd);
1000
1016
        if (status == 0) {
1001
1017
                kfree(flash->command);
1002
1018
                kfree(flash);