/drivers/mtd/chips/fwh_lock.h

  1#ifndef FWH_LOCK_H
  2#define FWH_LOCK_H
  3
  4
  5enum fwh_lock_state {
  6        FWH_UNLOCKED   = 0,
  7	FWH_DENY_WRITE = 1,
  8	FWH_IMMUTABLE  = 2,
  9	FWH_DENY_READ  = 4,
 10};
 11
 12struct 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 */
 28static 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		DEBUG( MTD_DEBUG_LEVEL3,
 38			"MTD %s(): chip->start: %lx wanted >= 0x400000\n",
 39			__func__, chip->start );
 40		return -EIO;
 41	}
 42	/*
 43	 * lock block registers:
 44	 * - on 64k boundariesand
 45	 * - bit 1 set high
 46	 * - block lock registers are 4MiB lower - overflow subtract (danger)
 47	 *
 48	 * The address manipulation is first done on the logical address
 49	 * which is 0 at the start of the chip, and then the offset of
 50	 * the individual chip is addted to it.  Any other order a weird
 51	 * map offset could cause problems.
 52	 */
 53	adr = (adr & ~0xffffUL) | 0x2;
 54	adr += chip->start - 0x400000;
 55
 56	/*
 57	 * This is easy because these are writes to registers and not writes
 58	 * to flash memory - that means that we don't have to check status
 59	 * and timeout.
 60	 */
 61	mutex_lock(&chip->mutex);
 62	ret = get_chip(map, chip, adr, FL_LOCKING);
 63	if (ret) {
 64		mutex_unlock(&chip->mutex);
 65		return ret;
 66	}
 67
 68	chip->oldstate = chip->state;
 69	chip->state = xxlt->state;
 70	map_write(map, CMD(xxlt->val), adr);
 71
 72	/* Done and happy. */
 73	chip->state = chip->oldstate;
 74	put_chip(map, chip, adr);
 75	mutex_unlock(&chip->mutex);
 76	return 0;
 77}
 78
 79
 80static int fwh_lock_varsize(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 81{
 82	int ret;
 83
 84	ret = cfi_varsize_frob(mtd, fwh_xxlock_oneblock, ofs, len,
 85		(void *)&FWH_XXLOCK_ONEBLOCK_LOCK);
 86
 87	return ret;
 88}
 89
 90
 91static int fwh_unlock_varsize(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 92{
 93	int ret;
 94
 95	ret = cfi_varsize_frob(mtd, fwh_xxlock_oneblock, ofs, len,
 96		(void *)&FWH_XXLOCK_ONEBLOCK_UNLOCK);
 97
 98	return ret;
 99}
100
101static void fixup_use_fwh_lock(struct mtd_info *mtd)
102{
103	printk(KERN_NOTICE "using fwh lock/unlock method\n");
104	/* Setup for the chips with the fwh lock method */
105	mtd->lock   = fwh_lock_varsize;
106	mtd->unlock = fwh_unlock_varsize;
107}
108#endif /* FWH_LOCK_H */