drivers/mtd/chips/cfi_util.c

   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  * $Id: cfi_util.c,v 1.8 2004/12/14 19:55:56 nico Exp $
  11  *
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/types.h>
  16 #include <linux/kernel.h>
  17 #include <linux/sched.h>
  18 #include <asm/io.h>
  19 #include <asm/byteorder.h>
  20
  21 #include <linux/errno.h>
  22 #include <linux/slab.h>
  23 #include <linux/delay.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/mtd/xip.h>
  26 #include <linux/mtd/mtd.h>
  27 #include <linux/mtd/map.h>
  28 #include <linux/mtd/cfi.h>
  29 #include <linux/mtd/compatmac.h>
  30
  31 struct cfi_extquery *
  32 __xipram cfi_read_pri(struct map_info *map, __u16 adr, __u16 size, const char* name)
  33 {
  34         struct cfi_private *cfi = map->fldrv_priv;
  35         __u32 base = 0; // cfi->chips[0].start;
  36         int ofs_factor = cfi->interleave * cfi->device_type;
  37         int i;
  38         struct cfi_extquery *extp = NULL;
  39
  40         printk(" %s Extended Query Table at 0x%4.4X\n", name, adr);
  41         if (!adr)
  42                 goto out;
  43
  44         extp = kmalloc(size, GFP_KERNEL);
  45         if (!extp) {
  46                 printk(KERN_ERR "Failed to allocate memory\n");
  47                 goto out;
  48         }
  49
  50 #ifdef CONFIG_MTD_XIP
  51         local_irq_disable();
  52 #endif
  53
  54         /* Switch it into Query Mode */
  55         cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
  56
  57         /* Read in the Extended Query Table */
  58         for (i=0; i<size; i++) {
  59                 ((unsigned char *)extp)[i] =
  60                         cfi_read_query(map, base+((adr+i)*ofs_factor));
  61         }
  62
  63         /* Make sure it returns to read mode */
  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
  67 #ifdef CONFIG_MTD_XIP
  68         (void) map_read(map, base);
  69         asm volatile (".rep 8; nop; .endr");
  70         local_irq_enable();
  71 #endif
  72
  73         if (extp->MajorVersion != '1' ||
  74             (extp->MinorVersion < '0' || extp->MinorVersion > '3')) {
  75                 printk(KERN_WARNING "  Unknown %s Extended Query "
  76                        "version %c.%c.\n",  name, extp->MajorVersion,
  77                        extp->MinorVersion);
  78                 kfree(extp);
  79                 extp = NULL;
  80         }
  81
  82  out:   return extp;
  83 }
  84
  85 EXPORT_SYMBOL(cfi_read_pri);
  86
  87 void cfi_fixup(struct mtd_info *mtd, struct cfi_fixup *fixups)
  88 {
  89         struct map_info *map = mtd->priv;
  90         struct cfi_private *cfi = map->fldrv_priv;
  91         struct cfi_fixup *f;
  92
  93         for (f=fixups; f->fixup; f++) {
  94                 if (((f->mfr == CFI_MFR_ANY) || (f->mfr == cfi->mfr)) &&
  95                     ((f->id  == CFI_ID_ANY)  || (f->id  == cfi->id))) {
  96                         f->fixup(mtd, f->param);
  97                 }
  98         }
  99 }
 100
 101 EXPORT_SYMBOL(cfi_fixup);
 102
 103 int cfi_varsize_frob(struct mtd_info *mtd, varsize_frob_t frob,
 104                                      loff_t ofs, size_t len, void *thunk)
 105 {
 106         struct map_info *map = mtd->priv;
 107         struct cfi_private *cfi = map->fldrv_priv;
 108         unsigned long adr;
 109         int chipnum, ret = 0;
 110         int i, first;
 111         struct mtd_erase_region_info *regions = mtd->eraseregions;
 112
 113         if (ofs > mtd->size)
 114                 return -EINVAL;
 115
 116         if ((len + ofs) > mtd->size)
 117                 return -EINVAL;
 118
 119         /* Check that both start and end of the requested erase are
 120          * aligned with the erasesize at the appropriate addresses.
 121          */
 122
 123         i = 0;
 124
 125         /* Skip all erase regions which are ended before the start of
 126            the requested erase. Actually, to save on the calculations,
 127            we skip to the first erase region which starts after the
 128            start of the requested erase, and then go back one.
 129         */
 130
 131         while (i < mtd->numeraseregions && ofs >= regions[i].offset)
 132                i++;
 133         i--;
 134
 135         /* OK, now i is pointing at the erase region in which this
 136            erase request starts. Check the start of the requested
 137            erase range is aligned with the erase size which is in
 138            effect here.
 139         */
 140
 141         if (ofs & (regions[i].erasesize-1))
 142                 return -EINVAL;
 143
 144         /* Remember the erase region we start on */
 145         first = i;
 146
 147         /* Next, check that the end of the requested erase is aligned
 148          * with the erase region at that address.
 149          */
 150
 151         while (i<mtd->numeraseregions && (ofs + len) >= regions[i].offset)
 152                 i++;
 153
 154         /* As before, drop back one to point at the region in which
 155            the address actually falls
 156         */
 157         i--;
 158
 159         if ((ofs + len) & (regions[i].erasesize-1))
 160                 return -EINVAL;
 161
 162         chipnum = ofs >> cfi->chipshift;
 163         adr = ofs - (chipnum << cfi->chipshift);
 164
 165         i=first;
 166
 167         while(len) {
 168                 int size = regions[i].erasesize;
 169
 170                 ret = (*frob)(map, &cfi->chips[chipnum], adr, size, thunk);
 171
 172                 if (ret)
 173                         return ret;
 174
 175                 adr += size;
 176                 ofs += size;
 177                 len -= size;
 178
 179                 if (ofs == regions[i].offset + size * regions[i].numblocks)
 180                         i++;
 181
 182                 if (adr >> cfi->chipshift) {
 183                         adr = 0;
 184                         chipnum++;
 185
 186                         if (chipnum >= cfi->numchips)
 187                         break;
 188                 }
 189         }
 190
 191         return 0;
 192 }
 193
 194 EXPORT_SYMBOL(cfi_varsize_frob);
 195
 196 MODULE_LICENSE("GPL");