1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #ifndef FWH_LOCK_H |
3 | #define FWH_LOCK_H |
4 | |
5 | |
6 | enum fwh_lock_state { |
7 | FWH_UNLOCKED = 0, |
8 | FWH_DENY_WRITE = 1, |
9 | FWH_IMMUTABLE = 2, |
10 | FWH_DENY_READ = 4, |
11 | }; |
12 | |
13 | struct fwh_xxlock_thunk { |
14 | enum fwh_lock_state val; |
15 | flstate_t state; |
16 | }; |
17 | |
18 | |
19 | #define FWH_XXLOCK_ONEBLOCK_LOCK ((struct fwh_xxlock_thunk){ FWH_DENY_WRITE, FL_LOCKING}) |
20 | #define FWH_XXLOCK_ONEBLOCK_UNLOCK ((struct fwh_xxlock_thunk){ FWH_UNLOCKED, FL_UNLOCKING}) |
21 | |
22 | /* |
23 | * This locking/unlock is specific to firmware hub parts. Only one |
24 | * is known that supports the Intel command set. Firmware |
25 | * hub parts cannot be interleaved as they are on the LPC bus |
26 | * so this code has not been tested with interleaved chips, |
27 | * and will likely fail in that context. |
28 | */ |
29 | static int fwh_xxlock_oneblock(struct map_info *map, struct flchip *chip, |
30 | unsigned long adr, int len, void *thunk) |
31 | { |
32 | struct cfi_private *cfi = map->fldrv_priv; |
33 | struct fwh_xxlock_thunk *xxlt = (struct fwh_xxlock_thunk *)thunk; |
34 | int ret; |
35 | |
36 | /* Refuse the operation if the we cannot look behind the chip */ |
37 | if (chip->start < 0x400000) { |
38 | pr_debug( "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, mode: FL_LOCKING); |
63 | if (ret) { |
64 | mutex_unlock(lock: &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(lock: &chip->mutex); |
76 | return 0; |
77 | } |
78 | |
79 | |
80 | static 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, frob: fwh_xxlock_oneblock, ofs, len, |
85 | thunk: (void *)&FWH_XXLOCK_ONEBLOCK_LOCK); |
86 | |
87 | return ret; |
88 | } |
89 | |
90 | |
91 | static 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, frob: fwh_xxlock_oneblock, ofs, len, |
96 | thunk: (void *)&FWH_XXLOCK_ONEBLOCK_UNLOCK); |
97 | |
98 | return ret; |
99 | } |
100 | |
101 | static 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 */ |
109 | |