Branch data Line data Source code
1 : : /*
2 : : * Common Flash Interface support:
3 : : * Intel Extended Vendor Command Set (ID 0x0001)
4 : : *
5 : : * (C) 2000 Red Hat. GPL'd
6 : : *
7 : : *
8 : : * 10/10/2000 Nicolas Pitre <nico@fluxnic.net>
9 : : * - completely revamped method functions so they are aware and
10 : : * independent of the flash geometry (buswidth, interleave, etc.)
11 : : * - scalability vs code size is completely set at compile-time
12 : : * (see include/linux/mtd/cfi.h for selection)
13 : : * - optimized write buffer method
14 : : * 02/05/2002 Christopher Hoover <ch@hpl.hp.com>/<ch@murgatroid.com>
15 : : * - reworked lock/unlock/erase support for var size flash
16 : : * 21/03/2007 Rodolfo Giometti <giometti@linux.it>
17 : : * - auto unlock sectors on resume for auto locking flash on power up
18 : : */
19 : :
20 : : #include <linux/module.h>
21 : : #include <linux/types.h>
22 : : #include <linux/kernel.h>
23 : : #include <linux/sched.h>
24 : : #include <linux/init.h>
25 : : #include <asm/io.h>
26 : : #include <asm/byteorder.h>
27 : :
28 : : #include <linux/errno.h>
29 : : #include <linux/slab.h>
30 : : #include <linux/delay.h>
31 : : #include <linux/interrupt.h>
32 : : #include <linux/reboot.h>
33 : : #include <linux/bitmap.h>
34 : : #include <linux/mtd/xip.h>
35 : : #include <linux/mtd/map.h>
36 : : #include <linux/mtd/mtd.h>
37 : : #include <linux/mtd/cfi.h>
38 : :
39 : : /* #define CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE */
40 : : /* #define CMDSET0001_DISABLE_WRITE_SUSPEND */
41 : :
42 : : // debugging, turns off buffer write mode if set to 1
43 : : #define FORCE_WORD_WRITE 0
44 : :
45 : : /* Intel chips */
46 : : #define I82802AB 0x00ad
47 : : #define I82802AC 0x00ac
48 : : #define PF38F4476 0x881c
49 : : /* STMicroelectronics chips */
50 : : #define M50LPW080 0x002F
51 : : #define M50FLW080A 0x0080
52 : : #define M50FLW080B 0x0081
53 : : /* Atmel chips */
54 : : #define AT49BV640D 0x02de
55 : : #define AT49BV640DT 0x02db
56 : :
57 : : static int cfi_intelext_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
58 : : static int cfi_intelext_write_words(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
59 : : static int cfi_intelext_write_buffers(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
60 : : static int cfi_intelext_writev(struct mtd_info *, const struct kvec *, unsigned long, loff_t, size_t *);
61 : : static int cfi_intelext_erase_varsize(struct mtd_info *, struct erase_info *);
62 : : static void cfi_intelext_sync (struct mtd_info *);
63 : : static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
64 : : static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
65 : : static int cfi_intelext_is_locked(struct mtd_info *mtd, loff_t ofs,
66 : : uint64_t len);
67 : : #ifdef CONFIG_MTD_OTP
68 : : static int cfi_intelext_read_fact_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
69 : : static int cfi_intelext_read_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
70 : : static int cfi_intelext_write_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
71 : : static int cfi_intelext_lock_user_prot_reg (struct mtd_info *, loff_t, size_t);
72 : : static int cfi_intelext_get_fact_prot_info (struct mtd_info *,
73 : : struct otp_info *, size_t);
74 : : static int cfi_intelext_get_user_prot_info (struct mtd_info *,
75 : : struct otp_info *, size_t);
76 : : #endif
77 : : static int cfi_intelext_suspend (struct mtd_info *);
78 : : static void cfi_intelext_resume (struct mtd_info *);
79 : : static int cfi_intelext_reboot (struct notifier_block *, unsigned long, void *);
80 : :
81 : : static void cfi_intelext_destroy(struct mtd_info *);
82 : :
83 : : struct mtd_info *cfi_cmdset_0001(struct map_info *, int);
84 : :
85 : : static struct mtd_info *cfi_intelext_setup (struct mtd_info *);
86 : : static int cfi_intelext_partition_fixup(struct mtd_info *, struct cfi_private **);
87 : :
88 : : static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len,
89 : : size_t *retlen, void **virt, resource_size_t *phys);
90 : : static int cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len);
91 : :
92 : : static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
93 : : static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
94 : : static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr);
95 : : #include "fwh_lock.h"
96 : :
97 : :
98 : :
99 : : /*
100 : : * *********** SETUP AND PROBE BITS ***********
101 : : */
102 : :
103 : : static struct mtd_chip_driver cfi_intelext_chipdrv = {
104 : : .probe = NULL, /* Not usable directly */
105 : : .destroy = cfi_intelext_destroy,
106 : : .name = "cfi_cmdset_0001",
107 : : .module = THIS_MODULE
108 : : };
109 : :
110 : : /* #define DEBUG_LOCK_BITS */
111 : : /* #define DEBUG_CFI_FEATURES */
112 : :
113 : : #ifdef DEBUG_CFI_FEATURES
114 : : static void cfi_tell_features(struct cfi_pri_intelext *extp)
115 : : {
116 : : int i;
117 : : printk(" Extended Query version %c.%c\n", extp->MajorVersion, extp->MinorVersion);
118 : : printk(" Feature/Command Support: %4.4X\n", extp->FeatureSupport);
119 : : printk(" - Chip Erase: %s\n", extp->FeatureSupport&1?"supported":"unsupported");
120 : : printk(" - Suspend Erase: %s\n", extp->FeatureSupport&2?"supported":"unsupported");
121 : : printk(" - Suspend Program: %s\n", extp->FeatureSupport&4?"supported":"unsupported");
122 : : printk(" - Legacy Lock/Unlock: %s\n", extp->FeatureSupport&8?"supported":"unsupported");
123 : : printk(" - Queued Erase: %s\n", extp->FeatureSupport&16?"supported":"unsupported");
124 : : printk(" - Instant block lock: %s\n", extp->FeatureSupport&32?"supported":"unsupported");
125 : : printk(" - Protection Bits: %s\n", extp->FeatureSupport&64?"supported":"unsupported");
126 : : printk(" - Page-mode read: %s\n", extp->FeatureSupport&128?"supported":"unsupported");
127 : : printk(" - Synchronous read: %s\n", extp->FeatureSupport&256?"supported":"unsupported");
128 : : printk(" - Simultaneous operations: %s\n", extp->FeatureSupport&512?"supported":"unsupported");
129 : : printk(" - Extended Flash Array: %s\n", extp->FeatureSupport&1024?"supported":"unsupported");
130 : : for (i=11; i<32; i++) {
131 : : if (extp->FeatureSupport & (1<<i))
132 : : printk(" - Unknown Bit %X: supported\n", i);
133 : : }
134 : :
135 : : printk(" Supported functions after Suspend: %2.2X\n", extp->SuspendCmdSupport);
136 : : printk(" - Program after Erase Suspend: %s\n", extp->SuspendCmdSupport&1?"supported":"unsupported");
137 : : for (i=1; i<8; i++) {
138 : : if (extp->SuspendCmdSupport & (1<<i))
139 : : printk(" - Unknown Bit %X: supported\n", i);
140 : : }
141 : :
142 : : printk(" Block Status Register Mask: %4.4X\n", extp->BlkStatusRegMask);
143 : : printk(" - Lock Bit Active: %s\n", extp->BlkStatusRegMask&1?"yes":"no");
144 : : printk(" - Lock-Down Bit Active: %s\n", extp->BlkStatusRegMask&2?"yes":"no");
145 : : for (i=2; i<3; i++) {
146 : : if (extp->BlkStatusRegMask & (1<<i))
147 : : printk(" - Unknown Bit %X Active: yes\n",i);
148 : : }
149 : : printk(" - EFA Lock Bit: %s\n", extp->BlkStatusRegMask&16?"yes":"no");
150 : : printk(" - EFA Lock-Down Bit: %s\n", extp->BlkStatusRegMask&32?"yes":"no");
151 : : for (i=6; i<16; i++) {
152 : : if (extp->BlkStatusRegMask & (1<<i))
153 : : printk(" - Unknown Bit %X Active: yes\n",i);
154 : : }
155 : :
156 : : printk(" Vcc Logic Supply Optimum Program/Erase Voltage: %d.%d V\n",
157 : : extp->VccOptimal >> 4, extp->VccOptimal & 0xf);
158 : : if (extp->VppOptimal)
159 : : printk(" Vpp Programming Supply Optimum Program/Erase Voltage: %d.%d V\n",
160 : : extp->VppOptimal >> 4, extp->VppOptimal & 0xf);
161 : : }
162 : : #endif
163 : :
164 : : /* Atmel chips don't use the same PRI format as Intel chips */
165 : 0 : static void fixup_convert_atmel_pri(struct mtd_info *mtd)
166 : : {
167 : 0 : struct map_info *map = mtd->priv;
168 : 0 : struct cfi_private *cfi = map->fldrv_priv;
169 : 0 : struct cfi_pri_intelext *extp = cfi->cmdset_priv;
170 : : struct cfi_pri_atmel atmel_pri;
171 : : uint32_t features = 0;
172 : :
173 : : /* Reverse byteswapping */
174 : : extp->FeatureSupport = cpu_to_le32(extp->FeatureSupport);
175 : : extp->BlkStatusRegMask = cpu_to_le16(extp->BlkStatusRegMask);
176 : : extp->ProtRegAddr = cpu_to_le16(extp->ProtRegAddr);
177 : :
178 : 0 : memcpy(&atmel_pri, extp, sizeof(atmel_pri));
179 : 0 : memset((char *)extp + 5, 0, sizeof(*extp) - 5);
180 : :
181 : 0 : printk(KERN_ERR "atmel Features: %02x\n", atmel_pri.Features);
182 : :
183 [ # # ]: 0 : if (atmel_pri.Features & 0x01) /* chip erase supported */
184 : : features |= (1<<0);
185 [ # # ]: 0 : if (atmel_pri.Features & 0x02) /* erase suspend supported */
186 : 0 : features |= (1<<1);
187 [ # # ]: 0 : if (atmel_pri.Features & 0x04) /* program suspend supported */
188 : 0 : features |= (1<<2);
189 [ # # ]: 0 : if (atmel_pri.Features & 0x08) /* simultaneous operations supported */
190 : 0 : features |= (1<<9);
191 [ # # ]: 0 : if (atmel_pri.Features & 0x20) /* page mode read supported */
192 : 0 : features |= (1<<7);
193 [ # # ]: 0 : if (atmel_pri.Features & 0x40) /* queued erase supported */
194 : 0 : features |= (1<<4);
195 [ # # ]: 0 : if (atmel_pri.Features & 0x80) /* Protection bits supported */
196 : 0 : features |= (1<<6);
197 : :
198 : 0 : extp->FeatureSupport = features;
199 : :
200 : : /* burst write mode not supported */
201 : 0 : cfi->cfiq->BufWriteTimeoutTyp = 0;
202 : 0 : cfi->cfiq->BufWriteTimeoutMax = 0;
203 : 0 : }
204 : :
205 : 0 : static void fixup_at49bv640dx_lock(struct mtd_info *mtd)
206 : : {
207 : 0 : struct map_info *map = mtd->priv;
208 : 0 : struct cfi_private *cfi = map->fldrv_priv;
209 : 0 : struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
210 : :
211 : 0 : cfip->FeatureSupport |= (1 << 5);
212 : 0 : mtd->flags |= MTD_POWERUP_LOCK;
213 : 0 : }
214 : :
215 : : #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
216 : : /* Some Intel Strata Flash prior to FPO revision C has bugs in this area */
217 : : static void fixup_intel_strataflash(struct mtd_info *mtd)
218 : : {
219 : : struct map_info *map = mtd->priv;
220 : : struct cfi_private *cfi = map->fldrv_priv;
221 : : struct cfi_pri_intelext *extp = cfi->cmdset_priv;
222 : :
223 : : printk(KERN_WARNING "cfi_cmdset_0001: Suspend "
224 : : "erase on write disabled.\n");
225 : : extp->SuspendCmdSupport &= ~1;
226 : : }
227 : : #endif
228 : :
229 : : #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
230 : : static void fixup_no_write_suspend(struct mtd_info *mtd)
231 : : {
232 : : struct map_info *map = mtd->priv;
233 : : struct cfi_private *cfi = map->fldrv_priv;
234 : : struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
235 : :
236 : : if (cfip && (cfip->FeatureSupport&4)) {
237 : : cfip->FeatureSupport &= ~4;
238 : : printk(KERN_WARNING "cfi_cmdset_0001: write suspend disabled\n");
239 : : }
240 : : }
241 : : #endif
242 : :
243 : 0 : static void fixup_st_m28w320ct(struct mtd_info *mtd)
244 : : {
245 : 0 : struct map_info *map = mtd->priv;
246 : 0 : struct cfi_private *cfi = map->fldrv_priv;
247 : :
248 : 0 : cfi->cfiq->BufWriteTimeoutTyp = 0; /* Not supported */
249 : 0 : cfi->cfiq->BufWriteTimeoutMax = 0; /* Not supported */
250 : 0 : }
251 : :
252 : 0 : static void fixup_st_m28w320cb(struct mtd_info *mtd)
253 : : {
254 : 0 : struct map_info *map = mtd->priv;
255 : 0 : struct cfi_private *cfi = map->fldrv_priv;
256 : :
257 : : /* Note this is done after the region info is endian swapped */
258 : 0 : cfi->cfiq->EraseRegionInfo[1] =
259 : 0 : (cfi->cfiq->EraseRegionInfo[1] & 0xffff0000) | 0x3e;
260 : 0 : };
261 : :
262 : 0 : static void fixup_use_point(struct mtd_info *mtd)
263 : : {
264 : : struct map_info *map = mtd->priv;
265 [ # # ]: 0 : if (!mtd->_point && map_is_linear(map)) {
266 : 0 : mtd->_point = cfi_intelext_point;
267 : 0 : mtd->_unpoint = cfi_intelext_unpoint;
268 : : }
269 : 0 : }
270 : :
271 : 0 : static void fixup_use_write_buffers(struct mtd_info *mtd)
272 : : {
273 : 0 : struct map_info *map = mtd->priv;
274 : 0 : struct cfi_private *cfi = map->fldrv_priv;
275 [ # # ]: 0 : if (cfi->cfiq->BufWriteTimeoutTyp) {
276 : 0 : printk(KERN_INFO "Using buffer write method\n" );
277 : 0 : mtd->_write = cfi_intelext_write_buffers;
278 : 0 : mtd->_writev = cfi_intelext_writev;
279 : : }
280 : 0 : }
281 : :
282 : : /*
283 : : * Some chips power-up with all sectors locked by default.
284 : : */
285 : 0 : static void fixup_unlock_powerup_lock(struct mtd_info *mtd)
286 : : {
287 : 0 : struct map_info *map = mtd->priv;
288 : 0 : struct cfi_private *cfi = map->fldrv_priv;
289 : 0 : struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
290 : :
291 [ # # ]: 0 : if (cfip->FeatureSupport&32) {
292 : 0 : printk(KERN_INFO "Using auto-unlock on power-up/resume\n" );
293 : 0 : mtd->flags |= MTD_POWERUP_LOCK;
294 : : }
295 : 0 : }
296 : :
297 : : static struct cfi_fixup cfi_fixup_table[] = {
298 : : { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri },
299 : : { CFI_MFR_ATMEL, AT49BV640D, fixup_at49bv640dx_lock },
300 : : { CFI_MFR_ATMEL, AT49BV640DT, fixup_at49bv640dx_lock },
301 : : #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
302 : : { CFI_MFR_ANY, CFI_ID_ANY, fixup_intel_strataflash },
303 : : #endif
304 : : #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
305 : : { CFI_MFR_ANY, CFI_ID_ANY, fixup_no_write_suspend },
306 : : #endif
307 : : #if !FORCE_WORD_WRITE
308 : : { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers },
309 : : #endif
310 : : { CFI_MFR_ST, 0x00ba, /* M28W320CT */ fixup_st_m28w320ct },
311 : : { CFI_MFR_ST, 0x00bb, /* M28W320CB */ fixup_st_m28w320cb },
312 : : { CFI_MFR_INTEL, CFI_ID_ANY, fixup_unlock_powerup_lock },
313 : : { 0, 0, NULL }
314 : : };
315 : :
316 : : static struct cfi_fixup jedec_fixup_table[] = {
317 : : { CFI_MFR_INTEL, I82802AB, fixup_use_fwh_lock },
318 : : { CFI_MFR_INTEL, I82802AC, fixup_use_fwh_lock },
319 : : { CFI_MFR_ST, M50LPW080, fixup_use_fwh_lock },
320 : : { CFI_MFR_ST, M50FLW080A, fixup_use_fwh_lock },
321 : : { CFI_MFR_ST, M50FLW080B, fixup_use_fwh_lock },
322 : : { 0, 0, NULL }
323 : : };
324 : : static struct cfi_fixup fixup_table[] = {
325 : : /* The CFI vendor ids and the JEDEC vendor IDs appear
326 : : * to be common. It is like the devices id's are as
327 : : * well. This table is to pick all cases where
328 : : * we know that is the case.
329 : : */
330 : : { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_point },
331 : : { 0, 0, NULL }
332 : : };
333 : :
334 : 0 : static void cfi_fixup_major_minor(struct cfi_private *cfi,
335 : : struct cfi_pri_intelext *extp)
336 : : {
337 [ # # ][ # # ]: 0 : if (cfi->mfr == CFI_MFR_INTEL &&
338 [ # # ]: 0 : cfi->id == PF38F4476 && extp->MinorVersion == '3')
339 : 0 : extp->MinorVersion = '1';
340 : 0 : }
341 : :
342 : : static inline struct cfi_pri_intelext *
343 : : read_pri_intelext(struct map_info *map, __u16 adr)
344 : : {
345 : 0 : struct cfi_private *cfi = map->fldrv_priv;
346 : : struct cfi_pri_intelext *extp;
347 : : unsigned int extra_size = 0;
348 : : unsigned int extp_size = sizeof(*extp);
349 : :
350 : : again:
351 : 0 : extp = (struct cfi_pri_intelext *)cfi_read_pri(map, adr, extp_size, "Intel/Sharp");
352 [ # # ]: 0 : if (!extp)
353 : : return NULL;
354 : :
355 : 0 : cfi_fixup_major_minor(cfi, extp);
356 : :
357 [ # # ][ # # ]: 0 : if (extp->MajorVersion != '1' ||
358 : 0 : (extp->MinorVersion < '0' || extp->MinorVersion > '5')) {
359 : 0 : printk(KERN_ERR " Unknown Intel/Sharp Extended Query "
360 : : "version %c.%c.\n", extp->MajorVersion,
361 : 0 : extp->MinorVersion);
362 : 0 : kfree(extp);
363 : : return NULL;
364 : : }
365 : :
366 : : /* Do some byteswapping if necessary */
367 : : extp->FeatureSupport = le32_to_cpu(extp->FeatureSupport);
368 : : extp->BlkStatusRegMask = le16_to_cpu(extp->BlkStatusRegMask);
369 : : extp->ProtRegAddr = le16_to_cpu(extp->ProtRegAddr);
370 : :
371 [ # # ]: 0 : if (extp->MinorVersion >= '0') {
372 : : extra_size = 0;
373 : :
374 : : /* Protection Register info */
375 : 0 : extra_size += (extp->NumProtectionFields - 1) *
376 : : sizeof(struct cfi_intelext_otpinfo);
377 : : }
378 : :
379 [ # # ]: 0 : if (extp->MinorVersion >= '1') {
380 : : /* Burst Read info */
381 : 0 : extra_size += 2;
382 [ # # ]: 0 : if (extp_size < sizeof(*extp) + extra_size)
383 : : goto need_more;
384 : 0 : extra_size += extp->extra[extra_size - 1];
385 : : }
386 : :
387 [ # # ]: 0 : if (extp->MinorVersion >= '3') {
388 : : int nb_parts, i;
389 : :
390 : : /* Number of hardware-partitions */
391 : 0 : extra_size += 1;
392 [ # # ]: 0 : if (extp_size < sizeof(*extp) + extra_size)
393 : : goto need_more;
394 : 0 : nb_parts = extp->extra[extra_size - 1];
395 : :
396 : : /* skip the sizeof(partregion) field in CFI 1.4 */
397 [ # # ]: 0 : if (extp->MinorVersion >= '4')
398 : 0 : extra_size += 2;
399 : :
400 [ # # ]: 0 : for (i = 0; i < nb_parts; i++) {
401 : : struct cfi_intelext_regioninfo *rinfo;
402 : 0 : rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[extra_size];
403 : 0 : extra_size += sizeof(*rinfo);
404 [ # # ]: 0 : if (extp_size < sizeof(*extp) + extra_size)
405 : : goto need_more;
406 : : rinfo->NumIdentPartitions=le16_to_cpu(rinfo->NumIdentPartitions);
407 : 0 : extra_size += (rinfo->NumBlockTypes - 1)
408 : 0 : * sizeof(struct cfi_intelext_blockinfo);
409 : : }
410 : :
411 [ # # ]: 0 : if (extp->MinorVersion >= '4')
412 : 0 : extra_size += sizeof(struct cfi_intelext_programming_regioninfo);
413 : :
414 [ # # ]: 0 : if (extp_size < sizeof(*extp) + extra_size) {
415 : : need_more:
416 : 0 : extp_size = sizeof(*extp) + extra_size;
417 : 0 : kfree(extp);
418 [ # # ]: 0 : if (extp_size > 4096) {
419 : 0 : printk(KERN_ERR
420 : : "%s: cfi_pri_intelext is too fat\n",
421 : : __func__);
422 : : return NULL;
423 : : }
424 : : goto again;
425 : : }
426 : : }
427 : :
428 : : return extp;
429 : : }
430 : :
431 : 0 : struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
432 : : {
433 : 0 : struct cfi_private *cfi = map->fldrv_priv;
434 : : struct mtd_info *mtd;
435 : : int i;
436 : :
437 : : mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
438 [ # # ]: 0 : if (!mtd) {
439 : 0 : printk(KERN_ERR "Failed to allocate memory for MTD device\n");
440 : 0 : return NULL;
441 : : }
442 : 0 : mtd->priv = map;
443 : 0 : mtd->type = MTD_NORFLASH;
444 : :
445 : : /* Fill in the default mtd operations */
446 : 0 : mtd->_erase = cfi_intelext_erase_varsize;
447 : 0 : mtd->_read = cfi_intelext_read;
448 : 0 : mtd->_write = cfi_intelext_write_words;
449 : 0 : mtd->_sync = cfi_intelext_sync;
450 : 0 : mtd->_lock = cfi_intelext_lock;
451 : 0 : mtd->_unlock = cfi_intelext_unlock;
452 : 0 : mtd->_is_locked = cfi_intelext_is_locked;
453 : 0 : mtd->_suspend = cfi_intelext_suspend;
454 : 0 : mtd->_resume = cfi_intelext_resume;
455 : 0 : mtd->flags = MTD_CAP_NORFLASH;
456 : 0 : mtd->name = map->name;
457 : 0 : mtd->writesize = 1;
458 : 0 : mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
459 : :
460 : 0 : mtd->reboot_notifier.notifier_call = cfi_intelext_reboot;
461 : :
462 [ # # ]: 0 : if (cfi->cfi_mode == CFI_MODE_CFI) {
463 : : /*
464 : : * It's a real CFI chip, not one for which the probe
465 : : * routine faked a CFI structure. So we read the feature
466 : : * table from it.
467 : : */
468 [ # # ]: 0 : __u16 adr = primary?cfi->cfiq->P_ADR:cfi->cfiq->A_ADR;
469 : : struct cfi_pri_intelext *extp;
470 : :
471 : : extp = read_pri_intelext(map, adr);
472 [ # # ]: 0 : if (!extp) {
473 : 0 : kfree(mtd);
474 : 0 : return NULL;
475 : : }
476 : :
477 : : /* Install our own private info structure */
478 : 0 : cfi->cmdset_priv = extp;
479 : :
480 : 0 : cfi_fixup(mtd, cfi_fixup_table);
481 : :
482 : : #ifdef DEBUG_CFI_FEATURES
483 : : /* Tell the user about it in lots of lovely detail */
484 : : cfi_tell_features(extp);
485 : : #endif
486 : :
487 [ # # ]: 0 : if(extp->SuspendCmdSupport & 1) {
488 : 0 : printk(KERN_NOTICE "cfi_cmdset_0001: Erase suspend on write enabled\n");
489 : : }
490 : : }
491 [ # # ]: 0 : else if (cfi->cfi_mode == CFI_MODE_JEDEC) {
492 : : /* Apply jedec specific fixups */
493 : 0 : cfi_fixup(mtd, jedec_fixup_table);
494 : : }
495 : : /* Apply generic fixups */
496 : 0 : cfi_fixup(mtd, fixup_table);
497 : :
498 [ # # ]: 0 : for (i=0; i< cfi->numchips; i++) {
499 [ # # ]: 0 : if (cfi->cfiq->WordWriteTimeoutTyp)
500 : 0 : cfi->chips[i].word_write_time =
501 : 0 : 1<<cfi->cfiq->WordWriteTimeoutTyp;
502 : : else
503 : 0 : cfi->chips[i].word_write_time = 50000;
504 : :
505 [ # # ]: 0 : if (cfi->cfiq->BufWriteTimeoutTyp)
506 : 0 : cfi->chips[i].buffer_write_time =
507 : 0 : 1<<cfi->cfiq->BufWriteTimeoutTyp;
508 : : /* No default; if it isn't specified, we won't use it */
509 : :
510 [ # # ]: 0 : if (cfi->cfiq->BlockEraseTimeoutTyp)
511 : 0 : cfi->chips[i].erase_time =
512 : 0 : 1000<<cfi->cfiq->BlockEraseTimeoutTyp;
513 : : else
514 : 0 : cfi->chips[i].erase_time = 2000000;
515 : :
516 [ # # ][ # # ]: 0 : if (cfi->cfiq->WordWriteTimeoutTyp &&
517 : 0 : cfi->cfiq->WordWriteTimeoutMax)
518 : 0 : cfi->chips[i].word_write_time_max =
519 : 0 : 1<<(cfi->cfiq->WordWriteTimeoutTyp +
520 : : cfi->cfiq->WordWriteTimeoutMax);
521 : : else
522 : 0 : cfi->chips[i].word_write_time_max = 50000 * 8;
523 : :
524 [ # # ][ # # ]: 0 : if (cfi->cfiq->BufWriteTimeoutTyp &&
525 : 0 : cfi->cfiq->BufWriteTimeoutMax)
526 : 0 : cfi->chips[i].buffer_write_time_max =
527 : 0 : 1<<(cfi->cfiq->BufWriteTimeoutTyp +
528 : : cfi->cfiq->BufWriteTimeoutMax);
529 : :
530 [ # # ][ # # ]: 0 : if (cfi->cfiq->BlockEraseTimeoutTyp &&
531 : 0 : cfi->cfiq->BlockEraseTimeoutMax)
532 : 0 : cfi->chips[i].erase_time_max =
533 : 0 : 1000<<(cfi->cfiq->BlockEraseTimeoutTyp +
534 : : cfi->cfiq->BlockEraseTimeoutMax);
535 : : else
536 : 0 : cfi->chips[i].erase_time_max = 2000000 * 8;
537 : :
538 : 0 : cfi->chips[i].ref_point_counter = 0;
539 : 0 : init_waitqueue_head(&(cfi->chips[i].wq));
540 : : }
541 : :
542 : 0 : map->fldrv = &cfi_intelext_chipdrv;
543 : :
544 : 0 : return cfi_intelext_setup(mtd);
545 : : }
546 : : struct mtd_info *cfi_cmdset_0003(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
547 : : struct mtd_info *cfi_cmdset_0200(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
548 : : EXPORT_SYMBOL_GPL(cfi_cmdset_0001);
549 : : EXPORT_SYMBOL_GPL(cfi_cmdset_0003);
550 : : EXPORT_SYMBOL_GPL(cfi_cmdset_0200);
551 : :
552 : 0 : static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd)
553 : : {
554 : 0 : struct map_info *map = mtd->priv;
555 : 0 : struct cfi_private *cfi = map->fldrv_priv;
556 : : unsigned long offset = 0;
557 : : int i,j;
558 : 0 : unsigned long devsize = (1<<cfi->cfiq->DevSize) * cfi->interleave;
559 : :
560 : : //printk(KERN_DEBUG "number of CFI chips: %d\n", cfi->numchips);
561 : :
562 : 0 : mtd->size = devsize * cfi->numchips;
563 : :
564 : 0 : mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
565 : 0 : mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info)
566 : : * mtd->numeraseregions, GFP_KERNEL);
567 [ # # ]: 0 : if (!mtd->eraseregions) {
568 : 0 : printk(KERN_ERR "Failed to allocate memory for MTD erase region info\n");
569 : 0 : goto setup_err;
570 : : }
571 : :
572 [ # # ]: 0 : for (i=0; i<cfi->cfiq->NumEraseRegions; i++) {
573 : : unsigned long ernum, ersize;
574 : 0 : ersize = ((cfi->cfiq->EraseRegionInfo[i] >> 8) & ~0xff) * cfi->interleave;
575 : 0 : ernum = (cfi->cfiq->EraseRegionInfo[i] & 0xffff) + 1;
576 : :
577 [ # # ]: 0 : if (mtd->erasesize < ersize) {
578 : 0 : mtd->erasesize = ersize;
579 : : }
580 [ # # ]: 0 : for (j=0; j<cfi->numchips; j++) {
581 : 0 : mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].offset = (j*devsize)+offset;
582 : 0 : mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].erasesize = ersize;
583 : 0 : mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].numblocks = ernum;
584 : 0 : mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].lockmap = kmalloc(ernum / 8 + 1, GFP_KERNEL);
585 : : }
586 : 0 : offset += (ersize * ernum);
587 : : }
588 : :
589 [ # # ]: 0 : if (offset != devsize) {
590 : : /* Argh */
591 : 0 : printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset, devsize);
592 : 0 : goto setup_err;
593 : : }
594 : :
595 [ # # ]: 0 : for (i=0; i<mtd->numeraseregions;i++){
596 : 0 : printk(KERN_DEBUG "erase region %d: offset=0x%llx,size=0x%x,blocks=%d\n",
597 : 0 : i,(unsigned long long)mtd->eraseregions[i].offset,
598 : : mtd->eraseregions[i].erasesize,
599 : : mtd->eraseregions[i].numblocks);
600 : : }
601 : :
602 : : #ifdef CONFIG_MTD_OTP
603 : : mtd->_read_fact_prot_reg = cfi_intelext_read_fact_prot_reg;
604 : : mtd->_read_user_prot_reg = cfi_intelext_read_user_prot_reg;
605 : : mtd->_write_user_prot_reg = cfi_intelext_write_user_prot_reg;
606 : : mtd->_lock_user_prot_reg = cfi_intelext_lock_user_prot_reg;
607 : : mtd->_get_fact_prot_info = cfi_intelext_get_fact_prot_info;
608 : : mtd->_get_user_prot_info = cfi_intelext_get_user_prot_info;
609 : : #endif
610 : :
611 : : /* This function has the potential to distort the reality
612 : : a bit and therefore should be called last. */
613 [ # # ]: 0 : if (cfi_intelext_partition_fixup(mtd, &cfi) != 0)
614 : : goto setup_err;
615 : :
616 : 0 : __module_get(THIS_MODULE);
617 : 0 : register_reboot_notifier(&mtd->reboot_notifier);
618 : 0 : return mtd;
619 : :
620 : : setup_err:
621 : 0 : kfree(mtd->eraseregions);
622 : 0 : kfree(mtd);
623 : 0 : kfree(cfi->cmdset_priv);
624 : 0 : return NULL;
625 : : }
626 : :
627 : 0 : static int cfi_intelext_partition_fixup(struct mtd_info *mtd,
628 : : struct cfi_private **pcfi)
629 : : {
630 : 0 : struct map_info *map = mtd->priv;
631 : 0 : struct cfi_private *cfi = *pcfi;
632 : 0 : struct cfi_pri_intelext *extp = cfi->cmdset_priv;
633 : :
634 : : /*
635 : : * Probing of multi-partition flash chips.
636 : : *
637 : : * To support multiple partitions when available, we simply arrange
638 : : * for each of them to have their own flchip structure even if they
639 : : * are on the same physical chip. This means completely recreating
640 : : * a new cfi_private structure right here which is a blatent code
641 : : * layering violation, but this is still the least intrusive
642 : : * arrangement at this point. This can be rearranged in the future
643 : : * if someone feels motivated enough. --nico
644 : : */
645 [ # # ][ # # ]: 0 : if (extp && extp->MajorVersion == '1' && extp->MinorVersion >= '3'
[ # # ]
646 [ # # ]: 0 : && extp->FeatureSupport & (1 << 9)) {
647 : : struct cfi_private *newcfi;
648 : : struct flchip *chip;
649 : : struct flchip_shared *shared;
650 : : int offs, numregions, numparts, partshift, numvirtchips, i, j;
651 : :
652 : : /* Protection Register info */
653 : 0 : offs = (extp->NumProtectionFields - 1) *
654 : : sizeof(struct cfi_intelext_otpinfo);
655 : :
656 : : /* Burst Read info */
657 : 0 : offs += extp->extra[offs+1]+2;
658 : :
659 : : /* Number of partition regions */
660 : 0 : numregions = extp->extra[offs];
661 : 0 : offs += 1;
662 : :
663 : : /* skip the sizeof(partregion) field in CFI 1.4 */
664 [ # # ]: 0 : if (extp->MinorVersion >= '4')
665 : 0 : offs += 2;
666 : :
667 : : /* Number of hardware partitions */
668 : : numparts = 0;
669 [ # # ]: 0 : for (i = 0; i < numregions; i++) {
670 : : struct cfi_intelext_regioninfo *rinfo;
671 : 0 : rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[offs];
672 : 0 : numparts += rinfo->NumIdentPartitions;
673 : 0 : offs += sizeof(*rinfo)
674 : 0 : + (rinfo->NumBlockTypes - 1) *
675 : : sizeof(struct cfi_intelext_blockinfo);
676 : : }
677 : :
678 [ # # ]: 0 : if (!numparts)
679 : : numparts = 1;
680 : :
681 : : /* Programming Region info */
682 [ # # ]: 0 : if (extp->MinorVersion >= '4') {
683 : : struct cfi_intelext_programming_regioninfo *prinfo;
684 : 0 : prinfo = (struct cfi_intelext_programming_regioninfo *)&extp->extra[offs];
685 : 0 : mtd->writesize = cfi->interleave << prinfo->ProgRegShift;
686 : 0 : mtd->flags &= ~MTD_BIT_WRITEABLE;
687 : 0 : printk(KERN_DEBUG "%s: program region size/ctrl_valid/ctrl_inval = %d/%d/%d\n",
688 : : map->name, mtd->writesize,
689 : 0 : cfi->interleave * prinfo->ControlValid,
690 : 0 : cfi->interleave * prinfo->ControlInvalid);
691 : : }
692 : :
693 : : /*
694 : : * All functions below currently rely on all chips having
695 : : * the same geometry so we'll just assume that all hardware
696 : : * partitions are of the same size too.
697 : : */
698 : 0 : partshift = cfi->chipshift - __ffs(numparts);
699 : :
700 [ # # ]: 0 : if ((1 << partshift) < mtd->erasesize) {
701 : 0 : printk( KERN_ERR
702 : : "%s: bad number of hw partitions (%d)\n",
703 : : __func__, numparts);
704 : 0 : return -EINVAL;
705 : : }
706 : :
707 : 0 : numvirtchips = cfi->numchips * numparts;
708 : 0 : newcfi = kmalloc(sizeof(struct cfi_private) + numvirtchips * sizeof(struct flchip), GFP_KERNEL);
709 [ # # ]: 0 : if (!newcfi)
710 : : return -ENOMEM;
711 : 0 : shared = kmalloc(sizeof(struct flchip_shared) * cfi->numchips, GFP_KERNEL);
712 [ # # ]: 0 : if (!shared) {
713 : 0 : kfree(newcfi);
714 : 0 : return -ENOMEM;
715 : : }
716 : 0 : memcpy(newcfi, cfi, sizeof(struct cfi_private));
717 : 0 : newcfi->numchips = numvirtchips;
718 : 0 : newcfi->chipshift = partshift;
719 : :
720 : 0 : chip = &newcfi->chips[0];
721 [ # # ]: 0 : for (i = 0; i < cfi->numchips; i++) {
722 : 0 : shared[i].writing = shared[i].erasing = NULL;
723 : 0 : mutex_init(&shared[i].lock);
724 [ # # ]: 0 : for (j = 0; j < numparts; j++) {
725 : 0 : *chip = cfi->chips[i];
726 : 0 : chip->start += j << partshift;
727 : 0 : chip->priv = &shared[i];
728 : : /* those should be reset too since
729 : : they create memory references. */
730 : 0 : init_waitqueue_head(&chip->wq);
731 : 0 : mutex_init(&chip->mutex);
732 : 0 : chip++;
733 : : }
734 : : }
735 : :
736 : 0 : printk(KERN_DEBUG "%s: %d set(s) of %d interleaved chips "
737 : : "--> %d partitions of %d KiB\n",
738 : : map->name, cfi->numchips, cfi->interleave,
739 : 0 : newcfi->numchips, 1<<(newcfi->chipshift-10));
740 : :
741 : 0 : map->fldrv_priv = newcfi;
742 : 0 : *pcfi = newcfi;
743 : 0 : kfree(cfi);
744 : : }
745 : :
746 : : return 0;
747 : : }
748 : :
749 : : /*
750 : : * *********** CHIP ACCESS FUNCTIONS ***********
751 : : */
752 : 0 : static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
753 : : {
754 : 0 : DECLARE_WAITQUEUE(wait, current);
755 : 0 : struct cfi_private *cfi = map->fldrv_priv;
756 : : map_word status, status_OK = CMD(0x80), status_PWS = CMD(0x01);
757 : 0 : struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
758 : 0 : unsigned long timeo = jiffies + HZ;
759 : :
760 : : /* Prevent setting state FL_SYNCING for chip in suspended state. */
761 [ # # ][ # # ]: 0 : if (mode == FL_SYNCING && chip->oldstate != FL_READY)
762 : : goto sleep;
763 : :
764 [ # # # # : 0 : switch (chip->state) {
# # # ]
765 : :
766 : : case FL_STATUS:
767 : : for (;;) {
768 : : status = map_read(map, adr);
769 [ # # ]: 0 : if (map_word_andequal(map, status, status_OK, status_OK))
770 : : break;
771 : :
772 : : /* At this point we're fine with write operations
773 : : in other partitions as they don't conflict. */
774 [ # # ][ # # ]: 0 : if (chip->priv && map_word_andequal(map, status, status_PWS, status_PWS))
775 : : break;
776 : :
777 : 0 : mutex_unlock(&chip->mutex);
778 : : cfi_udelay(1);
779 : 0 : mutex_lock(&chip->mutex);
780 : : /* Someone else might have been playing with it. */
781 : 0 : return -EAGAIN;
782 : : }
783 : : /* Fall through */
784 : : case FL_READY:
785 : : case FL_CFI_QUERY:
786 : : case FL_JEDEC_QUERY:
787 : : return 0;
788 : :
789 : : case FL_ERASING:
790 [ # # ][ # # ]: 0 : if (!cfip ||
791 [ # # ]: 0 : !(cfip->FeatureSupport & 2) ||
792 [ # # ]: 0 : !(mode == FL_READY || mode == FL_POINT ||
793 [ # # ]: 0 : (mode == FL_WRITING && (cfip->SuspendCmdSupport & 1))))
794 : : goto sleep;
795 : :
796 : :
797 : : /* Erase suspend */
798 : : map_write(map, CMD(0xB0), adr);
799 : :
800 : : /* If the flash has finished erasing, then 'erase suspend'
801 : : * appears to make some (28F320) flash devices switch to
802 : : * 'read' mode. Make sure that we switch to 'read status'
803 : : * mode so we get the right data. --rmk
804 : : */
805 : : map_write(map, CMD(0x70), adr);
806 : 0 : chip->oldstate = FL_ERASING;
807 : 0 : chip->state = FL_ERASE_SUSPENDING;
808 : 0 : chip->erase_suspended = 1;
809 : : for (;;) {
810 : : status = map_read(map, adr);
811 [ # # ]: 0 : if (map_word_andequal(map, status, status_OK, status_OK))
812 : : break;
813 : :
814 [ # # ]: 0 : if (time_after(jiffies, timeo)) {
815 : : /* Urgh. Resume and pretend we weren't here.
816 : : * Make sure we're in 'read status' mode if it had finished */
817 : 0 : put_chip(map, chip, adr);
818 : 0 : printk(KERN_ERR "%s: Chip not ready after erase "
819 : : "suspended: status = 0x%lx\n", map->name, status.x[0]);
820 : 0 : return -EIO;
821 : : }
822 : :
823 : 0 : mutex_unlock(&chip->mutex);
824 : : cfi_udelay(1);
825 : 0 : mutex_lock(&chip->mutex);
826 : : /* Nobody will touch it while it's in state FL_ERASE_SUSPENDING.
827 : : So we can just loop here. */
828 : 0 : }
829 : 0 : chip->state = FL_STATUS;
830 : 0 : return 0;
831 : :
832 : : case FL_XIP_WHILE_ERASING:
833 [ # # ][ # # ]: 0 : if (mode != FL_READY && mode != FL_POINT &&
834 [ # # ]: 0 : (mode != FL_WRITING || !cfip || !(cfip->SuspendCmdSupport&1)))
835 : : goto sleep;
836 : 0 : chip->oldstate = chip->state;
837 : 0 : chip->state = FL_READY;
838 : 0 : return 0;
839 : :
840 : : case FL_SHUTDOWN:
841 : : /* The machine is rebooting now,so no one can get chip anymore */
842 : : return -EIO;
843 : : case FL_POINT:
844 : : /* Only if there's no operation suspended... */
845 [ # # ][ # # ]: 0 : if (mode == FL_READY && chip->oldstate == FL_READY)
846 : : return 0;
847 : : /* Fall through */
848 : : default:
849 : : sleep:
850 : 0 : set_current_state(TASK_UNINTERRUPTIBLE);
851 : 0 : add_wait_queue(&chip->wq, &wait);
852 : 0 : mutex_unlock(&chip->mutex);
853 : 0 : schedule();
854 : 0 : remove_wait_queue(&chip->wq, &wait);
855 : 0 : mutex_lock(&chip->mutex);
856 : 0 : return -EAGAIN;
857 : : }
858 : : }
859 : :
860 : 0 : static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
861 : : {
862 : : int ret;
863 : 0 : DECLARE_WAITQUEUE(wait, current);
864 : :
865 : : retry:
866 [ # # ][ # # ]: 0 : if (chip->priv &&
867 : 0 : (mode == FL_WRITING || mode == FL_ERASING || mode == FL_OTP_WRITE
868 [ # # ][ # # ]: 0 : || mode == FL_SHUTDOWN) && chip->state != FL_SYNCING) {
869 : : /*
870 : : * OK. We have possibility for contention on the write/erase
871 : : * operations which are global to the real chip and not per
872 : : * partition. So let's fight it over in the partition which
873 : : * currently has authority on the operation.
874 : : *
875 : : * The rules are as follows:
876 : : *
877 : : * - any write operation must own shared->writing.
878 : : *
879 : : * - any erase operation must own _both_ shared->writing and
880 : : * shared->erasing.
881 : : *
882 : : * - contention arbitration is handled in the owner's context.
883 : : *
884 : : * The 'shared' struct can be read and/or written only when
885 : : * its lock is taken.
886 : : */
887 : : struct flchip_shared *shared = chip->priv;
888 : : struct flchip *contender;
889 : 0 : mutex_lock(&shared->lock);
890 : 0 : contender = shared->writing;
891 [ # # ]: 0 : if (contender && contender != chip) {
892 : : /*
893 : : * The engine to perform desired operation on this
894 : : * partition is already in use by someone else.
895 : : * Let's fight over it in the context of the chip
896 : : * currently using it. If it is possible to suspend,
897 : : * that other partition will do just that, otherwise
898 : : * it'll happily send us to sleep. In any case, when
899 : : * get_chip returns success we're clear to go ahead.
900 : : */
901 : 0 : ret = mutex_trylock(&contender->mutex);
902 : 0 : mutex_unlock(&shared->lock);
903 [ # # ]: 0 : if (!ret)
904 : : goto retry;
905 : 0 : mutex_unlock(&chip->mutex);
906 : 0 : ret = chip_ready(map, contender, contender->start, mode);
907 : 0 : mutex_lock(&chip->mutex);
908 : :
909 [ # # ]: 0 : if (ret == -EAGAIN) {
910 : 0 : mutex_unlock(&contender->mutex);
911 : 0 : goto retry;
912 : : }
913 [ # # ]: 0 : if (ret) {
914 : 0 : mutex_unlock(&contender->mutex);
915 : 0 : return ret;
916 : : }
917 : 0 : mutex_lock(&shared->lock);
918 : :
919 : : /* We should not own chip if it is already
920 : : * in FL_SYNCING state. Put contender and retry. */
921 [ # # ]: 0 : if (chip->state == FL_SYNCING) {
922 : 0 : put_chip(map, contender, contender->start);
923 : 0 : mutex_unlock(&contender->mutex);
924 : 0 : goto retry;
925 : : }
926 : 0 : mutex_unlock(&contender->mutex);
927 : : }
928 : :
929 : : /* Check if we already have suspended erase
930 : : * on this chip. Sleep. */
931 [ # # ][ # # ]: 0 : if (mode == FL_ERASING && shared->erasing
932 [ # # ]: 0 : && shared->erasing->oldstate == FL_ERASING) {
933 : 0 : mutex_unlock(&shared->lock);
934 : 0 : set_current_state(TASK_UNINTERRUPTIBLE);
935 : 0 : add_wait_queue(&chip->wq, &wait);
936 : 0 : mutex_unlock(&chip->mutex);
937 : 0 : schedule();
938 : 0 : remove_wait_queue(&chip->wq, &wait);
939 : 0 : mutex_lock(&chip->mutex);
940 : 0 : goto retry;
941 : : }
942 : :
943 : : /* We now own it */
944 : 0 : shared->writing = chip;
945 [ # # ]: 0 : if (mode == FL_ERASING)
946 : 0 : shared->erasing = chip;
947 : 0 : mutex_unlock(&shared->lock);
948 : : }
949 : 0 : ret = chip_ready(map, chip, adr, mode);
950 [ # # ]: 0 : if (ret == -EAGAIN)
951 : : goto retry;
952 : :
953 : : return ret;
954 : : }
955 : :
956 : 0 : static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr)
957 : : {
958 : 0 : struct cfi_private *cfi = map->fldrv_priv;
959 : :
960 [ # # ]: 0 : if (chip->priv) {
961 : : struct flchip_shared *shared = chip->priv;
962 : 0 : mutex_lock(&shared->lock);
963 [ # # ][ # # ]: 0 : if (shared->writing == chip && chip->oldstate == FL_READY) {
964 : : /* We own the ability to write, but we're done */
965 : 0 : shared->writing = shared->erasing;
966 [ # # ][ # # ]: 0 : if (shared->writing && shared->writing != chip) {
967 : : /* give back ownership to who we loaned it from */
968 : : struct flchip *loaner = shared->writing;
969 : 0 : mutex_lock(&loaner->mutex);
970 : 0 : mutex_unlock(&shared->lock);
971 : 0 : mutex_unlock(&chip->mutex);
972 : 0 : put_chip(map, loaner, loaner->start);
973 : 0 : mutex_lock(&chip->mutex);
974 : 0 : mutex_unlock(&loaner->mutex);
975 : 0 : wake_up(&chip->wq);
976 : 0 : return;
977 : : }
978 : 0 : shared->erasing = NULL;
979 : 0 : shared->writing = NULL;
980 [ # # ][ # # ]: 0 : } else if (shared->erasing == chip && shared->writing != chip) {
981 : : /*
982 : : * We own the ability to erase without the ability
983 : : * to write, which means the erase was suspended
984 : : * and some other partition is currently writing.
985 : : * Don't let the switch below mess things up since
986 : : * we don't have ownership to resume anything.
987 : : */
988 : 0 : mutex_unlock(&shared->lock);
989 : 0 : wake_up(&chip->wq);
990 : 0 : return;
991 : : }
992 : 0 : mutex_unlock(&shared->lock);
993 : : }
994 : :
995 [ # # # # ]: 0 : switch(chip->oldstate) {
996 : : case FL_ERASING:
997 : : /* What if one interleaved chip has finished and the
998 : : other hasn't? The old code would leave the finished
999 : : one in READY mode. That's bad, and caused -EROFS
1000 : : errors to be returned from do_erase_oneblock because
1001 : : that's the only bit it checked for at the time.
1002 : : As the state machine appears to explicitly allow
1003 : : sending the 0x70 (Read Status) command to an erasing
1004 : : chip and expecting it to be ignored, that's what we
1005 : : do. */
1006 : : map_write(map, CMD(0xd0), adr);
1007 : : map_write(map, CMD(0x70), adr);
1008 : 0 : chip->oldstate = FL_READY;
1009 : 0 : chip->state = FL_ERASING;
1010 : 0 : break;
1011 : :
1012 : : case FL_XIP_WHILE_ERASING:
1013 : 0 : chip->state = chip->oldstate;
1014 : 0 : chip->oldstate = FL_READY;
1015 : 0 : break;
1016 : :
1017 : : case FL_READY:
1018 : : case FL_STATUS:
1019 : : case FL_JEDEC_QUERY:
1020 : : break;
1021 : : default:
1022 : 0 : printk(KERN_ERR "%s: put_chip() called with oldstate %d!!\n", map->name, chip->oldstate);
1023 : : }
1024 : 0 : wake_up(&chip->wq);
1025 : : }
1026 : :
1027 : : #ifdef CONFIG_MTD_XIP
1028 : :
1029 : : /*
1030 : : * No interrupt what so ever can be serviced while the flash isn't in array
1031 : : * mode. This is ensured by the xip_disable() and xip_enable() functions
1032 : : * enclosing any code path where the flash is known not to be in array mode.
1033 : : * And within a XIP disabled code path, only functions marked with __xipram
1034 : : * may be called and nothing else (it's a good thing to inspect generated
1035 : : * assembly to make sure inline functions were actually inlined and that gcc
1036 : : * didn't emit calls to its own support functions). Also configuring MTD CFI
1037 : : * support to a single buswidth and a single interleave is also recommended.
1038 : : */
1039 : :
1040 : : static void xip_disable(struct map_info *map, struct flchip *chip,
1041 : : unsigned long adr)
1042 : : {
1043 : : /* TODO: chips with no XIP use should ignore and return */
1044 : : (void) map_read(map, adr); /* ensure mmu mapping is up to date */
1045 : : local_irq_disable();
1046 : : }
1047 : :
1048 : : static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
1049 : : unsigned long adr)
1050 : : {
1051 : : struct cfi_private *cfi = map->fldrv_priv;
1052 : : if (chip->state != FL_POINT && chip->state != FL_READY) {
1053 : : map_write(map, CMD(0xff), adr);
1054 : : chip->state = FL_READY;
1055 : : }
1056 : : (void) map_read(map, adr);
1057 : : xip_iprefetch();
1058 : : local_irq_enable();
1059 : : }
1060 : :
1061 : : /*
1062 : : * When a delay is required for the flash operation to complete, the
1063 : : * xip_wait_for_operation() function is polling for both the given timeout
1064 : : * and pending (but still masked) hardware interrupts. Whenever there is an
1065 : : * interrupt pending then the flash erase or write operation is suspended,
1066 : : * array mode restored and interrupts unmasked. Task scheduling might also
1067 : : * happen at that point. The CPU eventually returns from the interrupt or
1068 : : * the call to schedule() and the suspended flash operation is resumed for
1069 : : * the remaining of the delay period.
1070 : : *
1071 : : * Warning: this function _will_ fool interrupt latency tracing tools.
1072 : : */
1073 : :
1074 : : static int __xipram xip_wait_for_operation(
1075 : : struct map_info *map, struct flchip *chip,
1076 : : unsigned long adr, unsigned int chip_op_time_max)
1077 : : {
1078 : : struct cfi_private *cfi = map->fldrv_priv;
1079 : : struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
1080 : : map_word status, OK = CMD(0x80);
1081 : : unsigned long usec, suspended, start, done;
1082 : : flstate_t oldstate, newstate;
1083 : :
1084 : : start = xip_currtime();
1085 : : usec = chip_op_time_max;
1086 : : if (usec == 0)
1087 : : usec = 500000;
1088 : : done = 0;
1089 : :
1090 : : do {
1091 : : cpu_relax();
1092 : : if (xip_irqpending() && cfip &&
1093 : : ((chip->state == FL_ERASING && (cfip->FeatureSupport&2)) ||
1094 : : (chip->state == FL_WRITING && (cfip->FeatureSupport&4))) &&
1095 : : (cfi_interleave_is_1(cfi) || chip->oldstate == FL_READY)) {
1096 : : /*
1097 : : * Let's suspend the erase or write operation when
1098 : : * supported. Note that we currently don't try to
1099 : : * suspend interleaved chips if there is already
1100 : : * another operation suspended (imagine what happens
1101 : : * when one chip was already done with the current
1102 : : * operation while another chip suspended it, then
1103 : : * we resume the whole thing at once). Yes, it
1104 : : * can happen!
1105 : : */
1106 : : usec -= done;
1107 : : map_write(map, CMD(0xb0), adr);
1108 : : map_write(map, CMD(0x70), adr);
1109 : : suspended = xip_currtime();
1110 : : do {
1111 : : if (xip_elapsed_since(suspended) > 100000) {
1112 : : /*
1113 : : * The chip doesn't want to suspend
1114 : : * after waiting for 100 msecs.
1115 : : * This is a critical error but there
1116 : : * is not much we can do here.
1117 : : */
1118 : : return -EIO;
1119 : : }
1120 : : status = map_read(map, adr);
1121 : : } while (!map_word_andequal(map, status, OK, OK));
1122 : :
1123 : : /* Suspend succeeded */
1124 : : oldstate = chip->state;
1125 : : if (oldstate == FL_ERASING) {
1126 : : if (!map_word_bitsset(map, status, CMD(0x40)))
1127 : : break;
1128 : : newstate = FL_XIP_WHILE_ERASING;
1129 : : chip->erase_suspended = 1;
1130 : : } else {
1131 : : if (!map_word_bitsset(map, status, CMD(0x04)))
1132 : : break;
1133 : : newstate = FL_XIP_WHILE_WRITING;
1134 : : chip->write_suspended = 1;
1135 : : }
1136 : : chip->state = newstate;
1137 : : map_write(map, CMD(0xff), adr);
1138 : : (void) map_read(map, adr);
1139 : : xip_iprefetch();
1140 : : local_irq_enable();
1141 : : mutex_unlock(&chip->mutex);
1142 : : xip_iprefetch();
1143 : : cond_resched();
1144 : :
1145 : : /*
1146 : : * We're back. However someone else might have
1147 : : * decided to go write to the chip if we are in
1148 : : * a suspended erase state. If so let's wait
1149 : : * until it's done.
1150 : : */
1151 : : mutex_lock(&chip->mutex);
1152 : : while (chip->state != newstate) {
1153 : : DECLARE_WAITQUEUE(wait, current);
1154 : : set_current_state(TASK_UNINTERRUPTIBLE);
1155 : : add_wait_queue(&chip->wq, &wait);
1156 : : mutex_unlock(&chip->mutex);
1157 : : schedule();
1158 : : remove_wait_queue(&chip->wq, &wait);
1159 : : mutex_lock(&chip->mutex);
1160 : : }
1161 : : /* Disallow XIP again */
1162 : : local_irq_disable();
1163 : :
1164 : : /* Resume the write or erase operation */
1165 : : map_write(map, CMD(0xd0), adr);
1166 : : map_write(map, CMD(0x70), adr);
1167 : : chip->state = oldstate;
1168 : : start = xip_currtime();
1169 : : } else if (usec >= 1000000/HZ) {
1170 : : /*
1171 : : * Try to save on CPU power when waiting delay
1172 : : * is at least a system timer tick period.
1173 : : * No need to be extremely accurate here.
1174 : : */
1175 : : xip_cpu_idle();
1176 : : }
1177 : : status = map_read(map, adr);
1178 : : done = xip_elapsed_since(start);
1179 : : } while (!map_word_andequal(map, status, OK, OK)
1180 : : && done < usec);
1181 : :
1182 : : return (done >= usec) ? -ETIME : 0;
1183 : : }
1184 : :
1185 : : /*
1186 : : * The INVALIDATE_CACHED_RANGE() macro is normally used in parallel while
1187 : : * the flash is actively programming or erasing since we have to poll for
1188 : : * the operation to complete anyway. We can't do that in a generic way with
1189 : : * a XIP setup so do it before the actual flash operation in this case
1190 : : * and stub it out from INVAL_CACHE_AND_WAIT.
1191 : : */
1192 : : #define XIP_INVAL_CACHED_RANGE(map, from, size) \
1193 : : INVALIDATE_CACHED_RANGE(map, from, size)
1194 : :
1195 : : #define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec, usec_max) \
1196 : : xip_wait_for_operation(map, chip, cmd_adr, usec_max)
1197 : :
1198 : : #else
1199 : :
1200 : : #define xip_disable(map, chip, adr)
1201 : : #define xip_enable(map, chip, adr)
1202 : : #define XIP_INVAL_CACHED_RANGE(x...)
1203 : : #define INVAL_CACHE_AND_WAIT inval_cache_and_wait_for_operation
1204 : :
1205 : 0 : static int inval_cache_and_wait_for_operation(
1206 : 0 : struct map_info *map, struct flchip *chip,
1207 : : unsigned long cmd_adr, unsigned long inval_adr, int inval_len,
1208 : : unsigned int chip_op_time, unsigned int chip_op_time_max)
1209 : : {
1210 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1211 : : map_word status, status_OK = CMD(0x80);
1212 : 0 : int chip_state = chip->state;
1213 : : unsigned int timeo, sleep_time, reset_timeo;
1214 : :
1215 : 0 : mutex_unlock(&chip->mutex);
1216 [ # # ]: 0 : if (inval_len)
1217 [ # # ]: 0 : INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
1218 : 0 : mutex_lock(&chip->mutex);
1219 : :
1220 : : timeo = chip_op_time_max;
1221 [ # # ]: 0 : if (!timeo)
1222 : : timeo = 500000;
1223 : : reset_timeo = timeo;
1224 : 0 : sleep_time = chip_op_time / 2;
1225 : :
1226 : : for (;;) {
1227 [ # # ]: 0 : if (chip->state != chip_state) {
1228 : : /* Someone's suspended the operation: sleep */
1229 : 0 : DECLARE_WAITQUEUE(wait, current);
1230 : 0 : set_current_state(TASK_UNINTERRUPTIBLE);
1231 : 0 : add_wait_queue(&chip->wq, &wait);
1232 : 0 : mutex_unlock(&chip->mutex);
1233 : 0 : schedule();
1234 : 0 : remove_wait_queue(&chip->wq, &wait);
1235 : 0 : mutex_lock(&chip->mutex);
1236 : 0 : continue;
1237 : : }
1238 : :
1239 : : status = map_read(map, cmd_adr);
1240 [ # # ]: 0 : if (map_word_andequal(map, status, status_OK, status_OK))
1241 : : break;
1242 : :
1243 [ # # ][ # # ]: 0 : if (chip->erase_suspended && chip_state == FL_ERASING) {
1244 : : /* Erase suspend occurred while sleep: reset timeout */
1245 : : timeo = reset_timeo;
1246 : 0 : chip->erase_suspended = 0;
1247 : : }
1248 [ # # ][ # # ]: 0 : if (chip->write_suspended && chip_state == FL_WRITING) {
1249 : : /* Write suspend occurred while sleep: reset timeout */
1250 : : timeo = reset_timeo;
1251 : 0 : chip->write_suspended = 0;
1252 : : }
1253 [ # # ]: 0 : if (!timeo) {
1254 : : map_write(map, CMD(0x70), cmd_adr);
1255 : 0 : chip->state = FL_STATUS;
1256 : 0 : return -ETIME;
1257 : : }
1258 : :
1259 : : /* OK Still waiting. Drop the lock, wait a while and retry. */
1260 : 0 : mutex_unlock(&chip->mutex);
1261 [ # # ]: 0 : if (sleep_time >= 1000000/HZ) {
1262 : : /*
1263 : : * Half of the normal delay still remaining
1264 : : * can be performed with a sleeping delay instead
1265 : : * of busy waiting.
1266 : : */
1267 : 0 : msleep(sleep_time/1000);
1268 : 0 : timeo -= sleep_time;
1269 : : sleep_time = 1000000/HZ;
1270 : : } else {
1271 : 0 : udelay(1);
1272 : 0 : cond_resched();
1273 : 0 : timeo--;
1274 : : }
1275 : 0 : mutex_lock(&chip->mutex);
1276 : : }
1277 : :
1278 : : /* Done and happy. */
1279 : 0 : chip->state = FL_STATUS;
1280 : 0 : return 0;
1281 : : }
1282 : :
1283 : : #endif
1284 : :
1285 : : #define WAIT_TIMEOUT(map, chip, adr, udelay, udelay_max) \
1286 : : INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay, udelay_max);
1287 : :
1288 : :
1289 : 0 : static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
1290 : : {
1291 : : unsigned long cmd_addr;
1292 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1293 : : int ret = 0;
1294 : :
1295 : 0 : adr += chip->start;
1296 : :
1297 : : /* Ensure cmd read/writes are aligned. */
1298 : 0 : cmd_addr = adr & ~(map_bankwidth(map)-1);
1299 : :
1300 : 0 : mutex_lock(&chip->mutex);
1301 : :
1302 : 0 : ret = get_chip(map, chip, cmd_addr, FL_POINT);
1303 : :
1304 [ # # ]: 0 : if (!ret) {
1305 [ # # ]: 0 : if (chip->state != FL_POINT && chip->state != FL_READY)
1306 : : map_write(map, CMD(0xff), cmd_addr);
1307 : :
1308 : 0 : chip->state = FL_POINT;
1309 : 0 : chip->ref_point_counter++;
1310 : : }
1311 : 0 : mutex_unlock(&chip->mutex);
1312 : :
1313 : 0 : return ret;
1314 : : }
1315 : :
1316 : 0 : static int cfi_intelext_point(struct mtd_info *mtd, loff_t from, size_t len,
1317 : : size_t *retlen, void **virt, resource_size_t *phys)
1318 : : {
1319 : 0 : struct map_info *map = mtd->priv;
1320 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1321 : : unsigned long ofs, last_end = 0;
1322 : : int chipnum;
1323 : : int ret = 0;
1324 : :
1325 [ # # ]: 0 : if (!map->virt)
1326 : : return -EINVAL;
1327 : :
1328 : : /* Now lock the chip(s) to POINT state */
1329 : :
1330 : : /* ofs: offset within the first chip that the first read should start */
1331 : 0 : chipnum = (from >> cfi->chipshift);
1332 : 0 : ofs = from - (chipnum << cfi->chipshift);
1333 : :
1334 : 0 : *virt = map->virt + cfi->chips[chipnum].start + ofs;
1335 [ # # ]: 0 : if (phys)
1336 : 0 : *phys = map->phys + cfi->chips[chipnum].start + ofs;
1337 : :
1338 [ # # ]: 0 : while (len) {
1339 : : unsigned long thislen;
1340 : :
1341 [ # # ]: 0 : if (chipnum >= cfi->numchips)
1342 : : break;
1343 : :
1344 : : /* We cannot point across chips that are virtually disjoint */
1345 [ # # ]: 0 : if (!last_end)
1346 : 0 : last_end = cfi->chips[chipnum].start;
1347 [ # # ]: 0 : else if (cfi->chips[chipnum].start != last_end)
1348 : : break;
1349 : :
1350 [ # # ]: 0 : if ((len + ofs -1) >> cfi->chipshift)
1351 : 0 : thislen = (1<<cfi->chipshift) - ofs;
1352 : : else
1353 : : thislen = len;
1354 : :
1355 : 0 : ret = do_point_onechip(map, &cfi->chips[chipnum], ofs, thislen);
1356 [ # # ]: 0 : if (ret)
1357 : : break;
1358 : :
1359 : 0 : *retlen += thislen;
1360 : 0 : len -= thislen;
1361 : :
1362 : : ofs = 0;
1363 : 0 : last_end += 1 << cfi->chipshift;
1364 : 0 : chipnum++;
1365 : : }
1366 : : return 0;
1367 : : }
1368 : :
1369 : 0 : static int cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
1370 : : {
1371 : 0 : struct map_info *map = mtd->priv;
1372 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1373 : : unsigned long ofs;
1374 : : int chipnum, err = 0;
1375 : :
1376 : : /* Now unlock the chip(s) POINT state */
1377 : :
1378 : : /* ofs: offset within the first chip that the first read should start */
1379 : 0 : chipnum = (from >> cfi->chipshift);
1380 : 0 : ofs = from - (chipnum << cfi->chipshift);
1381 : :
1382 [ # # ]: 0 : while (len && !err) {
1383 : : unsigned long thislen;
1384 : : struct flchip *chip;
1385 : :
1386 : 0 : chip = &cfi->chips[chipnum];
1387 [ # # ]: 0 : if (chipnum >= cfi->numchips)
1388 : : break;
1389 : :
1390 [ # # ]: 0 : if ((len + ofs -1) >> cfi->chipshift)
1391 : 0 : thislen = (1<<cfi->chipshift) - ofs;
1392 : : else
1393 : : thislen = len;
1394 : :
1395 : 0 : mutex_lock(&chip->mutex);
1396 [ # # ]: 0 : if (chip->state == FL_POINT) {
1397 : 0 : chip->ref_point_counter--;
1398 [ # # ]: 0 : if(chip->ref_point_counter == 0)
1399 : 0 : chip->state = FL_READY;
1400 : : } else {
1401 : 0 : printk(KERN_ERR "%s: Error: unpoint called on non pointed region\n", map->name);
1402 : : err = -EINVAL;
1403 : : }
1404 : :
1405 : 0 : put_chip(map, chip, chip->start);
1406 : 0 : mutex_unlock(&chip->mutex);
1407 : :
1408 : 0 : len -= thislen;
1409 : : ofs = 0;
1410 : 0 : chipnum++;
1411 : : }
1412 : :
1413 : 0 : return err;
1414 : : }
1415 : :
1416 : 0 : static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
1417 : : {
1418 : : unsigned long cmd_addr;
1419 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1420 : : int ret;
1421 : :
1422 : 0 : adr += chip->start;
1423 : :
1424 : : /* Ensure cmd read/writes are aligned. */
1425 : 0 : cmd_addr = adr & ~(map_bankwidth(map)-1);
1426 : :
1427 : 0 : mutex_lock(&chip->mutex);
1428 : 0 : ret = get_chip(map, chip, cmd_addr, FL_READY);
1429 [ # # ]: 0 : if (ret) {
1430 : 0 : mutex_unlock(&chip->mutex);
1431 : : return ret;
1432 : : }
1433 : :
1434 [ # # ]: 0 : if (chip->state != FL_POINT && chip->state != FL_READY) {
1435 : : map_write(map, CMD(0xff), cmd_addr);
1436 : :
1437 : 0 : chip->state = FL_READY;
1438 : : }
1439 : :
1440 : 0 : map_copy_from(map, buf, adr, len);
1441 : :
1442 : 0 : put_chip(map, chip, cmd_addr);
1443 : :
1444 : 0 : mutex_unlock(&chip->mutex);
1445 : : return 0;
1446 : : }
1447 : :
1448 : 0 : static int cfi_intelext_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
1449 : : {
1450 : 0 : struct map_info *map = mtd->priv;
1451 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1452 : : unsigned long ofs;
1453 : : int chipnum;
1454 : : int ret = 0;
1455 : :
1456 : : /* ofs: offset within the first chip that the first read should start */
1457 : 0 : chipnum = (from >> cfi->chipshift);
1458 : 0 : ofs = from - (chipnum << cfi->chipshift);
1459 : :
1460 [ # # ]: 0 : while (len) {
1461 : : unsigned long thislen;
1462 : :
1463 [ # # ]: 0 : if (chipnum >= cfi->numchips)
1464 : : break;
1465 : :
1466 [ # # ]: 0 : if ((len + ofs -1) >> cfi->chipshift)
1467 : 0 : thislen = (1<<cfi->chipshift) - ofs;
1468 : : else
1469 : : thislen = len;
1470 : :
1471 : 0 : ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
1472 [ # # ]: 0 : if (ret)
1473 : : break;
1474 : :
1475 : 0 : *retlen += thislen;
1476 : 0 : len -= thislen;
1477 : 0 : buf += thislen;
1478 : :
1479 : : ofs = 0;
1480 : 0 : chipnum++;
1481 : : }
1482 : 0 : return ret;
1483 : : }
1484 : :
1485 : 0 : static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
1486 : : unsigned long adr, map_word datum, int mode)
1487 : : {
1488 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1489 : : map_word status, write_cmd;
1490 : : int ret=0;
1491 : :
1492 : 0 : adr += chip->start;
1493 : :
1494 [ # # # ]: 0 : switch (mode) {
1495 : : case FL_WRITING:
1496 [ # # ]: 0 : write_cmd = (cfi->cfiq->P_ID != P_ID_INTEL_PERFORMANCE) ? CMD(0x40) : CMD(0x41);
1497 : : break;
1498 : : case FL_OTP_WRITE:
1499 : : write_cmd = CMD(0xc0);
1500 : : break;
1501 : : default:
1502 : : return -EINVAL;
1503 : : }
1504 : :
1505 : 0 : mutex_lock(&chip->mutex);
1506 : 0 : ret = get_chip(map, chip, adr, mode);
1507 [ # # ]: 0 : if (ret) {
1508 : 0 : mutex_unlock(&chip->mutex);
1509 : 0 : return ret;
1510 : : }
1511 : :
1512 : : XIP_INVAL_CACHED_RANGE(map, adr, map_bankwidth(map));
1513 [ # # ]: 0 : ENABLE_VPP(map);
1514 : : xip_disable(map, chip, adr);
1515 : : map_write(map, write_cmd, adr);
1516 : : map_write(map, datum, adr);
1517 : 0 : chip->state = mode;
1518 : :
1519 : 0 : ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1520 : : adr, map_bankwidth(map),
1521 : 0 : chip->word_write_time,
1522 : 0 : chip->word_write_time_max);
1523 [ # # ]: 0 : if (ret) {
1524 : : xip_enable(map, chip, adr);
1525 : 0 : printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
1526 : 0 : goto out;
1527 : : }
1528 : :
1529 : : /* check for errors */
1530 : : status = map_read(map, adr);
1531 [ # # ]: 0 : if (map_word_bitsset(map, status, CMD(0x1a))) {
1532 : : unsigned long chipstatus = MERGESTATUS(status);
1533 : :
1534 : : /* reset status */
1535 : : map_write(map, CMD(0x50), adr);
1536 : : map_write(map, CMD(0x70), adr);
1537 : : xip_enable(map, chip, adr);
1538 : :
1539 [ # # ]: 0 : if (chipstatus & 0x02) {
1540 : : ret = -EROFS;
1541 [ # # ]: 0 : } else if (chipstatus & 0x08) {
1542 : 0 : printk(KERN_ERR "%s: word write error (bad VPP)\n", map->name);
1543 : : ret = -EIO;
1544 : : } else {
1545 : 0 : printk(KERN_ERR "%s: word write error (status 0x%lx)\n", map->name, chipstatus);
1546 : : ret = -EINVAL;
1547 : : }
1548 : :
1549 : : goto out;
1550 : : }
1551 : :
1552 : : xip_enable(map, chip, adr);
1553 [ # # ]: 0 : out: DISABLE_VPP(map);
1554 : 0 : put_chip(map, chip, adr);
1555 : 0 : mutex_unlock(&chip->mutex);
1556 : 0 : return ret;
1557 : : }
1558 : :
1559 : :
1560 : 0 : static int cfi_intelext_write_words (struct mtd_info *mtd, loff_t to , size_t len, size_t *retlen, const u_char *buf)
1561 : : {
1562 : 0 : struct map_info *map = mtd->priv;
1563 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1564 : : int ret = 0;
1565 : : int chipnum;
1566 : : unsigned long ofs;
1567 : :
1568 : 0 : chipnum = to >> cfi->chipshift;
1569 : 0 : ofs = to - (chipnum << cfi->chipshift);
1570 : :
1571 : : /* If it's not bus-aligned, do the first byte write */
1572 [ # # ]: 0 : if (ofs & (map_bankwidth(map)-1)) {
1573 : 0 : unsigned long bus_ofs = ofs & ~(map_bankwidth(map)-1);
1574 : 0 : int gap = ofs - bus_ofs;
1575 : : int n;
1576 : : map_word datum;
1577 : :
1578 : 0 : n = min_t(int, len, map_bankwidth(map)-gap);
1579 : : datum = map_word_ff(map);
1580 : : datum = map_word_load_partial(map, datum, buf, gap, n);
1581 : :
1582 : 0 : ret = do_write_oneword(map, &cfi->chips[chipnum],
1583 : : bus_ofs, datum, FL_WRITING);
1584 [ # # ]: 0 : if (ret)
1585 : : return ret;
1586 : :
1587 : 0 : len -= n;
1588 : 0 : ofs += n;
1589 : 0 : buf += n;
1590 : 0 : (*retlen) += n;
1591 : :
1592 [ # # ]: 0 : if (ofs >> cfi->chipshift) {
1593 : 0 : chipnum ++;
1594 : : ofs = 0;
1595 [ # # ]: 0 : if (chipnum == cfi->numchips)
1596 : : return 0;
1597 : : }
1598 : : }
1599 : :
1600 [ # # ]: 0 : while(len >= map_bankwidth(map)) {
1601 : : map_word datum = map_word_load(map, buf);
1602 : :
1603 : 0 : ret = do_write_oneword(map, &cfi->chips[chipnum],
1604 : : ofs, datum, FL_WRITING);
1605 [ # # ]: 0 : if (ret)
1606 : 0 : return ret;
1607 : :
1608 : 0 : ofs += map_bankwidth(map);
1609 : 0 : buf += map_bankwidth(map);
1610 : 0 : (*retlen) += map_bankwidth(map);
1611 : 0 : len -= map_bankwidth(map);
1612 : :
1613 [ # # ]: 0 : if (ofs >> cfi->chipshift) {
1614 : 0 : chipnum ++;
1615 : : ofs = 0;
1616 [ # # ]: 0 : if (chipnum == cfi->numchips)
1617 : : return 0;
1618 : : }
1619 : : }
1620 : :
1621 [ # # ]: 0 : if (len & (map_bankwidth(map)-1)) {
1622 : : map_word datum;
1623 : :
1624 : : datum = map_word_ff(map);
1625 : 0 : datum = map_word_load_partial(map, datum, buf, 0, len);
1626 : :
1627 : 0 : ret = do_write_oneword(map, &cfi->chips[chipnum],
1628 : : ofs, datum, FL_WRITING);
1629 [ # # ]: 0 : if (ret)
1630 : : return ret;
1631 : :
1632 : 0 : (*retlen) += len;
1633 : : }
1634 : :
1635 : : return 0;
1636 : : }
1637 : :
1638 : :
1639 : 0 : static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
1640 : : unsigned long adr, const struct kvec **pvec,
1641 : : unsigned long *pvec_seek, int len)
1642 : : {
1643 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1644 : : map_word status, write_cmd, datum;
1645 : : unsigned long cmd_adr;
1646 : : int ret, wbufsize, word_gap, words;
1647 : : const struct kvec *vec;
1648 : : unsigned long vec_seek;
1649 : : unsigned long initial_adr;
1650 : : int initial_len = len;
1651 : :
1652 : 0 : wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1653 : 0 : adr += chip->start;
1654 : : initial_adr = adr;
1655 : 0 : cmd_adr = adr & ~(wbufsize-1);
1656 : :
1657 : : /* Let's determine this according to the interleave only once */
1658 [ # # ]: 0 : write_cmd = (cfi->cfiq->P_ID != P_ID_INTEL_PERFORMANCE) ? CMD(0xe8) : CMD(0xe9);
1659 : :
1660 : 0 : mutex_lock(&chip->mutex);
1661 : 0 : ret = get_chip(map, chip, cmd_adr, FL_WRITING);
1662 [ # # ]: 0 : if (ret) {
1663 : 0 : mutex_unlock(&chip->mutex);
1664 : 0 : return ret;
1665 : : }
1666 : :
1667 : : XIP_INVAL_CACHED_RANGE(map, initial_adr, initial_len);
1668 [ # # ]: 0 : ENABLE_VPP(map);
1669 : : xip_disable(map, chip, cmd_adr);
1670 : :
1671 : : /* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set
1672 : : [...], the device will not accept any more Write to Buffer commands".
1673 : : So we must check here and reset those bits if they're set. Otherwise
1674 : : we're just pissing in the wind */
1675 [ # # ]: 0 : if (chip->state != FL_STATUS) {
1676 : : map_write(map, CMD(0x70), cmd_adr);
1677 : 0 : chip->state = FL_STATUS;
1678 : : }
1679 : : status = map_read(map, cmd_adr);
1680 [ # # ]: 0 : if (map_word_bitsset(map, status, CMD(0x30))) {
1681 : : xip_enable(map, chip, cmd_adr);
1682 : 0 : printk(KERN_WARNING "SR.4 or SR.5 bits set in buffer write (status %lx). Clearing.\n", status.x[0]);
1683 : : xip_disable(map, chip, cmd_adr);
1684 : : map_write(map, CMD(0x50), cmd_adr);
1685 : : map_write(map, CMD(0x70), cmd_adr);
1686 : : }
1687 : :
1688 : 0 : chip->state = FL_WRITING_TO_BUFFER;
1689 : : map_write(map, write_cmd, cmd_adr);
1690 : 0 : ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0, 0);
1691 [ # # ]: 0 : if (ret) {
1692 : : /* Argh. Not ready for write to buffer */
1693 : : map_word Xstatus = map_read(map, cmd_adr);
1694 : : map_write(map, CMD(0x70), cmd_adr);
1695 : 0 : chip->state = FL_STATUS;
1696 : : status = map_read(map, cmd_adr);
1697 : : map_write(map, CMD(0x50), cmd_adr);
1698 : : map_write(map, CMD(0x70), cmd_adr);
1699 : : xip_enable(map, chip, cmd_adr);
1700 : 0 : printk(KERN_ERR "%s: Chip not ready for buffer write. Xstatus = %lx, status = %lx\n",
1701 : : map->name, Xstatus.x[0], status.x[0]);
1702 : : goto out;
1703 : : }
1704 : :
1705 : : /* Figure out the number of words to write */
1706 : 0 : word_gap = (-adr & (map_bankwidth(map)-1));
1707 : 0 : words = DIV_ROUND_UP(len - word_gap, map_bankwidth(map));
1708 [ # # ]: 0 : if (!word_gap) {
1709 : 0 : words--;
1710 : : } else {
1711 : 0 : word_gap = map_bankwidth(map) - word_gap;
1712 : 0 : adr -= word_gap;
1713 : : datum = map_word_ff(map);
1714 : : }
1715 : :
1716 : : /* Write length of data to come */
1717 : 0 : map_write(map, CMD(words), cmd_adr );
1718 : :
1719 : : /* Write data */
1720 : 0 : vec = *pvec;
1721 : 0 : vec_seek = *pvec_seek;
1722 : : do {
1723 : 0 : int n = map_bankwidth(map) - word_gap;
1724 [ # # ]: 0 : if (n > vec->iov_len - vec_seek)
1725 : 0 : n = vec->iov_len - vec_seek;
1726 [ # # ]: 0 : if (n > len)
1727 : : n = len;
1728 : :
1729 [ # # ][ # # ]: 0 : if (!word_gap && len < map_bankwidth(map))
1730 : : datum = map_word_ff(map);
1731 : :
1732 : 0 : datum = map_word_load_partial(map, datum,
1733 : 0 : vec->iov_base + vec_seek,
1734 : : word_gap, n);
1735 : :
1736 : 0 : len -= n;
1737 : : word_gap += n;
1738 [ # # ][ # # ]: 0 : if (!len || word_gap == map_bankwidth(map)) {
1739 : : map_write(map, datum, adr);
1740 : 0 : adr += map_bankwidth(map);
1741 : : word_gap = 0;
1742 : : }
1743 : :
1744 : 0 : vec_seek += n;
1745 [ # # ]: 0 : if (vec_seek == vec->iov_len) {
1746 : 0 : vec++;
1747 : : vec_seek = 0;
1748 : : }
1749 [ # # ]: 0 : } while (len);
1750 : 0 : *pvec = vec;
1751 : 0 : *pvec_seek = vec_seek;
1752 : :
1753 : : /* GO GO GO */
1754 : : map_write(map, CMD(0xd0), cmd_adr);
1755 : 0 : chip->state = FL_WRITING;
1756 : :
1757 : 0 : ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
1758 : : initial_adr, initial_len,
1759 : 0 : chip->buffer_write_time,
1760 : 0 : chip->buffer_write_time_max);
1761 [ # # ]: 0 : if (ret) {
1762 : : map_write(map, CMD(0x70), cmd_adr);
1763 : 0 : chip->state = FL_STATUS;
1764 : : xip_enable(map, chip, cmd_adr);
1765 : 0 : printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name);
1766 : 0 : goto out;
1767 : : }
1768 : :
1769 : : /* check for errors */
1770 : : status = map_read(map, cmd_adr);
1771 [ # # ]: 0 : if (map_word_bitsset(map, status, CMD(0x1a))) {
1772 : : unsigned long chipstatus = MERGESTATUS(status);
1773 : :
1774 : : /* reset status */
1775 : : map_write(map, CMD(0x50), cmd_adr);
1776 : : map_write(map, CMD(0x70), cmd_adr);
1777 : : xip_enable(map, chip, cmd_adr);
1778 : :
1779 [ # # ]: 0 : if (chipstatus & 0x02) {
1780 : : ret = -EROFS;
1781 [ # # ]: 0 : } else if (chipstatus & 0x08) {
1782 : 0 : printk(KERN_ERR "%s: buffer write error (bad VPP)\n", map->name);
1783 : : ret = -EIO;
1784 : : } else {
1785 : 0 : printk(KERN_ERR "%s: buffer write error (status 0x%lx)\n", map->name, chipstatus);
1786 : : ret = -EINVAL;
1787 : : }
1788 : :
1789 : : goto out;
1790 : : }
1791 : :
1792 : : xip_enable(map, chip, cmd_adr);
1793 [ # # ]: 0 : out: DISABLE_VPP(map);
1794 : 0 : put_chip(map, chip, cmd_adr);
1795 : 0 : mutex_unlock(&chip->mutex);
1796 : 0 : return ret;
1797 : : }
1798 : :
1799 : 0 : static int cfi_intelext_writev (struct mtd_info *mtd, const struct kvec *vecs,
1800 : : unsigned long count, loff_t to, size_t *retlen)
1801 : : {
1802 : 0 : struct map_info *map = mtd->priv;
1803 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1804 : 0 : int wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1805 : : int ret = 0;
1806 : : int chipnum;
1807 : : unsigned long ofs, vec_seek, i;
1808 : : size_t len = 0;
1809 : :
1810 [ # # ]: 0 : for (i = 0; i < count; i++)
1811 : 0 : len += vecs[i].iov_len;
1812 : :
1813 [ # # ]: 0 : if (!len)
1814 : : return 0;
1815 : :
1816 : 0 : chipnum = to >> cfi->chipshift;
1817 : 0 : ofs = to - (chipnum << cfi->chipshift);
1818 : 0 : vec_seek = 0;
1819 : :
1820 : : do {
1821 : : /* We must not cross write block boundaries */
1822 : 0 : int size = wbufsize - (ofs & (wbufsize-1));
1823 : :
1824 [ # # ]: 0 : if (size > len)
1825 : 0 : size = len;
1826 : 0 : ret = do_write_buffer(map, &cfi->chips[chipnum],
1827 : : ofs, &vecs, &vec_seek, size);
1828 [ # # ]: 0 : if (ret)
1829 : : return ret;
1830 : :
1831 : 0 : ofs += size;
1832 : 0 : (*retlen) += size;
1833 : 0 : len -= size;
1834 : :
1835 [ # # ]: 0 : if (ofs >> cfi->chipshift) {
1836 : 0 : chipnum ++;
1837 : : ofs = 0;
1838 [ # # ]: 0 : if (chipnum == cfi->numchips)
1839 : : return 0;
1840 : : }
1841 : :
1842 : : /* Be nice and reschedule with the chip in a usable state for other
1843 : : processes. */
1844 : 0 : cond_resched();
1845 : :
1846 [ # # ]: 0 : } while (len);
1847 : :
1848 : : return 0;
1849 : : }
1850 : :
1851 : 0 : static int cfi_intelext_write_buffers (struct mtd_info *mtd, loff_t to,
1852 : : size_t len, size_t *retlen, const u_char *buf)
1853 : : {
1854 : : struct kvec vec;
1855 : :
1856 : 0 : vec.iov_base = (void *) buf;
1857 : 0 : vec.iov_len = len;
1858 : :
1859 : 0 : return cfi_intelext_writev(mtd, &vec, 1, to, retlen);
1860 : : }
1861 : :
1862 : 0 : static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
1863 : : unsigned long adr, int len, void *thunk)
1864 : : {
1865 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1866 : : map_word status;
1867 : : int retries = 3;
1868 : : int ret;
1869 : :
1870 : 0 : adr += chip->start;
1871 : :
1872 : : retry:
1873 : 0 : mutex_lock(&chip->mutex);
1874 : 0 : ret = get_chip(map, chip, adr, FL_ERASING);
1875 [ # # ]: 0 : if (ret) {
1876 : 0 : mutex_unlock(&chip->mutex);
1877 : 0 : return ret;
1878 : : }
1879 : :
1880 : : XIP_INVAL_CACHED_RANGE(map, adr, len);
1881 [ # # ]: 0 : ENABLE_VPP(map);
1882 : : xip_disable(map, chip, adr);
1883 : :
1884 : : /* Clear the status register first */
1885 : : map_write(map, CMD(0x50), adr);
1886 : :
1887 : : /* Now erase */
1888 : : map_write(map, CMD(0x20), adr);
1889 : : map_write(map, CMD(0xD0), adr);
1890 : 0 : chip->state = FL_ERASING;
1891 : 0 : chip->erase_suspended = 0;
1892 : :
1893 : 0 : ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1894 : : adr, len,
1895 : 0 : chip->erase_time,
1896 : 0 : chip->erase_time_max);
1897 [ # # ]: 0 : if (ret) {
1898 : : map_write(map, CMD(0x70), adr);
1899 : 0 : chip->state = FL_STATUS;
1900 : : xip_enable(map, chip, adr);
1901 : 0 : printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name);
1902 : 0 : goto out;
1903 : : }
1904 : :
1905 : : /* We've broken this before. It doesn't hurt to be safe */
1906 : : map_write(map, CMD(0x70), adr);
1907 : 0 : chip->state = FL_STATUS;
1908 : : status = map_read(map, adr);
1909 : :
1910 : : /* check for errors */
1911 [ # # ]: 0 : if (map_word_bitsset(map, status, CMD(0x3a))) {
1912 : : unsigned long chipstatus = MERGESTATUS(status);
1913 : :
1914 : : /* Reset the error bits */
1915 : : map_write(map, CMD(0x50), adr);
1916 : : map_write(map, CMD(0x70), adr);
1917 : : xip_enable(map, chip, adr);
1918 : :
1919 [ # # ]: 0 : if ((chipstatus & 0x30) == 0x30) {
1920 : 0 : printk(KERN_ERR "%s: block erase error: (bad command sequence, status 0x%lx)\n", map->name, chipstatus);
1921 : : ret = -EINVAL;
1922 [ # # ]: 0 : } else if (chipstatus & 0x02) {
1923 : : /* Protection bit set */
1924 : : ret = -EROFS;
1925 [ # # ]: 0 : } else if (chipstatus & 0x8) {
1926 : : /* Voltage */
1927 : 0 : printk(KERN_ERR "%s: block erase error: (bad VPP)\n", map->name);
1928 : : ret = -EIO;
1929 [ # # ][ # # ]: 0 : } else if (chipstatus & 0x20 && retries--) {
1930 : 0 : printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus);
1931 [ # # ]: 0 : DISABLE_VPP(map);
1932 : 0 : put_chip(map, chip, adr);
1933 : 0 : mutex_unlock(&chip->mutex);
1934 : 0 : goto retry;
1935 : : } else {
1936 : 0 : printk(KERN_ERR "%s: block erase failed at 0x%08lx (status 0x%lx)\n", map->name, adr, chipstatus);
1937 : : ret = -EIO;
1938 : : }
1939 : :
1940 : : goto out;
1941 : : }
1942 : :
1943 : : xip_enable(map, chip, adr);
1944 [ # # ]: 0 : out: DISABLE_VPP(map);
1945 : 0 : put_chip(map, chip, adr);
1946 : 0 : mutex_unlock(&chip->mutex);
1947 : 0 : return ret;
1948 : : }
1949 : :
1950 : 0 : static int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
1951 : : {
1952 : : unsigned long ofs, len;
1953 : : int ret;
1954 : :
1955 : 0 : ofs = instr->addr;
1956 : 0 : len = instr->len;
1957 : :
1958 : 0 : ret = cfi_varsize_frob(mtd, do_erase_oneblock, ofs, len, NULL);
1959 [ # # ]: 0 : if (ret)
1960 : : return ret;
1961 : :
1962 : 0 : instr->state = MTD_ERASE_DONE;
1963 : 0 : mtd_erase_callback(instr);
1964 : :
1965 : 0 : return 0;
1966 : : }
1967 : :
1968 : 0 : static void cfi_intelext_sync (struct mtd_info *mtd)
1969 : : {
1970 : 0 : struct map_info *map = mtd->priv;
1971 : 0 : struct cfi_private *cfi = map->fldrv_priv;
1972 : : int i;
1973 : : struct flchip *chip;
1974 : : int ret = 0;
1975 : :
1976 [ # # ][ # # ]: 0 : for (i=0; !ret && i<cfi->numchips; i++) {
1977 : 0 : chip = &cfi->chips[i];
1978 : :
1979 : 0 : mutex_lock(&chip->mutex);
1980 : 0 : ret = get_chip(map, chip, chip->start, FL_SYNCING);
1981 : :
1982 [ # # ]: 0 : if (!ret) {
1983 : 0 : chip->oldstate = chip->state;
1984 : 0 : chip->state = FL_SYNCING;
1985 : : /* No need to wake_up() on this state change -
1986 : : * as the whole point is that nobody can do anything
1987 : : * with the chip now anyway.
1988 : : */
1989 : : }
1990 : 0 : mutex_unlock(&chip->mutex);
1991 : : }
1992 : :
1993 : : /* Unlock the chips again */
1994 : :
1995 [ # # ]: 0 : for (i--; i >=0; i--) {
1996 : 0 : chip = &cfi->chips[i];
1997 : :
1998 : 0 : mutex_lock(&chip->mutex);
1999 : :
2000 [ # # ]: 0 : if (chip->state == FL_SYNCING) {
2001 : 0 : chip->state = chip->oldstate;
2002 : 0 : chip->oldstate = FL_READY;
2003 : 0 : wake_up(&chip->wq);
2004 : : }
2005 : 0 : mutex_unlock(&chip->mutex);
2006 : : }
2007 : 0 : }
2008 : :
2009 : 0 : static int __xipram do_getlockstatus_oneblock(struct map_info *map,
2010 : : struct flchip *chip,
2011 : : unsigned long adr,
2012 : : int len, void *thunk)
2013 : : {
2014 : 0 : struct cfi_private *cfi = map->fldrv_priv;
2015 : 0 : int status, ofs_factor = cfi->interleave * cfi->device_type;
2016 : :
2017 : 0 : adr += chip->start;
2018 : : xip_disable(map, chip, adr+(2*ofs_factor));
2019 : 0 : map_write(map, CMD(0x90), adr+(2*ofs_factor));
2020 : 0 : chip->state = FL_JEDEC_QUERY;
2021 : 0 : status = cfi_read_query(map, adr+(2*ofs_factor));
2022 : : xip_enable(map, chip, 0);
2023 : 0 : return status;
2024 : : }
2025 : :
2026 : : #ifdef DEBUG_LOCK_BITS
2027 : : static int __xipram do_printlockstatus_oneblock(struct map_info *map,
2028 : : struct flchip *chip,
2029 : : unsigned long adr,
2030 : : int len, void *thunk)
2031 : : {
2032 : : printk(KERN_DEBUG "block status register for 0x%08lx is %x\n",
2033 : : adr, do_getlockstatus_oneblock(map, chip, adr, len, thunk));
2034 : : return 0;
2035 : : }
2036 : : #endif
2037 : :
2038 : : #define DO_XXLOCK_ONEBLOCK_LOCK ((void *) 1)
2039 : : #define DO_XXLOCK_ONEBLOCK_UNLOCK ((void *) 2)
2040 : :
2041 : 0 : static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip,
2042 : : unsigned long adr, int len, void *thunk)
2043 : : {
2044 : 0 : struct cfi_private *cfi = map->fldrv_priv;
2045 : 0 : struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2046 : : int mdelay;
2047 : : int ret;
2048 : :
2049 : 0 : adr += chip->start;
2050 : :
2051 : 0 : mutex_lock(&chip->mutex);
2052 : 0 : ret = get_chip(map, chip, adr, FL_LOCKING);
2053 [ # # ]: 0 : if (ret) {
2054 : 0 : mutex_unlock(&chip->mutex);
2055 : 0 : return ret;
2056 : : }
2057 : :
2058 [ # # ]: 0 : ENABLE_VPP(map);
2059 : : xip_disable(map, chip, adr);
2060 : :
2061 : : map_write(map, CMD(0x60), adr);
2062 [ # # ]: 0 : if (thunk == DO_XXLOCK_ONEBLOCK_LOCK) {
2063 : : map_write(map, CMD(0x01), adr);
2064 : 0 : chip->state = FL_LOCKING;
2065 [ # # ]: 0 : } else if (thunk == DO_XXLOCK_ONEBLOCK_UNLOCK) {
2066 : : map_write(map, CMD(0xD0), adr);
2067 : 0 : chip->state = FL_UNLOCKING;
2068 : : } else
2069 : 0 : BUG();
2070 : :
2071 : : /*
2072 : : * If Instant Individual Block Locking supported then no need
2073 : : * to delay.
2074 : : */
2075 : : /*
2076 : : * Unlocking may take up to 1.4 seconds on some Intel flashes. So
2077 : : * lets use a max of 1.5 seconds (1500ms) as timeout.
2078 : : *
2079 : : * See "Clear Block Lock-Bits Time" on page 40 in
2080 : : * "3 Volt Intel StrataFlash Memory" 28F128J3,28F640J3,28F320J3 manual
2081 : : * from February 2003
2082 : : */
2083 [ # # ][ # # ]: 0 : mdelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1500 : 0;
2084 : :
2085 : 0 : ret = WAIT_TIMEOUT(map, chip, adr, mdelay, mdelay * 1000);
2086 [ # # ]: 0 : if (ret) {
2087 : : map_write(map, CMD(0x70), adr);
2088 : 0 : chip->state = FL_STATUS;
2089 : : xip_enable(map, chip, adr);
2090 : 0 : printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name);
2091 : 0 : goto out;
2092 : : }
2093 : :
2094 : : xip_enable(map, chip, adr);
2095 [ # # ]: 0 : out: DISABLE_VPP(map);
2096 : 0 : put_chip(map, chip, adr);
2097 : 0 : mutex_unlock(&chip->mutex);
2098 : 0 : return ret;
2099 : : }
2100 : :
2101 : 0 : static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2102 : : {
2103 : : int ret;
2104 : :
2105 : : #ifdef DEBUG_LOCK_BITS
2106 : : printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
2107 : : __func__, ofs, len);
2108 : : cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2109 : : ofs, len, NULL);
2110 : : #endif
2111 : :
2112 : 0 : ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
2113 : : ofs, len, DO_XXLOCK_ONEBLOCK_LOCK);
2114 : :
2115 : : #ifdef DEBUG_LOCK_BITS
2116 : : printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
2117 : : __func__, ret);
2118 : : cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2119 : : ofs, len, NULL);
2120 : : #endif
2121 : :
2122 : 0 : return ret;
2123 : : }
2124 : :
2125 : 0 : static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2126 : : {
2127 : : int ret;
2128 : :
2129 : : #ifdef DEBUG_LOCK_BITS
2130 : : printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
2131 : : __func__, ofs, len);
2132 : : cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2133 : : ofs, len, NULL);
2134 : : #endif
2135 : :
2136 : 0 : ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
2137 : : ofs, len, DO_XXLOCK_ONEBLOCK_UNLOCK);
2138 : :
2139 : : #ifdef DEBUG_LOCK_BITS
2140 : : printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
2141 : : __func__, ret);
2142 : : cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2143 : : ofs, len, NULL);
2144 : : #endif
2145 : :
2146 : 0 : return ret;
2147 : : }
2148 : :
2149 : 0 : static int cfi_intelext_is_locked(struct mtd_info *mtd, loff_t ofs,
2150 : : uint64_t len)
2151 : : {
2152 : 0 : return cfi_varsize_frob(mtd, do_getlockstatus_oneblock,
2153 : 0 : ofs, len, NULL) ? 1 : 0;
2154 : : }
2155 : :
2156 : : #ifdef CONFIG_MTD_OTP
2157 : :
2158 : : typedef int (*otp_op_t)(struct map_info *map, struct flchip *chip,
2159 : : u_long data_offset, u_char *buf, u_int size,
2160 : : u_long prot_offset, u_int groupno, u_int groupsize);
2161 : :
2162 : : static int __xipram
2163 : : do_otp_read(struct map_info *map, struct flchip *chip, u_long offset,
2164 : : u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2165 : : {
2166 : : struct cfi_private *cfi = map->fldrv_priv;
2167 : : int ret;
2168 : :
2169 : : mutex_lock(&chip->mutex);
2170 : : ret = get_chip(map, chip, chip->start, FL_JEDEC_QUERY);
2171 : : if (ret) {
2172 : : mutex_unlock(&chip->mutex);
2173 : : return ret;
2174 : : }
2175 : :
2176 : : /* let's ensure we're not reading back cached data from array mode */
2177 : : INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2178 : :
2179 : : xip_disable(map, chip, chip->start);
2180 : : if (chip->state != FL_JEDEC_QUERY) {
2181 : : map_write(map, CMD(0x90), chip->start);
2182 : : chip->state = FL_JEDEC_QUERY;
2183 : : }
2184 : : map_copy_from(map, buf, chip->start + offset, size);
2185 : : xip_enable(map, chip, chip->start);
2186 : :
2187 : : /* then ensure we don't keep OTP data in the cache */
2188 : : INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2189 : :
2190 : : put_chip(map, chip, chip->start);
2191 : : mutex_unlock(&chip->mutex);
2192 : : return 0;
2193 : : }
2194 : :
2195 : : static int
2196 : : do_otp_write(struct map_info *map, struct flchip *chip, u_long offset,
2197 : : u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2198 : : {
2199 : : int ret;
2200 : :
2201 : : while (size) {
2202 : : unsigned long bus_ofs = offset & ~(map_bankwidth(map)-1);
2203 : : int gap = offset - bus_ofs;
2204 : : int n = min_t(int, size, map_bankwidth(map)-gap);
2205 : : map_word datum = map_word_ff(map);
2206 : :
2207 : : datum = map_word_load_partial(map, datum, buf, gap, n);
2208 : : ret = do_write_oneword(map, chip, bus_ofs, datum, FL_OTP_WRITE);
2209 : : if (ret)
2210 : : return ret;
2211 : :
2212 : : offset += n;
2213 : : buf += n;
2214 : : size -= n;
2215 : : }
2216 : :
2217 : : return 0;
2218 : : }
2219 : :
2220 : : static int
2221 : : do_otp_lock(struct map_info *map, struct flchip *chip, u_long offset,
2222 : : u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2223 : : {
2224 : : struct cfi_private *cfi = map->fldrv_priv;
2225 : : map_word datum;
2226 : :
2227 : : /* make sure area matches group boundaries */
2228 : : if (size != grpsz)
2229 : : return -EXDEV;
2230 : :
2231 : : datum = map_word_ff(map);
2232 : : datum = map_word_clr(map, datum, CMD(1 << grpno));
2233 : : return do_write_oneword(map, chip, prot, datum, FL_OTP_WRITE);
2234 : : }
2235 : :
2236 : : static int cfi_intelext_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
2237 : : size_t *retlen, u_char *buf,
2238 : : otp_op_t action, int user_regs)
2239 : : {
2240 : : struct map_info *map = mtd->priv;
2241 : : struct cfi_private *cfi = map->fldrv_priv;
2242 : : struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2243 : : struct flchip *chip;
2244 : : struct cfi_intelext_otpinfo *otp;
2245 : : u_long devsize, reg_prot_offset, data_offset;
2246 : : u_int chip_num, chip_step, field, reg_fact_size, reg_user_size;
2247 : : u_int groups, groupno, groupsize, reg_fact_groups, reg_user_groups;
2248 : : int ret;
2249 : :
2250 : : *retlen = 0;
2251 : :
2252 : : /* Check that we actually have some OTP registers */
2253 : : if (!extp || !(extp->FeatureSupport & 64) || !extp->NumProtectionFields)
2254 : : return -ENODATA;
2255 : :
2256 : : /* we need real chips here not virtual ones */
2257 : : devsize = (1 << cfi->cfiq->DevSize) * cfi->interleave;
2258 : : chip_step = devsize >> cfi->chipshift;
2259 : : chip_num = 0;
2260 : :
2261 : : /* Some chips have OTP located in the _top_ partition only.
2262 : : For example: Intel 28F256L18T (T means top-parameter device) */
2263 : : if (cfi->mfr == CFI_MFR_INTEL) {
2264 : : switch (cfi->id) {
2265 : : case 0x880b:
2266 : : case 0x880c:
2267 : : case 0x880d:
2268 : : chip_num = chip_step - 1;
2269 : : }
2270 : : }
2271 : :
2272 : : for ( ; chip_num < cfi->numchips; chip_num += chip_step) {
2273 : : chip = &cfi->chips[chip_num];
2274 : : otp = (struct cfi_intelext_otpinfo *)&extp->extra[0];
2275 : :
2276 : : /* first OTP region */
2277 : : field = 0;
2278 : : reg_prot_offset = extp->ProtRegAddr;
2279 : : reg_fact_groups = 1;
2280 : : reg_fact_size = 1 << extp->FactProtRegSize;
2281 : : reg_user_groups = 1;
2282 : : reg_user_size = 1 << extp->UserProtRegSize;
2283 : :
2284 : : while (len > 0) {
2285 : : /* flash geometry fixup */
2286 : : data_offset = reg_prot_offset + 1;
2287 : : data_offset *= cfi->interleave * cfi->device_type;
2288 : : reg_prot_offset *= cfi->interleave * cfi->device_type;
2289 : : reg_fact_size *= cfi->interleave;
2290 : : reg_user_size *= cfi->interleave;
2291 : :
2292 : : if (user_regs) {
2293 : : groups = reg_user_groups;
2294 : : groupsize = reg_user_size;
2295 : : /* skip over factory reg area */
2296 : : groupno = reg_fact_groups;
2297 : : data_offset += reg_fact_groups * reg_fact_size;
2298 : : } else {
2299 : : groups = reg_fact_groups;
2300 : : groupsize = reg_fact_size;
2301 : : groupno = 0;
2302 : : }
2303 : :
2304 : : while (len > 0 && groups > 0) {
2305 : : if (!action) {
2306 : : /*
2307 : : * Special case: if action is NULL
2308 : : * we fill buf with otp_info records.
2309 : : */
2310 : : struct otp_info *otpinfo;
2311 : : map_word lockword;
2312 : : len -= sizeof(struct otp_info);
2313 : : if (len <= 0)
2314 : : return -ENOSPC;
2315 : : ret = do_otp_read(map, chip,
2316 : : reg_prot_offset,
2317 : : (u_char *)&lockword,
2318 : : map_bankwidth(map),
2319 : : 0, 0, 0);
2320 : : if (ret)
2321 : : return ret;
2322 : : otpinfo = (struct otp_info *)buf;
2323 : : otpinfo->start = from;
2324 : : otpinfo->length = groupsize;
2325 : : otpinfo->locked =
2326 : : !map_word_bitsset(map, lockword,
2327 : : CMD(1 << groupno));
2328 : : from += groupsize;
2329 : : buf += sizeof(*otpinfo);
2330 : : *retlen += sizeof(*otpinfo);
2331 : : } else if (from >= groupsize) {
2332 : : from -= groupsize;
2333 : : data_offset += groupsize;
2334 : : } else {
2335 : : int size = groupsize;
2336 : : data_offset += from;
2337 : : size -= from;
2338 : : from = 0;
2339 : : if (size > len)
2340 : : size = len;
2341 : : ret = action(map, chip, data_offset,
2342 : : buf, size, reg_prot_offset,
2343 : : groupno, groupsize);
2344 : : if (ret < 0)
2345 : : return ret;
2346 : : buf += size;
2347 : : len -= size;
2348 : : *retlen += size;
2349 : : data_offset += size;
2350 : : }
2351 : : groupno++;
2352 : : groups--;
2353 : : }
2354 : :
2355 : : /* next OTP region */
2356 : : if (++field == extp->NumProtectionFields)
2357 : : break;
2358 : : reg_prot_offset = otp->ProtRegAddr;
2359 : : reg_fact_groups = otp->FactGroups;
2360 : : reg_fact_size = 1 << otp->FactProtRegSize;
2361 : : reg_user_groups = otp->UserGroups;
2362 : : reg_user_size = 1 << otp->UserProtRegSize;
2363 : : otp++;
2364 : : }
2365 : : }
2366 : :
2367 : : return 0;
2368 : : }
2369 : :
2370 : : static int cfi_intelext_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
2371 : : size_t len, size_t *retlen,
2372 : : u_char *buf)
2373 : : {
2374 : : return cfi_intelext_otp_walk(mtd, from, len, retlen,
2375 : : buf, do_otp_read, 0);
2376 : : }
2377 : :
2378 : : static int cfi_intelext_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
2379 : : size_t len, size_t *retlen,
2380 : : u_char *buf)
2381 : : {
2382 : : return cfi_intelext_otp_walk(mtd, from, len, retlen,
2383 : : buf, do_otp_read, 1);
2384 : : }
2385 : :
2386 : : static int cfi_intelext_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
2387 : : size_t len, size_t *retlen,
2388 : : u_char *buf)
2389 : : {
2390 : : return cfi_intelext_otp_walk(mtd, from, len, retlen,
2391 : : buf, do_otp_write, 1);
2392 : : }
2393 : :
2394 : : static int cfi_intelext_lock_user_prot_reg(struct mtd_info *mtd,
2395 : : loff_t from, size_t len)
2396 : : {
2397 : : size_t retlen;
2398 : : return cfi_intelext_otp_walk(mtd, from, len, &retlen,
2399 : : NULL, do_otp_lock, 1);
2400 : : }
2401 : :
2402 : : static int cfi_intelext_get_fact_prot_info(struct mtd_info *mtd,
2403 : : struct otp_info *buf, size_t len)
2404 : : {
2405 : : size_t retlen;
2406 : : int ret;
2407 : :
2408 : : ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 0);
2409 : : return ret ? : retlen;
2410 : : }
2411 : :
2412 : : static int cfi_intelext_get_user_prot_info(struct mtd_info *mtd,
2413 : : struct otp_info *buf, size_t len)
2414 : : {
2415 : : size_t retlen;
2416 : : int ret;
2417 : :
2418 : : ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 1);
2419 : : return ret ? : retlen;
2420 : : }
2421 : :
2422 : : #endif
2423 : :
2424 : 0 : static void cfi_intelext_save_locks(struct mtd_info *mtd)
2425 : : {
2426 : : struct mtd_erase_region_info *region;
2427 : : int block, status, i;
2428 : : unsigned long adr;
2429 : : size_t len;
2430 : :
2431 [ # # ]: 0 : for (i = 0; i < mtd->numeraseregions; i++) {
2432 : 0 : region = &mtd->eraseregions[i];
2433 [ # # ]: 0 : if (!region->lockmap)
2434 : 0 : continue;
2435 : :
2436 [ # # ]: 0 : for (block = 0; block < region->numblocks; block++){
2437 : 0 : len = region->erasesize;
2438 : 0 : adr = region->offset + block * len;
2439 : :
2440 : 0 : status = cfi_varsize_frob(mtd,
2441 : : do_getlockstatus_oneblock, adr, len, NULL);
2442 [ # # ]: 0 : if (status)
2443 : 0 : set_bit(block, region->lockmap);
2444 : : else
2445 : 0 : clear_bit(block, region->lockmap);
2446 : : }
2447 : : }
2448 : 0 : }
2449 : :
2450 : 0 : static int cfi_intelext_suspend(struct mtd_info *mtd)
2451 : : {
2452 : 0 : struct map_info *map = mtd->priv;
2453 : 0 : struct cfi_private *cfi = map->fldrv_priv;
2454 : 0 : struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2455 : : int i;
2456 : : struct flchip *chip;
2457 : : int ret = 0;
2458 : :
2459 [ # # ]: 0 : if ((mtd->flags & MTD_POWERUP_LOCK)
2460 [ # # ][ # # ]: 0 : && extp && (extp->FeatureSupport & (1 << 5)))
2461 : 0 : cfi_intelext_save_locks(mtd);
2462 : :
2463 [ # # ][ # # ]: 0 : for (i=0; !ret && i<cfi->numchips; i++) {
2464 : 0 : chip = &cfi->chips[i];
2465 : :
2466 : 0 : mutex_lock(&chip->mutex);
2467 : :
2468 [ # # # ]: 0 : switch (chip->state) {
2469 : : case FL_READY:
2470 : : case FL_STATUS:
2471 : : case FL_CFI_QUERY:
2472 : : case FL_JEDEC_QUERY:
2473 [ # # ]: 0 : if (chip->oldstate == FL_READY) {
2474 : : /* place the chip in a known state before suspend */
2475 : 0 : map_write(map, CMD(0xFF), cfi->chips[i].start);
2476 : 0 : chip->oldstate = chip->state;
2477 : 0 : chip->state = FL_PM_SUSPENDED;
2478 : : /* No need to wake_up() on this state change -
2479 : : * as the whole point is that nobody can do anything
2480 : : * with the chip now anyway.
2481 : : */
2482 : : } else {
2483 : : /* There seems to be an operation pending. We must wait for it. */
2484 : 0 : printk(KERN_NOTICE "Flash device refused suspend due to pending operation (oldstate %d)\n", chip->oldstate);
2485 : : ret = -EAGAIN;
2486 : : }
2487 : : break;
2488 : : default:
2489 : : /* Should we actually wait? Once upon a time these routines weren't
2490 : : allowed to. Or should we return -EAGAIN, because the upper layers
2491 : : ought to have already shut down anything which was using the device
2492 : : anyway? The latter for now. */
2493 : 0 : printk(KERN_NOTICE "Flash device refused suspend due to active operation (state %d)\n", chip->state);
2494 : : ret = -EAGAIN;
2495 : : case FL_PM_SUSPENDED:
2496 : : break;
2497 : : }
2498 : 0 : mutex_unlock(&chip->mutex);
2499 : : }
2500 : :
2501 : : /* Unlock the chips again */
2502 : :
2503 [ # # ]: 0 : if (ret) {
2504 [ # # ]: 0 : for (i--; i >=0; i--) {
2505 : 0 : chip = &cfi->chips[i];
2506 : :
2507 : 0 : mutex_lock(&chip->mutex);
2508 : :
2509 [ # # ]: 0 : if (chip->state == FL_PM_SUSPENDED) {
2510 : : /* No need to force it into a known state here,
2511 : : because we're returning failure, and it didn't
2512 : : get power cycled */
2513 : 0 : chip->state = chip->oldstate;
2514 : 0 : chip->oldstate = FL_READY;
2515 : 0 : wake_up(&chip->wq);
2516 : : }
2517 : 0 : mutex_unlock(&chip->mutex);
2518 : : }
2519 : : }
2520 : :
2521 : 0 : return ret;
2522 : : }
2523 : :
2524 : 0 : static void cfi_intelext_restore_locks(struct mtd_info *mtd)
2525 : : {
2526 : : struct mtd_erase_region_info *region;
2527 : : int block, i;
2528 : : unsigned long adr;
2529 : : size_t len;
2530 : :
2531 [ # # ]: 0 : for (i = 0; i < mtd->numeraseregions; i++) {
2532 : 0 : region = &mtd->eraseregions[i];
2533 [ # # ]: 0 : if (!region->lockmap)
2534 : 0 : continue;
2535 : :
2536 [ # # ]: 0 : for_each_clear_bit(block, region->lockmap, region->numblocks) {
2537 : 0 : len = region->erasesize;
2538 : 0 : adr = region->offset + block * len;
2539 : 0 : cfi_intelext_unlock(mtd, adr, len);
2540 : : }
2541 : : }
2542 : 0 : }
2543 : :
2544 : 0 : static void cfi_intelext_resume(struct mtd_info *mtd)
2545 : : {
2546 : 0 : struct map_info *map = mtd->priv;
2547 : 0 : struct cfi_private *cfi = map->fldrv_priv;
2548 : 0 : struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2549 : : int i;
2550 : : struct flchip *chip;
2551 : :
2552 [ # # ]: 0 : for (i=0; i<cfi->numchips; i++) {
2553 : :
2554 : 0 : chip = &cfi->chips[i];
2555 : :
2556 : 0 : mutex_lock(&chip->mutex);
2557 : :
2558 : : /* Go to known state. Chip may have been power cycled */
2559 [ # # ]: 0 : if (chip->state == FL_PM_SUSPENDED) {
2560 : 0 : map_write(map, CMD(0xFF), cfi->chips[i].start);
2561 : 0 : chip->oldstate = chip->state = FL_READY;
2562 : 0 : wake_up(&chip->wq);
2563 : : }
2564 : :
2565 : 0 : mutex_unlock(&chip->mutex);
2566 : : }
2567 : :
2568 [ # # ]: 0 : if ((mtd->flags & MTD_POWERUP_LOCK)
2569 [ # # ][ # # ]: 0 : && extp && (extp->FeatureSupport & (1 << 5)))
2570 : 0 : cfi_intelext_restore_locks(mtd);
2571 : 0 : }
2572 : :
2573 : 0 : static int cfi_intelext_reset(struct mtd_info *mtd)
2574 : : {
2575 : 0 : struct map_info *map = mtd->priv;
2576 : 0 : struct cfi_private *cfi = map->fldrv_priv;
2577 : : int i, ret;
2578 : :
2579 [ # # ]: 0 : for (i=0; i < cfi->numchips; i++) {
2580 : 0 : struct flchip *chip = &cfi->chips[i];
2581 : :
2582 : : /* force the completion of any ongoing operation
2583 : : and switch to array mode so any bootloader in
2584 : : flash is accessible for soft reboot. */
2585 : 0 : mutex_lock(&chip->mutex);
2586 : 0 : ret = get_chip(map, chip, chip->start, FL_SHUTDOWN);
2587 [ # # ]: 0 : if (!ret) {
2588 : 0 : map_write(map, CMD(0xff), chip->start);
2589 : 0 : chip->state = FL_SHUTDOWN;
2590 : 0 : put_chip(map, chip, chip->start);
2591 : : }
2592 : 0 : mutex_unlock(&chip->mutex);
2593 : : }
2594 : :
2595 : 0 : return 0;
2596 : : }
2597 : :
2598 : 0 : static int cfi_intelext_reboot(struct notifier_block *nb, unsigned long val,
2599 : : void *v)
2600 : : {
2601 : 0 : struct mtd_info *mtd;
2602 : :
2603 : : mtd = container_of(nb, struct mtd_info, reboot_notifier);
2604 : 0 : cfi_intelext_reset(mtd);
2605 : 0 : return NOTIFY_DONE;
2606 : : }
2607 : :
2608 : 0 : static void cfi_intelext_destroy(struct mtd_info *mtd)
2609 : : {
2610 : 0 : struct map_info *map = mtd->priv;
2611 : 0 : struct cfi_private *cfi = map->fldrv_priv;
2612 : : struct mtd_erase_region_info *region;
2613 : : int i;
2614 : 0 : cfi_intelext_reset(mtd);
2615 : 0 : unregister_reboot_notifier(&mtd->reboot_notifier);
2616 : 0 : kfree(cfi->cmdset_priv);
2617 : 0 : kfree(cfi->cfiq);
2618 : 0 : kfree(cfi->chips[0].priv);
2619 : 0 : kfree(cfi);
2620 [ # # ]: 0 : for (i = 0; i < mtd->numeraseregions; i++) {
2621 : 0 : region = &mtd->eraseregions[i];
2622 [ # # ]: 0 : if (region->lockmap)
2623 : 0 : kfree(region->lockmap);
2624 : : }
2625 : 0 : kfree(mtd->eraseregions);
2626 : 0 : }
2627 : :
2628 : : MODULE_LICENSE("GPL");
2629 : : MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
2630 : : MODULE_DESCRIPTION("MTD chip driver for Intel/Sharp flash chips");
2631 : : MODULE_ALIAS("cfi_cmdset_0003");
2632 : : MODULE_ALIAS("cfi_cmdset_0200");
|
