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