drivers/mtd/chips/fwh_lock.h

   1 #ifndef FWH_LOCK_H
   2 #define FWH_LOCK_H
   3
   4
   5 enum fwh_lock_state {
   6         FWH_UNLOCKED   = 0,
   7         FWH_DENY_WRITE = 1,
   8         FWH_IMMUTABLE  = 2,
   9         FWH_DENY_READ  = 4,
  10 };
  11
  12 struct fwh_xxlock_thunk {
  13         enum fwh_lock_state val;
  14         flstate_t state;
  15 };
  16
  17
  18 #define FWH_XXLOCK_ONEBLOCK_LOCK   ((struct fwh_xxlock_thunk){ FWH_DENY_WRITE, FL_LOCKING})
  19 #define FWH_XXLOCK_ONEBLOCK_UNLOCK ((struct fwh_xxlock_thunk){ FWH_UNLOCKED,   FL_UNLOCKING})
  20
  21 /*
  22  * This locking/unlock is specific to firmware hub parts.  Only one
  23  * is known that supports the Intel command set.    Firmware
  24  * hub parts cannot be interleaved as they are on the LPC bus
  25  * so this code has not been tested with interleaved chips,
  26  * and will likely fail in that context.
  27  */
  28 static int fwh_xxlock_oneblock(struct map_info *map, struct flchip *chip,
  29         unsigned long adr, int len, void *thunk)
  30 {
  31         struct cfi_private *cfi = map->fldrv_priv;
  32         struct fwh_xxlock_thunk *xxlt = (struct fwh_xxlock_thunk *)thunk;
  33         int ret;
  34
  35         /* Refuse the operation if the we cannot look behind the chip */
  36         if (chip->start < 0x400000) {
  37                 pr_debug( "MTD %s(): chip->start: %lx wanted >= 0x400000\n",
  38                         __func__, chip->start );
  39                 return -EIO;
  40         }
  41         /*
  42          * lock block registers:
  43          * - on 64k boundariesand
  44          * - bit 1 set high
  45          * - block lock registers are 4MiB lower - overflow subtract (danger)
  46          *
  47          * The address manipulation is first done on the logical address
  48          * which is 0 at the start of the chip, and then the offset of
  49          * the individual chip is addted to it.  Any other order a weird
  50          * map offset could cause problems.
  51          */
  52         adr = (adr & ~0xffffUL) | 0x2;
  53         adr += chip->start - 0x400000;
  54
  55         /*
  56          * This is easy because these are writes to registers and not writes
  57          * to flash memory - that means that we don't have to check status
  58          * and timeout.
  59          */
  60         mutex_lock(&chip->mutex);
  61         ret = get_chip(map, chip, adr, FL_LOCKING);
  62         if (ret) {
  63                 mutex_unlock(&chip->mutex);
  64                 return ret;
  65         }
  66
  67         chip->oldstate = chip->state;
  68         chip->state = xxlt->state;
  69         map_write(map, CMD(xxlt->val), adr);
  70
  71         /* Done and happy. */
  72         chip->state = chip->oldstate;
  73         put_chip(map, chip, adr);
  74         mutex_unlock(&chip->mutex);
  75         return 0;
  76 }
  77
  78
  79 static int fwh_lock_varsize(struct mtd_info *mtd, loff_t ofs, uint64_t len)
  80 {
  81         int ret;
  82
  83         ret = cfi_varsize_frob(mtd, fwh_xxlock_oneblock, ofs, len,
  84                 (void *)&FWH_XXLOCK_ONEBLOCK_LOCK);
  85
  86         return ret;
  87 }
  88
  89
  90 static int fwh_unlock_varsize(struct mtd_info *mtd, loff_t ofs, uint64_t len)
  91 {
  92         int ret;
  93
  94         ret = cfi_varsize_frob(mtd, fwh_xxlock_oneblock, ofs, len,
  95                 (void *)&FWH_XXLOCK_ONEBLOCK_UNLOCK);
  96
  97         return ret;
  98 }
  99
 100 static void fixup_use_fwh_lock(struct mtd_info *mtd)
 101 {
 102         printk(KERN_NOTICE "using fwh lock/unlock method\n");
 103         /* Setup for the chips with the fwh lock method */
 104         mtd->_lock   = fwh_lock_varsize;
 105         mtd->_unlock = fwh_unlock_varsize;
 106 }
 107 #endif /* FWH_LOCK_H */