1 /*
2 * Common Flash Interface support:
3 * Generic utility functions not dependant on command set
4 *
5 * Copyright (C) 2002 Red Hat
6 * Copyright (C) 2003 STMicroelectronics Limited
7 *
8 * This code is covered by the GPL.
9 */
10
11 #include <linux/module.h>
12 #include <linux/types.h>
13 #include <linux/kernel.h>
14 #include <asm/io.h>
15 #include <asm/byteorder.h>
16
17 #include <linux/errno.h>
18 #include <linux/slab.h>
19 #include <linux/delay.h>
20 #include <linux/interrupt.h>
21 #include <linux/mtd/xip.h>
22 #include <linux/mtd/mtd.h>
23 #include <linux/mtd/map.h>
24 #include <linux/mtd/cfi.h>
25 #include <linux/mtd/compatmac.h>
26
cfi_qry_present(struct map_info * map,__u32 base,struct cfi_private * cfi)27 int __xipram cfi_qry_present(struct map_info *map, __u32 base,
28 struct cfi_private *cfi)
29 {
30 int osf = cfi->interleave * cfi->device_type; /* scale factor */
31 map_word val[3];
32 map_word qry[3];
33
34 qry[0] = cfi_build_cmd('Q', map, cfi);
35 qry[1] = cfi_build_cmd('R', map, cfi);
36 qry[2] = cfi_build_cmd('Y', map, cfi);
37
38 val[0] = map_read(map, base + osf*0x10);
39 val[1] = map_read(map, base + osf*0x11);
40 val[2] = map_read(map, base + osf*0x12);
41
42 if (!map_word_equal(map, qry[0], val[0]))
43 return 0;
44
45 if (!map_word_equal(map, qry[1], val[1]))
46 return 0;
47
48 if (!map_word_equal(map, qry[2], val[2]))
49 return 0;
50
51 return 1; /* "QRY" found */
52 }
53 EXPORT_SYMBOL_GPL(cfi_qry_present);
54
cfi_qry_mode_on(uint32_t base,struct map_info * map,struct cfi_private * cfi)55 int __xipram cfi_qry_mode_on(uint32_t base, struct map_info *map,
56 struct cfi_private *cfi)
57 {
58 cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
59 cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
60 if (cfi_qry_present(map, base, cfi))
61 return 1;
62 /* QRY not found probably we deal with some odd CFI chips */
63 /* Some revisions of some old Intel chips? */
64 cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
65 cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
66 cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
67 if (cfi_qry_present(map, base, cfi))
68 return 1;
69 /* ST M29DW chips */
70 cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
71 cfi_send_gen_cmd(0x98, 0x555, base, map, cfi, cfi->device_type, NULL);
72 if (cfi_qry_present(map, base, cfi))
73 return 1;
74 /* QRY not found */
75 return 0;
76 }
77 EXPORT_SYMBOL_GPL(cfi_qry_mode_on);
78
cfi_qry_mode_off(uint32_t base,struct map_info * map,struct cfi_private * cfi)79 void __xipram cfi_qry_mode_off(uint32_t base, struct map_info *map,
80 struct cfi_private *cfi)
81 {
82 cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
83 cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
84 }
85 EXPORT_SYMBOL_GPL(cfi_qry_mode_off);
86
87 struct cfi_extquery *
cfi_read_pri(struct map_info * map,__u16 adr,__u16 size,const char * name)88 __xipram cfi_read_pri(struct map_info *map, __u16 adr, __u16 size, const char* name)
89 {
90 struct cfi_private *cfi = map->fldrv_priv;
91 __u32 base = 0; // cfi->chips[0].start;
92 int ofs_factor = cfi->interleave * cfi->device_type;
93 int i;
94 struct cfi_extquery *extp = NULL;
95
96 printk(" %s Extended Query Table at 0x%4.4X\n", name, adr);
97 if (!adr)
98 goto out;
99
100 extp = kmalloc(size, GFP_KERNEL);
101 if (!extp) {
102 printk(KERN_ERR "Failed to allocate memory\n");
103 goto out;
104 }
105
106 #ifdef CONFIG_MTD_XIP
107 local_irq_disable();
108 #endif
109
110 /* Switch it into Query Mode */
111 cfi_qry_mode_on(base, map, cfi);
112 /* Read in the Extended Query Table */
113 for (i=0; i<size; i++) {
114 ((unsigned char *)extp)[i] =
115 cfi_read_query(map, base+((adr+i)*ofs_factor));
116 }
117
118 /* Make sure it returns to read mode */
119 cfi_qry_mode_off(base, map, cfi);
120
121 #ifdef CONFIG_MTD_XIP
122 (void) map_read(map, base);
123 xip_iprefetch();
124 local_irq_enable();
125 #endif
126
127 out: return extp;
128 }
129
130 EXPORT_SYMBOL(cfi_read_pri);
131
cfi_fixup(struct mtd_info * mtd,struct cfi_fixup * fixups)132 void cfi_fixup(struct mtd_info *mtd, struct cfi_fixup *fixups)
133 {
134 struct map_info *map = mtd->priv;
135 struct cfi_private *cfi = map->fldrv_priv;
136 struct cfi_fixup *f;
137
138 for (f=fixups; f->fixup; f++) {
139 if (((f->mfr == CFI_MFR_ANY) || (f->mfr == cfi->mfr)) &&
140 ((f->id == CFI_ID_ANY) || (f->id == cfi->id))) {
141 f->fixup(mtd, f->param);
142 }
143 }
144 }
145
146 EXPORT_SYMBOL(cfi_fixup);
147
cfi_varsize_frob(struct mtd_info * mtd,varsize_frob_t frob,loff_t ofs,size_t len,void * thunk)148 int cfi_varsize_frob(struct mtd_info *mtd, varsize_frob_t frob,
149 loff_t ofs, size_t len, void *thunk)
150 {
151 struct map_info *map = mtd->priv;
152 struct cfi_private *cfi = map->fldrv_priv;
153 unsigned long adr;
154 int chipnum, ret = 0;
155 int i, first;
156 struct mtd_erase_region_info *regions = mtd->eraseregions;
157
158 if (ofs > mtd->size)
159 return -EINVAL;
160
161 if ((len + ofs) > mtd->size)
162 return -EINVAL;
163
164 /* Check that both start and end of the requested erase are
165 * aligned with the erasesize at the appropriate addresses.
166 */
167
168 i = 0;
169
170 /* Skip all erase regions which are ended before the start of
171 the requested erase. Actually, to save on the calculations,
172 we skip to the first erase region which starts after the
173 start of the requested erase, and then go back one.
174 */
175
176 while (i < mtd->numeraseregions && ofs >= regions[i].offset)
177 i++;
178 i--;
179
180 /* OK, now i is pointing at the erase region in which this
181 erase request starts. Check the start of the requested
182 erase range is aligned with the erase size which is in
183 effect here.
184 */
185
186 if (ofs & (regions[i].erasesize-1))
187 return -EINVAL;
188
189 /* Remember the erase region we start on */
190 first = i;
191
192 /* Next, check that the end of the requested erase is aligned
193 * with the erase region at that address.
194 */
195
196 while (i<mtd->numeraseregions && (ofs + len) >= regions[i].offset)
197 i++;
198
199 /* As before, drop back one to point at the region in which
200 the address actually falls
201 */
202 i--;
203
204 if ((ofs + len) & (regions[i].erasesize-1))
205 return -EINVAL;
206
207 chipnum = ofs >> cfi->chipshift;
208 adr = ofs - (chipnum << cfi->chipshift);
209
210 i=first;
211
212 while(len) {
213 int size = regions[i].erasesize;
214
215 ret = (*frob)(map, &cfi->chips[chipnum], adr, size, thunk);
216
217 if (ret)
218 return ret;
219
220 adr += size;
221 ofs += size;
222 len -= size;
223
224 if (ofs == regions[i].offset + size * regions[i].numblocks)
225 i++;
226
227 if (adr >> cfi->chipshift) {
228 adr = 0;
229 chipnum++;
230
231 if (chipnum >= cfi->numchips)
232 break;
233 }
234 }
235
236 return 0;
237 }
238
239 EXPORT_SYMBOL(cfi_varsize_frob);
240
241 MODULE_LICENSE("GPL");
242