?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
blkcg: fix blkg_alloc() failure path
[linux-2.6.git] / drivers / mtd / onenand / onenand_base.c
blob7153e0d27101e3eed06ac17addcdbd4734c7ccc3
1 /*
2 * linux/drivers/mtd/onenand/onenand_base.c
3 *
4 * Copyright © 2005-2009 Samsung Electronics
5 * Copyright © 2007 Nokia Corporation
6 *
7 * Kyungmin Park <kyungmin.park@samsung.com>
8 *
9 * Credits:
10 * Adrian Hunter <ext-adrian.hunter@nokia.com>:
11 * auto-placement support, read-while load support, various fixes
12 *
13 * Vishak G <vishak.g at samsung.com>, Rohit Hagargundgi <h.rohit at samsung.com>
14 * Flex-OneNAND support
15 * Amul Kumar Saha <amul.saha at samsung.com>
16 * OTP support
17 *
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License version 2 as
20 * published by the Free Software Foundation.
21 */
22
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/slab.h>
27 #include <linux/init.h>
28 #include <linux/sched.h>
29 #include <linux/delay.h>
30 #include <linux/interrupt.h>
31 #include <linux/jiffies.h>
32 #include <linux/mtd/mtd.h>
33 #include <linux/mtd/onenand.h>
34 #include <linux/mtd/partitions.h>
35
36 #include <asm/io.h>
37
38 /*
39 * Multiblock erase if number of blocks to erase is 2 or more.
40 * Maximum number of blocks for simultaneous erase is 64.
41 */
42 #define MB_ERASE_MIN_BLK_COUNT 2
43 #define MB_ERASE_MAX_BLK_COUNT 64
44
45 /* Default Flex-OneNAND boundary and lock respectively */
46 static int flex_bdry[MAX_DIES * 2] = { -1, 0, -1, 0 };
47
48 module_param_array(flex_bdry, int, NULL, 0400);
49 MODULE_PARM_DESC(flex_bdry, "SLC Boundary information for Flex-OneNAND"
50 "Syntax:flex_bdry=DIE_BDRY,LOCK,..."
51 "DIE_BDRY: SLC boundary of the die"
52 "LOCK: Locking information for SLC boundary"
53 " : 0->Set boundary in unlocked status"
54 " : 1->Set boundary in locked status");
55
56 /* Default OneNAND/Flex-OneNAND OTP options*/
57 static int otp;
58
59 module_param(otp, int, 0400);
60 MODULE_PARM_DESC(otp, "Corresponding behaviour of OneNAND in OTP"
61 "Syntax : otp=LOCK_TYPE"
62 "LOCK_TYPE : Keys issued, for specific OTP Lock type"
63 " : 0 -> Default (No Blocks Locked)"
64 " : 1 -> OTP Block lock"
65 " : 2 -> 1st Block lock"
66 " : 3 -> BOTH OTP Block and 1st Block lock");
67
68 /*
69 * flexonenand_oob_128 - oob info for Flex-Onenand with 4KB page
70 * For now, we expose only 64 out of 80 ecc bytes
71 */
72 static struct nand_ecclayout flexonenand_oob_128 = {
73 .eccbytes = 64,
74 .eccpos = {
75 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
76 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
77 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
78 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
79 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
80 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
81 102, 103, 104, 105
82 },
83 .oobfree = {
84 {2, 4}, {18, 4}, {34, 4}, {50, 4},
85 {66, 4}, {82, 4}, {98, 4}, {114, 4}
86 }
87 };
88
89 /*
90 * onenand_oob_128 - oob info for OneNAND with 4KB page
91 *
92 * Based on specification:
93 * 4Gb M-die OneNAND Flash (KFM4G16Q4M, KFN8G16Q4M). Rev. 1.3, Apr. 2010
94 *
95 * For eccpos we expose only 64 bytes out of 72 (see struct nand_ecclayout)
96 *
97 * oobfree uses the spare area fields marked as
98 * "Managed by internal ECC logic for Logical Sector Number area"
99 */
100 static struct nand_ecclayout onenand_oob_128 = {
101 .eccbytes = 64,
102 .eccpos = {
103 7, 8, 9, 10, 11, 12, 13, 14, 15,
104 23, 24, 25, 26, 27, 28, 29, 30, 31,
105 39, 40, 41, 42, 43, 44, 45, 46, 47,
106 55, 56, 57, 58, 59, 60, 61, 62, 63,
107 71, 72, 73, 74, 75, 76, 77, 78, 79,
108 87, 88, 89, 90, 91, 92, 93, 94, 95,
109 103, 104, 105, 106, 107, 108, 109, 110, 111,
110 119
111 },
112 .oobfree = {
113 {2, 3}, {18, 3}, {34, 3}, {50, 3},
114 {66, 3}, {82, 3}, {98, 3}, {114, 3}
115 }
116 };
117
118 /**
119 * onenand_oob_64 - oob info for large (2KB) page
120 */
121 static struct nand_ecclayout onenand_oob_64 = {
122 .eccbytes = 20,
123 .eccpos = {
124 8, 9, 10, 11, 12,
125 24, 25, 26, 27, 28,
126 40, 41, 42, 43, 44,
127 56, 57, 58, 59, 60,
128 },
129 .oobfree = {
130 {2, 3}, {14, 2}, {18, 3}, {30, 2},
131 {34, 3}, {46, 2}, {50, 3}, {62, 2}
132 }
133 };
134
135 /**
136 * onenand_oob_32 - oob info for middle (1KB) page
137 */
138 static struct nand_ecclayout onenand_oob_32 = {
139 .eccbytes = 10,
140 .eccpos = {
141 8, 9, 10, 11, 12,
142 24, 25, 26, 27, 28,
143 },
144 .oobfree = { {2, 3}, {14, 2}, {18, 3}, {30, 2} }
145 };
146
147 static const unsigned char ffchars[] = {
148 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
149 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 16 */
150 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
151 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 32 */
152 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
153 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 48 */
154 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
155 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 64 */
156 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
157 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 80 */
158 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
159 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 96 */
160 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
161 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 112 */
162 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
163 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 128 */
164 };
165
166 /**
167 * onenand_readw - [OneNAND Interface] Read OneNAND register
168 * @param addr address to read
169 *
170 * Read OneNAND register
171 */
172 static unsigned short onenand_readw(void __iomem *addr)
173 {
174 return readw(addr);
175 }
176
177 /**
178 * onenand_writew - [OneNAND Interface] Write OneNAND register with value
179 * @param value value to write
180 * @param addr address to write
181 *
182 * Write OneNAND register with value
183 */
184 static void onenand_writew(unsigned short value, void __iomem *addr)
185 {
186 writew(value, addr);
187 }
188
189 /**
190 * onenand_block_address - [DEFAULT] Get block address
191 * @param this onenand chip data structure
192 * @param block the block
193 * @return translated block address if DDP, otherwise same
194 *
195 * Setup Start Address 1 Register (F100h)
196 */
197 static int onenand_block_address(struct onenand_chip *this, int block)
198 {
199 /* Device Flash Core select, NAND Flash Block Address */
200 if (block & this->density_mask)
201 return ONENAND_DDP_CHIP1 | (block ^ this->density_mask);
202
203 return block;
204 }
205
206 /**
207 * onenand_bufferram_address - [DEFAULT] Get bufferram address
208 * @param this onenand chip data structure
209 * @param block the block
210 * @return set DBS value if DDP, otherwise 0
211 *
212 * Setup Start Address 2 Register (F101h) for DDP
213 */
214 static int onenand_bufferram_address(struct onenand_chip *this, int block)
215 {
216 /* Device BufferRAM Select */
217 if (block & this->density_mask)
218 return ONENAND_DDP_CHIP1;
219
220 return ONENAND_DDP_CHIP0;
221 }
222
223 /**
224 * onenand_page_address - [DEFAULT] Get page address
225 * @param page the page address
226 * @param sector the sector address
227 * @return combined page and sector address
228 *
229 * Setup Start Address 8 Register (F107h)
230 */
231 static int onenand_page_address(int page, int sector)
232 {
233 /* Flash Page Address, Flash Sector Address */
234 int fpa, fsa;
235
236 fpa = page & ONENAND_FPA_MASK;
237 fsa = sector & ONENAND_FSA_MASK;
238
239 return ((fpa << ONENAND_FPA_SHIFT) | fsa);
240 }
241
242 /**
243 * onenand_buffer_address - [DEFAULT] Get buffer address
244 * @param dataram1 DataRAM index
245 * @param sectors the sector address
246 * @param count the number of sectors
247 * @return the start buffer value
248 *
249 * Setup Start Buffer Register (F200h)
250 */
251 static int onenand_buffer_address(int dataram1, int sectors, int count)
252 {
253 int bsa, bsc;
254
255 /* BufferRAM Sector Address */
256 bsa = sectors & ONENAND_BSA_MASK;
257
258 if (dataram1)
259 bsa |= ONENAND_BSA_DATARAM1; /* DataRAM1 */
260 else
261 bsa |= ONENAND_BSA_DATARAM0; /* DataRAM0 */
262
263 /* BufferRAM Sector Count */
264 bsc = count & ONENAND_BSC_MASK;
265
266 return ((bsa << ONENAND_BSA_SHIFT) | bsc);
267 }
268
269 /**
270 * flexonenand_block- For given address return block number
271 * @param this - OneNAND device structure
272 * @param addr - Address for which block number is needed
273 */
274 static unsigned flexonenand_block(struct onenand_chip *this, loff_t addr)
275 {
276 unsigned boundary, blk, die = 0;
277
278 if (ONENAND_IS_DDP(this) && addr >= this->diesize[0]) {
279 die = 1;
280 addr -= this->diesize[0];
281 }
282
283 boundary = this->boundary[die];
284
285 blk = addr >> (this->erase_shift - 1);
286 if (blk > boundary)
287 blk = (blk + boundary + 1) >> 1;
288
289 blk += die ? this->density_mask : 0;
290 return blk;
291 }
292
293 inline unsigned onenand_block(struct onenand_chip *this, loff_t addr)
294 {
295 if (!FLEXONENAND(this))
296 return addr >> this->erase_shift;
297 return flexonenand_block(this, addr);
298 }
299
300 /**
301 * flexonenand_addr - Return address of the block
302 * @this: OneNAND device structure
303 * @block: Block number on Flex-OneNAND
304 *
305 * Return address of the block
306 */
307 static loff_t flexonenand_addr(struct onenand_chip *this, int block)
308 {
309 loff_t ofs = 0;
310 int die = 0, boundary;
311
312 if (ONENAND_IS_DDP(this) && block >= this->density_mask) {
313 block -= this->density_mask;
314 die = 1;
315 ofs = this->diesize[0];
316 }
317
318 boundary = this->boundary[die];
319 ofs += (loff_t)block << (this->erase_shift - 1);
320 if (block > (boundary + 1))
321 ofs += (loff_t)(block - boundary - 1) << (this->erase_shift - 1);
322 return ofs;
323 }
324
325 loff_t onenand_addr(struct onenand_chip *this, int block)
326 {
327 if (!FLEXONENAND(this))
328 return (loff_t)block << this->erase_shift;
329 return flexonenand_addr(this, block);
330 }
331 EXPORT_SYMBOL(onenand_addr);
332
333 /**
334 * onenand_get_density - [DEFAULT] Get OneNAND density
335 * @param dev_id OneNAND device ID
336 *
337 * Get OneNAND density from device ID
338 */
339 static inline int onenand_get_density(int dev_id)
340 {
341 int density = dev_id >> ONENAND_DEVICE_DENSITY_SHIFT;
342 return (density & ONENAND_DEVICE_DENSITY_MASK);
343 }
344
345 /**
346 * flexonenand_region - [Flex-OneNAND] Return erase region of addr
347 * @param mtd MTD device structure
348 * @param addr address whose erase region needs to be identified
349 */
350 int flexonenand_region(struct mtd_info *mtd, loff_t addr)
351 {
352 int i;
353
354 for (i = 0; i < mtd->numeraseregions; i++)
355 if (addr < mtd->eraseregions[i].offset)
356 break;
357 return i - 1;
358 }
359 EXPORT_SYMBOL(flexonenand_region);
360
361 /**
362 * onenand_command - [DEFAULT] Send command to OneNAND device
363 * @param mtd MTD device structure
364 * @param cmd the command to be sent
365 * @param addr offset to read from or write to
366 * @param len number of bytes to read or write
367 *
368 * Send command to OneNAND device. This function is used for middle/large page
369 * devices (1KB/2KB Bytes per page)
370 */
371 static int onenand_command(struct mtd_info *mtd, int cmd, loff_t addr, size_t len)
372 {
373 struct onenand_chip *this = mtd->priv;
374 int value, block, page;
375
376 /* Address translation */
377 switch (cmd) {
378 case ONENAND_CMD_UNLOCK:
379 case ONENAND_CMD_LOCK:
380 case ONENAND_CMD_LOCK_TIGHT:
381 case ONENAND_CMD_UNLOCK_ALL:
382 block = -1;
383 page = -1;
384 break;
385
386 case FLEXONENAND_CMD_PI_ACCESS:
387 /* addr contains die index */
388 block = addr * this->density_mask;
389 page = -1;
390 break;
391
392 case ONENAND_CMD_ERASE:
393 case ONENAND_CMD_MULTIBLOCK_ERASE:
394 case ONENAND_CMD_ERASE_VERIFY:
395 case ONENAND_CMD_BUFFERRAM:
396 case ONENAND_CMD_OTP_ACCESS:
397 block = onenand_block(this, addr);
398 page = -1;
399 break;
400
401 case FLEXONENAND_CMD_READ_PI:
402 cmd = ONENAND_CMD_READ;
403 block = addr * this->density_mask;
404 page = 0;
405 break;
406
407 default:
408 block = onenand_block(this, addr);
409 if (FLEXONENAND(this))
410 page = (int) (addr - onenand_addr(this, block))>>\
411 this->page_shift;
412 else
413 page = (int) (addr >> this->page_shift);
414 if (ONENAND_IS_2PLANE(this)) {
415 /* Make the even block number */
416 block &= ~1;
417 /* Is it the odd plane? */
418 if (addr & this->writesize)
419 block++;
420 page >>= 1;
421 }
422 page &= this->page_mask;
423 break;
424 }
425
426 /* NOTE: The setting order of the registers is very important! */
427 if (cmd == ONENAND_CMD_BUFFERRAM) {
428 /* Select DataRAM for DDP */
429 value = onenand_bufferram_address(this, block);
430 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
431
432 if (ONENAND_IS_2PLANE(this) || ONENAND_IS_4KB_PAGE(this))
433 /* It is always BufferRAM0 */
434 ONENAND_SET_BUFFERRAM0(this);
435 else
436 /* Switch to the next data buffer */
437 ONENAND_SET_NEXT_BUFFERRAM(this);
438
439 return 0;
440 }
441
442 if (block != -1) {
443 /* Write 'DFS, FBA' of Flash */
444 value = onenand_block_address(this, block);
445 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
446
447 /* Select DataRAM for DDP */
448 value = onenand_bufferram_address(this, block);
449 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
450 }
451
452 if (page != -1) {
453 /* Now we use page size operation */
454 int sectors = 0, count = 0;
455 int dataram;
456
457 switch (cmd) {
458 case FLEXONENAND_CMD_RECOVER_LSB:
459 case ONENAND_CMD_READ:
460 case ONENAND_CMD_READOOB:
461 if (ONENAND_IS_4KB_PAGE(this))
462 /* It is always BufferRAM0 */
463 dataram = ONENAND_SET_BUFFERRAM0(this);
464 else
465 dataram = ONENAND_SET_NEXT_BUFFERRAM(this);
466 break;
467
468 default:
469 if (ONENAND_IS_2PLANE(this) && cmd == ONENAND_CMD_PROG)
470 cmd = ONENAND_CMD_2X_PROG;
471 dataram = ONENAND_CURRENT_BUFFERRAM(this);
472 break;
473 }
474
475 /* Write 'FPA, FSA' of Flash */
476 value = onenand_page_address(page, sectors);
477 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS8);
478
479 /* Write 'BSA, BSC' of DataRAM */
480 value = onenand_buffer_address(dataram, sectors, count);
481 this->write_word(value, this->base + ONENAND_REG_START_BUFFER);
482 }
483
484 /* Interrupt clear */
485 this->write_word(ONENAND_INT_CLEAR, this->base + ONENAND_REG_INTERRUPT);
486
487 /* Write command */
488 this->write_word(cmd, this->base + ONENAND_REG_COMMAND);
489
490 return 0;
491 }
492
493 /**
494 * onenand_read_ecc - return ecc status
495 * @param this onenand chip structure
496 */
497 static inline int onenand_read_ecc(struct onenand_chip *this)
498 {
499 int ecc, i, result = 0;
500
501 if (!FLEXONENAND(this) && !ONENAND_IS_4KB_PAGE(this))
502 return this->read_word(this->base + ONENAND_REG_ECC_STATUS);
503
504 for (i = 0; i < 4; i++) {
505 ecc = this->read_word(this->base + ONENAND_REG_ECC_STATUS + i*2);
506 if (likely(!ecc))
507 continue;
508 if (ecc & FLEXONENAND_UNCORRECTABLE_ERROR)
509 return ONENAND_ECC_2BIT_ALL;
510 else
511 result = ONENAND_ECC_1BIT_ALL;
512 }
513
514 return result;
515 }
516
517 /**
518 * onenand_wait - [DEFAULT] wait until the command is done
519 * @param mtd MTD device structure
520 * @param state state to select the max. timeout value
521 *
522 * Wait for command done. This applies to all OneNAND command
523 * Read can take up to 30us, erase up to 2ms and program up to 350us
524 * according to general OneNAND specs
525 */
526 static int onenand_wait(struct mtd_info *mtd, int state)
527 {
528 struct onenand_chip * this = mtd->priv;
529 unsigned long timeout;
530 unsigned int flags = ONENAND_INT_MASTER;
531 unsigned int interrupt = 0;
532 unsigned int ctrl;
533
534 /* The 20 msec is enough */
535 timeout = jiffies + msecs_to_jiffies(20);
536 while (time_before(jiffies, timeout)) {
537 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
538
539 if (interrupt & flags)
540 break;
541
542 if (state != FL_READING && state != FL_PREPARING_ERASE)
543 cond_resched();
544 }
545 /* To get correct interrupt status in timeout case */
546 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
547
548 ctrl = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
549
550 /*
551 * In the Spec. it checks the controller status first
552 * However if you get the correct information in case of
553 * power off recovery (POR) test, it should read ECC status first
554 */
555 if (interrupt & ONENAND_INT_READ) {
556 int ecc = onenand_read_ecc(this);
557 if (ecc) {
558 if (ecc & ONENAND_ECC_2BIT_ALL) {
559 printk(KERN_ERR "%s: ECC error = 0x%04x\n",
560 __func__, ecc);
561 mtd->ecc_stats.failed++;
562 return -EBADMSG;
563 } else if (ecc & ONENAND_ECC_1BIT_ALL) {
564 printk(KERN_DEBUG "%s: correctable ECC error = 0x%04x\n",
565 __func__, ecc);
566 mtd->ecc_stats.corrected++;
567 }
568 }
569 } else if (state == FL_READING) {
570 printk(KERN_ERR "%s: read timeout! ctrl=0x%04x intr=0x%04x\n",
571 __func__, ctrl, interrupt);
572 return -EIO;
573 }
574
575 if (state == FL_PREPARING_ERASE && !(interrupt & ONENAND_INT_ERASE)) {
576 printk(KERN_ERR "%s: mb erase timeout! ctrl=0x%04x intr=0x%04x\n",
577 __func__, ctrl, interrupt);
578 return -EIO;
579 }
580
581 if (!(interrupt & ONENAND_INT_MASTER)) {
582 printk(KERN_ERR "%s: timeout! ctrl=0x%04x intr=0x%04x\n",
583 __func__, ctrl, interrupt);
584 return -EIO;
585 }
586
587 /* If there's controller error, it's a real error */
588 if (ctrl & ONENAND_CTRL_ERROR) {
589 printk(KERN_ERR "%s: controller error = 0x%04x\n",
590 __func__, ctrl);
591 if (ctrl & ONENAND_CTRL_LOCK)
592 printk(KERN_ERR "%s: it's locked error.\n", __func__);
593 return -EIO;
594 }
595
596 return 0;
597 }
598
599 /*
600 * onenand_interrupt - [DEFAULT] onenand interrupt handler
601 * @param irq onenand interrupt number
602 * @param dev_id interrupt data
603 *
604 * complete the work
605 */
606 static irqreturn_t onenand_interrupt(int irq, void *data)
607 {
608 struct onenand_chip *this = data;
609
610 /* To handle shared interrupt */
611 if (!this->complete.done)
612 complete(&this->complete);
613
614 return IRQ_HANDLED;
615 }
616
617 /*
618 * onenand_interrupt_wait - [DEFAULT] wait until the command is done
619 * @param mtd MTD device structure
620 * @param state state to select the max. timeout value
621 *
622 * Wait for command done.
623 */
624 static int onenand_interrupt_wait(struct mtd_info *mtd, int state)
625 {
626 struct onenand_chip *this = mtd->priv;
627
628 wait_for_completion(&this->complete);
629
630 return onenand_wait(mtd, state);
631 }
632
633 /*
634 * onenand_try_interrupt_wait - [DEFAULT] try interrupt wait
635 * @param mtd MTD device structure
636 * @param state state to select the max. timeout value
637 *
638 * Try interrupt based wait (It is used one-time)
639 */
640 static int onenand_try_interrupt_wait(struct mtd_info *mtd, int state)
641 {
642 struct onenand_chip *this = mtd->priv;
643 unsigned long remain, timeout;
644
645 /* We use interrupt wait first */
646 this->wait = onenand_interrupt_wait;
647
648 timeout = msecs_to_jiffies(100);
649 remain = wait_for_completion_timeout(&this->complete, timeout);
650 if (!remain) {
651 printk(KERN_INFO "OneNAND: There's no interrupt. "
652 "We use the normal wait\n");
653
654 /* Release the irq */
655 free_irq(this->irq, this);
656
657 this->wait = onenand_wait;
658 }
659
660 return onenand_wait(mtd, state);
661 }
662
663 /*
664 * onenand_setup_wait - [OneNAND Interface] setup onenand wait method
665 * @param mtd MTD device structure
666 *
667 * There's two method to wait onenand work
668 * 1. polling - read interrupt status register
669 * 2. interrupt - use the kernel interrupt method
670 */
671 static void onenand_setup_wait(struct mtd_info *mtd)
672 {
673 struct onenand_chip *this = mtd->priv;
674 int syscfg;
675
676 init_completion(&this->complete);
677
678 if (this->irq <= 0) {
679 this->wait = onenand_wait;
680 return;
681 }
682
683 if (request_irq(this->irq, &onenand_interrupt,
684 IRQF_SHARED, "onenand", this)) {
685 /* If we can't get irq, use the normal wait */
686 this->wait = onenand_wait;
687 return;
688 }
689
690 /* Enable interrupt */
691 syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1);
692 syscfg |= ONENAND_SYS_CFG1_IOBE;
693 this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);
694
695 this->wait = onenand_try_interrupt_wait;
696 }
697
698 /**
699 * onenand_bufferram_offset - [DEFAULT] BufferRAM offset
700 * @param mtd MTD data structure
701 * @param area BufferRAM area
702 * @return offset given area
703 *
704 * Return BufferRAM offset given area
705 */
706 static inline int onenand_bufferram_offset(struct mtd_info *mtd, int area)
707 {
708 struct onenand_chip *this = mtd->priv;
709
710 if (ONENAND_CURRENT_BUFFERRAM(this)) {
711 /* Note: the 'this->writesize' is a real page size */
712 if (area == ONENAND_DATARAM)
713 return this->writesize;
714 if (area == ONENAND_SPARERAM)
715 return mtd->oobsize;
716 }
717
718 return 0;
719 }
720
721 /**
722 * onenand_read_bufferram - [OneNAND Interface] Read the bufferram area
723 * @param mtd MTD data structure
724 * @param area BufferRAM area
725 * @param buffer the databuffer to put/get data
726 * @param offset offset to read from or write to
727 * @param count number of bytes to read/write
728 *
729 * Read the BufferRAM area
730 */
731 static int onenand_read_bufferram(struct mtd_info *mtd, int area,
732 unsigned char *buffer, int offset, size_t count)
733 {
734 struct onenand_chip *this = mtd->priv;
735 void __iomem *bufferram;
736
737 bufferram = this->base + area;
738
739 bufferram += onenand_bufferram_offset(mtd, area);
740
741 if (ONENAND_CHECK_BYTE_ACCESS(count)) {
742 unsigned short word;
743
744 /* Align with word(16-bit) size */
745 count--;
746
747 /* Read word and save byte */
748 word = this->read_word(bufferram + offset + count);
749 buffer[count] = (word & 0xff);
750 }
751
752 memcpy(buffer, bufferram + offset, count);
753
754 return 0;
755 }
756
757 /**
758 * onenand_sync_read_bufferram - [OneNAND Interface] Read the bufferram area with Sync. Burst mode
759 * @param mtd MTD data structure
760 * @param area BufferRAM area
761 * @param buffer the databuffer to put/get data
762 * @param offset offset to read from or write to
763 * @param count number of bytes to read/write
764 *
765 * Read the BufferRAM area with Sync. Burst Mode
766 */
767 static int onenand_sync_read_bufferram(struct mtd_info *mtd, int area,
768 unsigned char *buffer, int offset, size_t count)
769 {
770 struct onenand_chip *this = mtd->priv;
771 void __iomem *bufferram;
772
773 bufferram = this->base + area;
774
775 bufferram += onenand_bufferram_offset(mtd, area);
776
777 this->mmcontrol(mtd, ONENAND_SYS_CFG1_SYNC_READ);
778
779 if (ONENAND_CHECK_BYTE_ACCESS(count)) {
780 unsigned short word;
781
782 /* Align with word(16-bit) size */
783 count--;
784
785 /* Read word and save byte */
786 word = this->read_word(bufferram + offset + count);
787 buffer[count] = (word & 0xff);
788 }
789
790 memcpy(buffer, bufferram + offset, count);
791
792 this->mmcontrol(mtd, 0);
793
794 return 0;
795 }
796
797 /**
798 * onenand_write_bufferram - [OneNAND Interface] Write the bufferram area
799 * @param mtd MTD data structure
800 * @param area BufferRAM area
801 * @param buffer the databuffer to put/get data
802 * @param offset offset to read from or write to
803 * @param count number of bytes to read/write
804 *
805 * Write the BufferRAM area
806 */
807 static int onenand_write_bufferram(struct mtd_info *mtd, int area,
808 const unsigned char *buffer, int offset, size_t count)
809 {
810 struct onenand_chip *this = mtd->priv;
811 void __iomem *bufferram;
812
813 bufferram = this->base + area;
814
815 bufferram += onenand_bufferram_offset(mtd, area);
816
817 if (ONENAND_CHECK_BYTE_ACCESS(count)) {
818 unsigned short word;
819 int byte_offset;
820
821 /* Align with word(16-bit) size */
822 count--;
823
824 /* Calculate byte access offset */
825 byte_offset = offset + count;
826
827 /* Read word and save byte */
828 word = this->read_word(bufferram + byte_offset);
829 word = (word & ~0xff) | buffer[count];
830 this->write_word(word, bufferram + byte_offset);
831 }
832
833 memcpy(bufferram + offset, buffer, count);
834
835 return 0;
836 }
837
838 /**
839 * onenand_get_2x_blockpage - [GENERIC] Get blockpage at 2x program mode
840 * @param mtd MTD data structure
841 * @param addr address to check
842 * @return blockpage address
843 *
844 * Get blockpage address at 2x program mode
845 */
846 static int onenand_get_2x_blockpage(struct mtd_info *mtd, loff_t addr)
847 {
848 struct onenand_chip *this = mtd->priv;
849 int blockpage, block, page;
850
851 /* Calculate the even block number */
852 block = (int) (addr >> this->erase_shift) & ~1;
853 /* Is it the odd plane? */
854 if (addr & this->writesize)
855 block++;
856 page = (int) (addr >> (this->page_shift + 1)) & this->page_mask;
857 blockpage = (block << 7) | page;
858
859 return blockpage;
860 }
861
862 /**
863 * onenand_check_bufferram - [GENERIC] Check BufferRAM information
864 * @param mtd MTD data structure
865 * @param addr address to check
866 * @return 1 if there are valid data, otherwise 0
867 *
868 * Check bufferram if there is data we required
869 */
870 static int onenand_check_bufferram(struct mtd_info *mtd, loff_t addr)
871 {
872 struct onenand_chip *this = mtd->priv;
873 int blockpage, found = 0;
874 unsigned int i;
875
876 if (ONENAND_IS_2PLANE(this))
877 blockpage = onenand_get_2x_blockpage(mtd, addr);
878 else
879 blockpage = (int) (addr >> this->page_shift);
880
881 /* Is there valid data? */
882 i = ONENAND_CURRENT_BUFFERRAM(this);
883 if (this->bufferram[i].blockpage == blockpage)
884 found = 1;
885 else {
886 /* Check another BufferRAM */
887 i = ONENAND_NEXT_BUFFERRAM(this);
888 if (this->bufferram[i].blockpage == blockpage) {
889 ONENAND_SET_NEXT_BUFFERRAM(this);
890 found = 1;
891 }
892 }
893
894 if (found && ONENAND_IS_DDP(this)) {
895 /* Select DataRAM for DDP */
896 int block = onenand_block(this, addr);
897 int value = onenand_bufferram_address(this, block);
898 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
899 }
900
901 return found;
902 }
903
904 /**
905 * onenand_update_bufferram - [GENERIC] Update BufferRAM information
906 * @param mtd MTD data structure
907 * @param addr address to update
908 * @param valid valid flag
909 *
910 * Update BufferRAM information
911 */
912 static void onenand_update_bufferram(struct mtd_info *mtd, loff_t addr,
913 int valid)
914 {
915 struct onenand_chip *this = mtd->priv;
916 int blockpage;
917 unsigned int i;
918
919 if (ONENAND_IS_2PLANE(this))
920 blockpage = onenand_get_2x_blockpage(mtd, addr);
921 else
922 blockpage = (int) (addr >> this->page_shift);
923
924 /* Invalidate another BufferRAM */
925 i = ONENAND_NEXT_BUFFERRAM(this);
926 if (this->bufferram[i].blockpage == blockpage)
927 this->bufferram[i].blockpage = -1;
928
929 /* Update BufferRAM */
930 i = ONENAND_CURRENT_BUFFERRAM(this);
931 if (valid)
932 this->bufferram[i].blockpage = blockpage;
933 else
934 this->bufferram[i].blockpage = -1;
935 }
936
937 /**
938 * onenand_invalidate_bufferram - [GENERIC] Invalidate BufferRAM information
939 * @param mtd MTD data structure
940 * @param addr start address to invalidate
941 * @param len length to invalidate
942 *
943 * Invalidate BufferRAM information
944 */
945 static void onenand_invalidate_bufferram(struct mtd_info *mtd, loff_t addr,
946 unsigned int len)
947 {
948 struct onenand_chip *this = mtd->priv;
949 int i;
950 loff_t end_addr = addr + len;
951
952 /* Invalidate BufferRAM */
953 for (i = 0; i < MAX_BUFFERRAM; i++) {
954 loff_t buf_addr = this->bufferram[i].blockpage << this->page_shift;
955 if (buf_addr >= addr && buf_addr < end_addr)
956 this->bufferram[i].blockpage = -1;
957 }
958 }
959
960 /**
961 * onenand_get_device - [GENERIC] Get chip for selected access
962 * @param mtd MTD device structure
963 * @param new_state the state which is requested
964 *
965 * Get the device and lock it for exclusive access
966 */
967 static int onenand_get_device(struct mtd_info *mtd, int new_state)
968 {
969 struct onenand_chip *this = mtd->priv;
970 DECLARE_WAITQUEUE(wait, current);
971
972 /*
973 * Grab the lock and see if the device is available
974 */
975 while (1) {
976 spin_lock(&this->chip_lock);
977 if (this->state == FL_READY) {
978 this->state = new_state;
979 spin_unlock(&this->chip_lock);
980 if (new_state != FL_PM_SUSPENDED && this->enable)
981 this->enable(mtd);
982 break;
983 }
984 if (new_state == FL_PM_SUSPENDED) {
985 spin_unlock(&this->chip_lock);
986 return (this->state == FL_PM_SUSPENDED) ? 0 : -EAGAIN;
987 }
988 set_current_state(TASK_UNINTERRUPTIBLE);
989 add_wait_queue(&this->wq, &wait);
990 spin_unlock(&this->chip_lock);
991 schedule();
992 remove_wait_queue(&this->wq, &wait);
993 }
994
995 return 0;
996 }
997
998 /**
999 * onenand_release_device - [GENERIC] release chip
1000 * @param mtd MTD device structure
1001 *
1002 * Deselect, release chip lock and wake up anyone waiting on the device
1003 */
1004 static void onenand_release_device(struct mtd_info *mtd)
1005 {
1006 struct onenand_chip *this = mtd->priv;
1007
1008 if (this->state != FL_PM_SUSPENDED && this->disable)
1009 this->disable(mtd);
1010 /* Release the chip */
1011 spin_lock(&this->chip_lock);
1012 this->state = FL_READY;
1013 wake_up(&this->wq);
1014 spin_unlock(&this->chip_lock);
1015 }
1016
1017 /**
1018 * onenand_transfer_auto_oob - [INTERN] oob auto-placement transfer
1019 * @param mtd MTD device structure
1020 * @param buf destination address
1021 * @param column oob offset to read from
1022 * @param thislen oob length to read
1023 */
1024 static int onenand_transfer_auto_oob(struct mtd_info *mtd, uint8_t *buf, int column,
1025 int thislen)
1026 {
1027 struct onenand_chip *this = mtd->priv;
1028 struct nand_oobfree *free;
1029 int readcol = column;
1030 int readend = column + thislen;
1031 int lastgap = 0;
1032 unsigned int i;
1033 uint8_t *oob_buf = this->oob_buf;
1034
1035 free = this->ecclayout->oobfree;
1036 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
1037 if (readcol >= lastgap)
1038 readcol += free->offset - lastgap;
1039 if (readend >= lastgap)
1040 readend += free->offset - lastgap;
1041 lastgap = free->offset + free->length;
1042 }
1043 this->read_bufferram(mtd, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize);
1044 free = this->ecclayout->oobfree;
1045 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
1046 int free_end = free->offset + free->length;
1047 if (free->offset < readend && free_end > readcol) {
1048 int st = max_t(int,free->offset,readcol);
1049 int ed = min_t(int,free_end,readend);
1050 int n = ed - st;
1051 memcpy(buf, oob_buf + st, n);
1052 buf += n;
1053 } else if (column == 0)
1054 break;
1055 }
1056 return 0;
1057 }
1058
1059 /**
1060 * onenand_recover_lsb - [Flex-OneNAND] Recover LSB page data
1061 * @param mtd MTD device structure
1062 * @param addr address to recover
1063 * @param status return value from onenand_wait / onenand_bbt_wait
1064 *
1065 * MLC NAND Flash cell has paired pages - LSB page and MSB page. LSB page has
1066 * lower page address and MSB page has higher page address in paired pages.
1067 * If power off occurs during MSB page program, the paired LSB page data can
1068 * become corrupt. LSB page recovery read is a way to read LSB page though page
1069 * data are corrupted. When uncorrectable error occurs as a result of LSB page
1070 * read after power up, issue LSB page recovery read.
1071 */
1072 static int onenand_recover_lsb(struct mtd_info *mtd, loff_t addr, int status)
1073 {
1074 struct onenand_chip *this = mtd->priv;
1075 int i;
1076
1077 /* Recovery is only for Flex-OneNAND */
1078 if (!FLEXONENAND(this))
1079 return status;
1080
1081 /* check if we failed due to uncorrectable error */
1082 if (!mtd_is_eccerr(status) && status != ONENAND_BBT_READ_ECC_ERROR)
1083 return status;
1084
1085 /* check if address lies in MLC region */
1086 i = flexonenand_region(mtd, addr);
1087 if (mtd->eraseregions[i].erasesize < (1 << this->erase_shift))
1088 return status;
1089
1090 /* We are attempting to reread, so decrement stats.failed
1091 * which was incremented by onenand_wait due to read failure
1092 */
1093 printk(KERN_INFO "%s: Attempting to recover from uncorrectable read\n",
1094 __func__);
1095 mtd->ecc_stats.failed--;
1096
1097 /* Issue the LSB page recovery command */
1098 this->command(mtd, FLEXONENAND_CMD_RECOVER_LSB, addr, this->writesize);
1099 return this->wait(mtd, FL_READING);
1100 }
1101
1102 /**
1103 * onenand_mlc_read_ops_nolock - MLC OneNAND read main and/or out-of-band
1104 * @param mtd MTD device structure
1105 * @param from offset to read from
1106 * @param ops: oob operation description structure
1107 *
1108 * MLC OneNAND / Flex-OneNAND has 4KB page size and 4KB dataram.
1109 * So, read-while-load is not present.
1110 */
1111 static int onenand_mlc_read_ops_nolock(struct mtd_info *mtd, loff_t from,
1112 struct mtd_oob_ops *ops)
1113 {
1114 struct onenand_chip *this = mtd->priv;
1115 struct mtd_ecc_stats stats;
1116 size_t len = ops->len;
1117 size_t ooblen = ops->ooblen;
1118 u_char *buf = ops->datbuf;
1119 u_char *oobbuf = ops->oobbuf;
1120 int read = 0, column, thislen;
1121 int oobread = 0, oobcolumn, thisooblen, oobsize;
1122 int ret = 0;
1123 int writesize = this->writesize;
1124
1125 pr_debug("%s: from = 0x%08x, len = %i\n", __func__, (unsigned int)from,
1126 (int)len);
1127
1128 if (ops->mode == MTD_OPS_AUTO_OOB)
1129 oobsize = this->ecclayout->oobavail;
1130 else
1131 oobsize = mtd->oobsize;
1132
1133 oobcolumn = from & (mtd->oobsize - 1);
1134
1135 /* Do not allow reads past end of device */
1136 if (from + len > mtd->size) {
1137 printk(KERN_ERR "%s: Attempt read beyond end of device\n",
1138 __func__);
1139 ops->retlen = 0;
1140 ops->oobretlen = 0;
1141 return -EINVAL;
1142 }
1143
1144 stats = mtd->ecc_stats;
1145
1146 while (read < len) {
1147 cond_resched();
1148
1149 thislen = min_t(int, writesize, len - read);
1150
1151 column = from & (writesize - 1);
1152 if (column + thislen > writesize)
1153 thislen = writesize - column;
1154
1155 if (!onenand_check_bufferram(mtd, from)) {
1156 this->command(mtd, ONENAND_CMD_READ, from, writesize);
1157
1158 ret = this->wait(mtd, FL_READING);
1159 if (unlikely(ret))
1160 ret = onenand_recover_lsb(mtd, from, ret);
1161 onenand_update_bufferram(mtd, from, !ret);
1162 if (mtd_is_eccerr(ret))
1163 ret = 0;
1164 if (ret)
1165 break;
1166 }
1167
1168 this->read_bufferram(mtd, ONENAND_DATARAM, buf, column, thislen);
1169 if (oobbuf) {
1170 thisooblen = oobsize - oobcolumn;
1171 thisooblen = min_t(int, thisooblen, ooblen - oobread);
1172
1173 if (ops->mode == MTD_OPS_AUTO_OOB)
1174 onenand_transfer_auto_oob(mtd, oobbuf, oobcolumn, thisooblen);
1175 else
1176 this->read_bufferram(mtd, ONENAND_SPARERAM, oobbuf, oobcolumn, thisooblen);
1177 oobread += thisooblen;
1178 oobbuf += thisooblen;
1179 oobcolumn = 0;
1180 }
1181
1182 read += thislen;
1183 if (read == len)
1184 break;
1185
1186 from += thislen;
1187 buf += thislen;
1188 }
1189
1190 /*
1191 * Return success, if no ECC failures, else -EBADMSG
1192 * fs driver will take care of that, because
1193 * retlen == desired len and result == -EBADMSG
1194 */
1195 ops->retlen = read;
1196 ops->oobretlen = oobread;
1197
1198 if (ret)
1199 return ret;
1200
1201 if (mtd->ecc_stats.failed - stats.failed)
1202 return -EBADMSG;
1203
1204 /* return max bitflips per ecc step; ONENANDs correct 1 bit only */
1205 return mtd->ecc_stats.corrected != stats.corrected ? 1 : 0;
1206 }
1207
1208 /**
1209 * onenand_read_ops_nolock - [OneNAND Interface] OneNAND read main and/or out-of-band
1210 * @param mtd MTD device structure
1211 * @param from offset to read from
1212 * @param ops: oob operation description structure
1213 *
1214 * OneNAND read main and/or out-of-band data
1215 */
1216 static int onenand_read_ops_nolock(struct mtd_info *mtd, loff_t from,
1217 struct mtd_oob_ops *ops)
1218 {
1219 struct onenand_chip *this = mtd->priv;
1220 struct mtd_ecc_stats stats;
1221 size_t len = ops->len;
1222 size_t ooblen = ops->ooblen;
1223 u_char *buf = ops->datbuf;
1224 u_char *oobbuf = ops->oobbuf;
1225 int read = 0, column, thislen;
1226 int oobread = 0, oobcolumn, thisooblen, oobsize;
1227 int ret = 0, boundary = 0;
1228 int writesize = this->writesize;
1229
1230 pr_debug("%s: from = 0x%08x, len = %i\n", __func__, (unsigned int)from,
1231 (int)len);
1232
1233 if (ops->mode == MTD_OPS_AUTO_OOB)
1234 oobsize = this->ecclayout->oobavail;
1235 else
1236 oobsize = mtd->oobsize;
1237
1238 oobcolumn = from & (mtd->oobsize - 1);
1239
1240 /* Do not allow reads past end of device */
1241 if ((from + len) > mtd->size) {
1242 printk(KERN_ERR "%s: Attempt read beyond end of device\n",
1243 __func__);
1244 ops->retlen = 0;
1245 ops->oobretlen = 0;
1246 return -EINVAL;
1247 }
1248
1249 stats = mtd->ecc_stats;
1250
1251 /* Read-while-load method */
1252
1253 /* Do first load to bufferRAM */
1254 if (read < len) {
1255 if (!onenand_check_bufferram(mtd, from)) {
1256 this->command(mtd, ONENAND_CMD_READ, from, writesize);
1257 ret = this->wait(mtd, FL_READING);
1258 onenand_update_bufferram(mtd, from, !ret);
1259 if (mtd_is_eccerr(ret))
1260 ret = 0;
1261 }
1262 }
1263
1264 thislen = min_t(int, writesize, len - read);
1265 column = from & (writesize - 1);
1266 if (column + thislen > writesize)
1267 thislen = writesize - column;
1268
1269 while (!ret) {
1270 /* If there is more to load then start next load */
1271 from += thislen;
1272 if (read + thislen < len) {
1273 this->command(mtd, ONENAND_CMD_READ, from, writesize);
1274 /*
1275 * Chip boundary handling in DDP
1276 * Now we issued chip 1 read and pointed chip 1
1277 * bufferram so we have to point chip 0 bufferram.
1278 */
1279 if (ONENAND_IS_DDP(this) &&
1280 unlikely(from == (this->chipsize >> 1))) {
1281 this->write_word(ONENAND_DDP_CHIP0, this->base + ONENAND_REG_START_ADDRESS2);
1282 boundary = 1;
1283 } else
1284 boundary = 0;
1285 ONENAND_SET_PREV_BUFFERRAM(this);
1286 }
1287 /* While load is going, read from last bufferRAM */
1288 this->read_bufferram(mtd, ONENAND_DATARAM, buf, column, thislen);
1289
1290 /* Read oob area if needed */
1291 if (oobbuf) {
1292 thisooblen = oobsize - oobcolumn;
1293 thisooblen = min_t(int, thisooblen, ooblen - oobread);
1294
1295 if (ops->mode == MTD_OPS_AUTO_OOB)
1296 onenand_transfer_auto_oob(mtd, oobbuf, oobcolumn, thisooblen);
1297 else
1298 this->read_bufferram(mtd, ONENAND_SPARERAM, oobbuf, oobcolumn, thisooblen);
1299 oobread += thisooblen;
1300 oobbuf += thisooblen;
1301 oobcolumn = 0;
1302 }
1303
1304 /* See if we are done */
1305 read += thislen;
1306 if (read == len)
1307 break;
1308 /* Set up for next read from bufferRAM */
1309 if (unlikely(boundary))
1310 this->write_word(ONENAND_DDP_CHIP1, this->base + ONENAND_REG_START_ADDRESS2);
1311 ONENAND_SET_NEXT_BUFFERRAM(this);
1312 buf += thislen;
1313 thislen = min_t(int, writesize, len - read);
1314 column = 0;
1315 cond_resched();
1316 /* Now wait for load */
1317 ret = this->wait(mtd, FL_READING);
1318 onenand_update_bufferram(mtd, from, !ret);
1319 if (mtd_is_eccerr(ret))
1320 ret = 0;
1321 }
1322
1323 /*
1324 * Return success, if no ECC failures, else -EBADMSG
1325 * fs driver will take care of that, because
1326 * retlen == desired len and result == -EBADMSG
1327 */
1328 ops->retlen = read;
1329 ops->oobretlen = oobread;
1330
1331 if (ret)
1332 return ret;
1333
1334 if (mtd->ecc_stats.failed - stats.failed)
1335 return -EBADMSG;
1336
1337 /* return max bitflips per ecc step; ONENANDs correct 1 bit only */
1338 return mtd->ecc_stats.corrected != stats.corrected ? 1 : 0;
1339 }
1340
1341 /**
1342 * onenand_read_oob_nolock - [MTD Interface] OneNAND read out-of-band
1343 * @param mtd MTD device structure
1344 * @param from offset to read from
1345 * @param ops: oob operation description structure
1346 *
1347 * OneNAND read out-of-band data from the spare area
1348 */
1349 static int onenand_read_oob_nolock(struct mtd_info *mtd, loff_t from,
1350 struct mtd_oob_ops *ops)
1351 {
1352 struct onenand_chip *this = mtd->priv;
1353 struct mtd_ecc_stats stats;
1354 int read = 0, thislen, column, oobsize;
1355 size_t len = ops->ooblen;
1356 unsigned int mode = ops->mode;
1357 u_char *buf = ops->oobbuf;
1358 int ret = 0, readcmd;
1359
1360 from += ops->ooboffs;
1361
1362 pr_debug("%s: from = 0x%08x, len = %i\n", __func__, (unsigned int)from,
1363 (int)len);
1364
1365 /* Initialize return length value */
1366 ops->oobretlen = 0;
1367
1368 if (mode == MTD_OPS_AUTO_OOB)
1369 oobsize = this->ecclayout->oobavail;
1370 else
1371 oobsize = mtd->oobsize;
1372
1373 column = from & (mtd->oobsize - 1);
1374
1375 if (unlikely(column >= oobsize)) {
1376 printk(KERN_ERR "%s: Attempted to start read outside oob\n",
1377 __func__);
1378 return -EINVAL;
1379 }
1380
1381 /* Do not allow reads past end of device */
1382 if (unlikely(from >= mtd->size ||
1383 column + len > ((mtd->size >> this->page_shift) -
1384 (from >> this->page_shift)) * oobsize)) {
1385 printk(KERN_ERR "%s: Attempted to read beyond end of device\n",
1386 __func__);
1387 return -EINVAL;
1388 }
1389
1390 stats = mtd->ecc_stats;
1391
1392 readcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1393
1394 while (read < len) {
1395 cond_resched();
1396
1397 thislen = oobsize - column;
1398 thislen = min_t(int, thislen, len);
1399
1400 this->command(mtd, readcmd, from, mtd->oobsize);
1401
1402 onenand_update_bufferram(mtd, from, 0);
1403
1404 ret = this->wait(mtd, FL_READING);
1405 if (unlikely(ret))
1406 ret = onenand_recover_lsb(mtd, from, ret);
1407
1408 if (ret && !mtd_is_eccerr(ret)) {
1409 printk(KERN_ERR "%s: read failed = 0x%x\n",
1410 __func__, ret);
1411 break;
1412 }
1413
1414 if (mode == MTD_OPS_AUTO_OOB)
1415 onenand_transfer_auto_oob(mtd, buf, column, thislen);
1416 else
1417 this->read_bufferram(mtd, ONENAND_SPARERAM, buf, column, thislen);
1418
1419 read += thislen;
1420
1421 if (read == len)
1422 break;
1423
1424 buf += thislen;
1425
1426 /* Read more? */
1427 if (read < len) {
1428 /* Page size */
1429 from += mtd->writesize;
1430 column = 0;
1431 }
1432 }
1433
1434 ops->oobretlen = read;
1435
1436 if (ret)
1437 return ret;
1438
1439 if (mtd->ecc_stats.failed - stats.failed)
1440 return -EBADMSG;
1441
1442 return 0;
1443 }
1444
1445 /**
1446 * onenand_read - [MTD Interface] Read data from flash
1447 * @param mtd MTD device structure
1448 * @param from offset to read from
1449 * @param len number of bytes to read
1450 * @param retlen pointer to variable to store the number of read bytes
1451 * @param buf the databuffer to put data
1452 *
1453 * Read with ecc
1454 */
1455 static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
1456 size_t *retlen, u_char *buf)
1457 {
1458 struct onenand_chip *this = mtd->priv;
1459 struct mtd_oob_ops ops = {
1460 .len = len,
1461 .ooblen = 0,
1462 .datbuf = buf,
1463 .oobbuf = NULL,
1464 };
1465 int ret;
1466
1467 onenand_get_device(mtd, FL_READING);
1468 ret = ONENAND_IS_4KB_PAGE(this) ?
1469 onenand_mlc_read_ops_nolock(mtd, from, &ops) :
1470 onenand_read_ops_nolock(mtd, from, &ops);
1471 onenand_release_device(mtd);
1472
1473 *retlen = ops.retlen;
1474 return ret;
1475 }
1476
1477 /**
1478 * onenand_read_oob - [MTD Interface] Read main and/or out-of-band
1479 * @param mtd: MTD device structure
1480 * @param from: offset to read from
1481 * @param ops: oob operation description structure
1482
1483 * Read main and/or out-of-band
1484 */
1485 static int onenand_read_oob(struct mtd_info *mtd, loff_t from,
1486 struct mtd_oob_ops *ops)
1487 {
1488 struct onenand_chip *this = mtd->priv;
1489 int ret;
1490
1491 switch (ops->mode) {
1492 case MTD_OPS_PLACE_OOB:
1493 case MTD_OPS_AUTO_OOB:
1494 break;
1495 case MTD_OPS_RAW:
1496 /* Not implemented yet */
1497 default:
1498 return -EINVAL;
1499 }
1500
1501 onenand_get_device(mtd, FL_READING);
1502 if (ops->datbuf)
1503 ret = ONENAND_IS_4KB_PAGE(this) ?
1504 onenand_mlc_read_ops_nolock(mtd, from, ops) :
1505 onenand_read_ops_nolock(mtd, from, ops);
1506 else
1507 ret = onenand_read_oob_nolock(mtd, from, ops);
1508 onenand_release_device(mtd);
1509
1510 return ret;
1511 }
1512
1513 /**
1514 * onenand_bbt_wait - [DEFAULT] wait until the command is done
1515 * @param mtd MTD device structure
1516 * @param state state to select the max. timeout value
1517 *
1518 * Wait for command done.
1519 */
1520 static int onenand_bbt_wait(struct mtd_info *mtd, int state)
1521 {
1522 struct onenand_chip *this = mtd->priv;
1523 unsigned long timeout;
1524 unsigned int interrupt, ctrl, ecc, addr1, addr8;
1525
1526 /* The 20 msec is enough */
1527 timeout = jiffies + msecs_to_jiffies(20);
1528 while (time_before(jiffies, timeout)) {
1529 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1530 if (interrupt & ONENAND_INT_MASTER)
1531 break;
1532 }
1533 /* To get correct interrupt status in timeout case */
1534 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1535 ctrl = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
1536 addr1 = this->read_word(this->base + ONENAND_REG_START_ADDRESS1);
1537 addr8 = this->read_word(this->base + ONENAND_REG_START_ADDRESS8);
1538
1539 if (interrupt & ONENAND_INT_READ) {
1540 ecc = onenand_read_ecc(this);
1541 if (ecc & ONENAND_ECC_2BIT_ALL) {
1542 printk(KERN_DEBUG "%s: ecc 0x%04x ctrl 0x%04x "
1543 "intr 0x%04x addr1 %#x addr8 %#x\n",
1544 __func__, ecc, ctrl, interrupt, addr1, addr8);
1545 return ONENAND_BBT_READ_ECC_ERROR;
1546 }
1547 } else {
1548 printk(KERN_ERR "%s: read timeout! ctrl 0x%04x "
1549 "intr 0x%04x addr1 %#x addr8 %#x\n",
1550 __func__, ctrl, interrupt, addr1, addr8);
1551 return ONENAND_BBT_READ_FATAL_ERROR;
1552 }
1553
1554 /* Initial bad block case: 0x2400 or 0x0400 */
1555 if (ctrl & ONENAND_CTRL_ERROR) {
1556 printk(KERN_DEBUG "%s: ctrl 0x%04x intr 0x%04x addr1 %#x "
1557 "addr8 %#x\n", __func__, ctrl, interrupt, addr1, addr8);
1558 return ONENAND_BBT_READ_ERROR;
1559 }
1560
1561 return 0;
1562 }
1563
1564 /**
1565 * onenand_bbt_read_oob - [MTD Interface] OneNAND read out-of-band for bbt scan
1566 * @param mtd MTD device structure
1567 * @param from offset to read from
1568 * @param ops oob operation description structure
1569 *
1570 * OneNAND read out-of-band data from the spare area for bbt scan
1571 */
1572 int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from,
1573 struct mtd_oob_ops *ops)
1574 {
1575 struct onenand_chip *this = mtd->priv;
1576 int read = 0, thislen, column;
1577 int ret = 0, readcmd;
1578 size_t len = ops->ooblen;
1579 u_char *buf = ops->oobbuf;
1580
1581 pr_debug("%s: from = 0x%08x, len = %zi\n", __func__, (unsigned int)from,
1582 len);
1583
1584 /* Initialize return value */
1585 ops->oobretlen = 0;
1586
1587 /* Do not allow reads past end of device */
1588 if (unlikely((from + len) > mtd->size)) {
1589 printk(KERN_ERR "%s: Attempt read beyond end of device\n",
1590 __func__);
1591 return ONENAND_BBT_READ_FATAL_ERROR;
1592 }
1593
1594 /* Grab the lock and see if the device is available */
1595 onenand_get_device(mtd, FL_READING);
1596
1597 column = from & (mtd->oobsize - 1);
1598
1599 readcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1600
1601 while (read < len) {
1602 cond_resched();
1603
1604 thislen = mtd->oobsize - column;
1605 thislen = min_t(int, thislen, len);
1606
1607 this->command(mtd, readcmd, from, mtd->oobsize);
1608
1609 onenand_update_bufferram(mtd, from, 0);
1610
1611 ret = this->bbt_wait(mtd, FL_READING);
1612 if (unlikely(ret))
1613 ret = onenand_recover_lsb(mtd, from, ret);
1614
1615 if (ret)
1616 break;
1617
1618 this->read_bufferram(mtd, ONENAND_SPARERAM, buf, column, thislen);
1619 read += thislen;
1620 if (read == len)
1621 break;
1622
1623 buf += thislen;
1624
1625 /* Read more? */
1626 if (read < len) {
1627 /* Update Page size */
1628 from += this->writesize;
1629 column = 0;
1630 }
1631 }
1632
1633 /* Deselect and wake up anyone waiting on the device */
1634 onenand_release_device(mtd);
1635
1636 ops->oobretlen = read;
1637 return ret;
1638 }
1639
1640 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
1641 /**
1642 * onenand_verify_oob - [GENERIC] verify the oob contents after a write
1643 * @param mtd MTD device structure
1644 * @param buf the databuffer to verify
1645 * @param to offset to read from
1646 */
1647 static int onenand_verify_oob(struct mtd_info *mtd, const u_char *buf, loff_t to)
1648 {
1649 struct onenand_chip *this = mtd->priv;
1650 u_char *oob_buf = this->oob_buf;
1651 int status, i, readcmd;
1652
1653 readcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1654
1655 this->command(mtd, readcmd, to, mtd->oobsize);
1656 onenand_update_bufferram(mtd, to, 0);
1657 status = this->wait(mtd, FL_READING);
1658 if (status)
1659 return status;
1660
1661 this->read_bufferram(mtd, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize);
1662 for (i = 0; i < mtd->oobsize; i++)
1663 if (buf[i] != 0xFF && buf[i] != oob_buf[i])
1664 return -EBADMSG;
1665
1666 return 0;
1667 }
1668
1669 /**
1670 * onenand_verify - [GENERIC] verify the chip contents after a write
1671 * @param mtd MTD device structure
1672 * @param buf the databuffer to verify
1673 * @param addr offset to read from
1674 * @param len number of bytes to read and compare
1675 */
1676 static int onenand_verify(struct mtd_info *mtd, const u_char *buf, loff_t addr, size_t len)
1677 {
1678 struct onenand_chip *this = mtd->priv;
1679 int ret = 0;
1680 int thislen, column;
1681
1682 column = addr & (this->writesize - 1);
1683
1684 while (len != 0) {
1685 thislen = min_t(int, this->writesize - column, len);
1686
1687 this->command(mtd, ONENAND_CMD_READ, addr, this->writesize);
1688
1689 onenand_update_bufferram(mtd, addr, 0);
1690
1691 ret = this->wait(mtd, FL_READING);
1692 if (ret)
1693 return ret;
1694
1695 onenand_update_bufferram(mtd, addr, 1);
1696
1697 this->read_bufferram(mtd, ONENAND_DATARAM, this->verify_buf, 0, mtd->writesize);
1698
1699 if (memcmp(buf, this->verify_buf + column, thislen))
1700 return -EBADMSG;
1701
1702 len -= thislen;
1703 buf += thislen;
1704 addr += thislen;
1705 column = 0;
1706 }
1707
1708 return 0;
1709 }
1710 #else
1711 #define onenand_verify(...) (0)
1712 #define onenand_verify_oob(...) (0)
1713 #endif
1714
1715 #define NOTALIGNED(x) ((x & (this->subpagesize - 1)) != 0)
1716
1717 static void onenand_panic_wait(struct mtd_info *mtd)
1718 {
1719 struct onenand_chip *this = mtd->priv;
1720 unsigned int interrupt;
1721 int i;
1722
1723 for (i = 0; i < 2000; i++) {
1724 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1725 if (interrupt & ONENAND_INT_MASTER)
1726 break;
1727 udelay(10);
1728 }
1729 }
1730
1731 /**
1732 * onenand_panic_write - [MTD Interface] write buffer to FLASH in a panic context
1733 * @param mtd MTD device structure
1734 * @param to offset to write to
1735 * @param len number of bytes to write
1736 * @param retlen pointer to variable to store the number of written bytes
1737 * @param buf the data to write
1738 *
1739 * Write with ECC
1740 */
1741 static int onenand_panic_write(struct mtd_info *mtd, loff_t to, size_t len,
1742 size_t *retlen, const u_char *buf)
1743 {
1744 struct onenand_chip *this = mtd->priv;
1745 int column, subpage;
1746 int written = 0;
1747 int ret = 0;
1748
1749 if (this->state == FL_PM_SUSPENDED)
1750 return -EBUSY;
1751
1752 /* Wait for any existing operation to clear */
1753 onenand_panic_wait(mtd);
1754
1755 pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsigned int)to,
1756 (int)len);
1757
1758 /* Reject writes, which are not page aligned */
1759 if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) {
1760 printk(KERN_ERR "%s: Attempt to write not page aligned data\n",
1761 __func__);
1762 return -EINVAL;
1763 }
1764
1765 column = to & (mtd->writesize - 1);
1766
1767 /* Loop until all data write */
1768 while (written < len) {
1769 int thislen = min_t(int, mtd->writesize - column, len - written);
1770 u_char *wbuf = (u_char *) buf;
1771
1772 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
1773
1774 /* Partial page write */
1775 subpage = thislen < mtd->writesize;
1776 if (subpage) {
1777 memset(this->page_buf, 0xff, mtd->writesize);
1778 memcpy(this->page_buf + column, buf, thislen);
1779 wbuf = this->page_buf;
1780 }
1781
1782 this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
1783 this->write_bufferram(mtd, ONENAND_SPARERAM, ffchars, 0, mtd->oobsize);
1784
1785 this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
1786
1787 onenand_panic_wait(mtd);
1788
1789 /* In partial page write we don't update bufferram */
1790 onenand_update_bufferram(mtd, to, !ret && !subpage);
1791 if (ONENAND_IS_2PLANE(this)) {
1792 ONENAND_SET_BUFFERRAM1(this);
1793 onenand_update_bufferram(mtd, to + this->writesize, !ret && !subpage);
1794 }
1795
1796 if (ret) {
1797 printk(KERN_ERR "%s: write failed %d\n", __func__, ret);
1798 break;
1799 }
1800
1801 written += thislen;
1802
1803 if (written == len)
1804 break;
1805
1806 column = 0;
1807 to += thislen;
1808 buf += thislen;
1809 }
1810
1811 *retlen = written;
1812 return ret;
1813 }
1814
1815 /**
1816 * onenand_fill_auto_oob - [INTERN] oob auto-placement transfer
1817 * @param mtd MTD device structure
1818 * @param oob_buf oob buffer
1819 * @param buf source address
1820 * @param column oob offset to write to
1821 * @param thislen oob length to write
1822 */
1823 static int onenand_fill_auto_oob(struct mtd_info *mtd, u_char *oob_buf,
1824 const u_char *buf, int column, int thislen)
1825 {
1826 struct onenand_chip *this = mtd->priv;
1827 struct nand_oobfree *free;
1828 int writecol = column;
1829 int writeend = column + thislen;
1830 int lastgap = 0;
1831 unsigned int i;
1832
1833 free = this->ecclayout->oobfree;
1834 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
1835 if (writecol >= lastgap)
1836 writecol += free->offset - lastgap;
1837 if (writeend >= lastgap)
1838 writeend += free->offset - lastgap;
1839 lastgap = free->offset + free->length;
1840 }
1841 free = this->ecclayout->oobfree;
1842 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
1843 int free_end = free->offset + free->length;
1844 if (free->offset < writeend && free_end > writecol) {
1845 int st = max_t(int,free->offset,writecol);
1846 int ed = min_t(int,free_end,writeend);
1847 int n = ed - st;
1848 memcpy(oob_buf + st, buf, n);
1849 buf += n;
1850 } else if (column == 0)
1851 break;
1852 }
1853 return 0;
1854 }
1855
1856 /**
1857 * onenand_write_ops_nolock - [OneNAND Interface] write main and/or out-of-band
1858 * @param mtd MTD device structure
1859 * @param to offset to write to
1860 * @param ops oob operation description structure
1861 *
1862 * Write main and/or oob with ECC
1863 */
1864 static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
1865 struct mtd_oob_ops *ops)
1866 {
1867 struct onenand_chip *this = mtd->priv;
1868 int written = 0, column, thislen = 0, subpage = 0;
1869 int prev = 0, prevlen = 0, prev_subpage = 0, first = 1;
1870 int oobwritten = 0, oobcolumn, thisooblen, oobsize;
1871 size_t len = ops->len;
1872 size_t ooblen = ops->ooblen;
1873 const u_char *buf = ops->datbuf;
1874 const u_char *oob = ops->oobbuf;
1875 u_char *oobbuf;
1876 int ret = 0, cmd;
1877
1878 pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsigned int)to,
1879 (int)len);
1880
1881 /* Initialize retlen, in case of early exit */
1882 ops->retlen = 0;
1883 ops->oobretlen = 0;
1884
1885 /* Reject writes, which are not page aligned */
1886 if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) {
1887 printk(KERN_ERR "%s: Attempt to write not page aligned data\n",
1888 __func__);
1889 return -EINVAL;
1890 }
1891
1892 /* Check zero length */
1893 if (!len)
1894 return 0;
1895
1896 if (ops->mode == MTD_OPS_AUTO_OOB)
1897 oobsize = this->ecclayout->oobavail;
1898 else
1899 oobsize = mtd->oobsize;
1900
1901 oobcolumn = to & (mtd->oobsize - 1);
1902
1903 column = to & (mtd->writesize - 1);
1904
1905 /* Loop until all data write */
1906 while (1) {
1907 if (written < len) {
1908 u_char *wbuf = (u_char *) buf;
1909
1910 thislen = min_t(int, mtd->writesize - column, len - written);
1911 thisooblen = min_t(int, oobsize - oobcolumn, ooblen - oobwritten);
1912
1913 cond_resched();
1914
1915 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
1916
1917 /* Partial page write */
1918 subpage = thislen < mtd->writesize;
1919 if (subpage) {
1920 memset(this->page_buf, 0xff, mtd->writesize);
1921 memcpy(this->page_buf + column, buf, thislen);
1922 wbuf = this->page_buf;
1923 }
1924
1925 this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
1926
1927 if (oob) {
1928 oobbuf = this->oob_buf;
1929
1930 /* We send data to spare ram with oobsize
1931 * to prevent byte access */
1932 memset(oobbuf, 0xff, mtd->oobsize);
1933 if (ops->mode == MTD_OPS_AUTO_OOB)
1934 onenand_fill_auto_oob(mtd, oobbuf, oob, oobcolumn, thisooblen);
1935 else
1936 memcpy(oobbuf + oobcolumn, oob, thisooblen);
1937
1938 oobwritten += thisooblen;
1939 oob += thisooblen;
1940 oobcolumn = 0;
1941 } else
1942 oobbuf = (u_char *) ffchars;
1943
1944 this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
1945 } else
1946 ONENAND_SET_NEXT_BUFFERRAM(this);
1947
1948 /*
1949 * 2 PLANE, MLC, and Flex-OneNAND do not support
1950 * write-while-program feature.
1951 */
1952 if (!ONENAND_IS_2PLANE(this) && !ONENAND_IS_4KB_PAGE(this) && !first) {
1953 ONENAND_SET_PREV_BUFFERRAM(this);
1954
1955 ret = this->wait(mtd, FL_WRITING);
1956
1957 /* In partial page write we don't update bufferram */
1958 onenand_update_bufferram(mtd, prev, !ret && !prev_subpage);
1959 if (ret) {
1960 written -= prevlen;
1961 printk(KERN_ERR "%s: write failed %d\n",
1962 __func__, ret);
1963 break;
1964 }
1965
1966 if (written == len) {
1967 /* Only check verify write turn on */
1968 ret = onenand_verify(mtd, buf - len, to - len, len);
1969 if (ret)
1970 printk(KERN_ERR "%s: verify failed %d\n",
1971 __func__, ret);
1972 break;
1973 }
1974
1975 ONENAND_SET_NEXT_BUFFERRAM(this);
1976 }
1977
1978 this->ongoing = 0;
1979 cmd = ONENAND_CMD_PROG;
1980
1981 /* Exclude 1st OTP and OTP blocks for cache program feature */
1982 if (ONENAND_IS_CACHE_PROGRAM(this) &&
1983 likely(onenand_block(this, to) != 0) &&
1984 ONENAND_IS_4KB_PAGE(this) &&
1985 ((written + thislen) < len)) {
1986 cmd = ONENAND_CMD_2X_CACHE_PROG;
1987 this->ongoing = 1;
1988 }
1989
1990 this->command(mtd, cmd, to, mtd->writesize);
1991
1992 /*
1993 * 2 PLANE, MLC, and Flex-OneNAND wait here
1994 */
1995 if (ONENAND_IS_2PLANE(this) || ONENAND_IS_4KB_PAGE(this)) {
1996 ret = this->wait(mtd, FL_WRITING);
1997
1998 /* In partial page write we don't update bufferram */
1999 onenand_update_bufferram(mtd, to, !ret && !subpage);
2000 if (ret) {
2001 printk(KERN_ERR "%s: write failed %d\n",
2002 __func__, ret);
2003 break;
2004 }
2005
2006 /* Only check verify write turn on */
2007 ret = onenand_verify(mtd, buf, to, thislen);
2008 if (ret) {
2009 printk(KERN_ERR "%s: verify failed %d\n",
2010 __func__, ret);
2011 break;
2012 }
2013
2014 written += thislen;
2015
2016 if (written == len)
2017 break;
2018
2019 } else
2020 written += thislen;
2021
2022 column = 0;
2023 prev_subpage = subpage;
2024 prev = to;
2025 prevlen = thislen;
2026 to += thislen;
2027 buf += thislen;
2028 first = 0;
2029 }
2030
2031 /* In error case, clear all bufferrams */
2032 if (written != len)
2033 onenand_invalidate_bufferram(mtd, 0, -1);
2034
2035 ops->retlen = written;
2036 ops->oobretlen = oobwritten;
2037
2038 return ret;
2039 }
2040
2041
2042 /**
2043 * onenand_write_oob_nolock - [INTERN] OneNAND write out-of-band
2044 * @param mtd MTD device structure
2045 * @param to offset to write to
2046 * @param len number of bytes to write
2047 * @param retlen pointer to variable to store the number of written bytes
2048 * @param buf the data to write
2049 * @param mode operation mode
2050 *
2051 * OneNAND write out-of-band
2052 */
2053 static int onenand_write_oob_nolock(struct mtd_info *mtd, loff_t to,
2054 struct mtd_oob_ops *ops)
2055 {
2056 struct onenand_chip *this = mtd->priv;
2057 int column, ret = 0, oobsize;
2058 int written = 0, oobcmd;
2059 u_char *oobbuf;
2060 size_t len = ops->ooblen;
2061 const u_char *buf = ops->oobbuf;
2062 unsigned int mode = ops->mode;
2063
2064 to += ops->ooboffs;
2065
2066 pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsigned int)to,
2067 (int)len);
2068
2069 /* Initialize retlen, in case of early exit */
2070 ops->oobretlen = 0;
2071
2072 if (mode == MTD_OPS_AUTO_OOB)
2073 oobsize = this->ecclayout->oobavail;
2074 else
2075 oobsize = mtd->oobsize;
2076
2077 column = to & (mtd->oobsize - 1);
2078
2079 if (unlikely(column >= oobsize)) {
2080 printk(KERN_ERR "%s: Attempted to start write outside oob\n",
2081 __func__);
2082 return -EINVAL;
2083 }
2084
2085 /* For compatibility with NAND: Do not allow write past end of page */
2086 if (unlikely(column + len > oobsize)) {
2087 printk(KERN_ERR "%s: Attempt to write past end of page\n",
2088 __func__);
2089 return -EINVAL;
2090 }
2091
2092 /* Do not allow reads past end of device */
2093 if (unlikely(to >= mtd->size ||
2094 column + len > ((mtd->size >> this->page_shift) -
2095 (to >> this->page_shift)) * oobsize)) {
2096 printk(KERN_ERR "%s: Attempted to write past end of device\n",
2097 __func__);
2098 return -EINVAL;
2099 }
2100
2101 oobbuf = this->oob_buf;
2102
2103 oobcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_PROG : ONENAND_CMD_PROGOOB;
2104
2105 /* Loop until all data write */
2106 while (written < len) {
2107 int thislen = min_t(int, oobsize, len - written);
2108
2109 cond_resched();
2110
2111 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, mtd->oobsize);
2112
2113 /* We send data to spare ram with oobsize
2114 * to prevent byte access */
2115 memset(oobbuf, 0xff, mtd->oobsize);
2116 if (mode == MTD_OPS_AUTO_OOB)
2117 onenand_fill_auto_oob(mtd, oobbuf, buf, column, thislen);
2118 else
2119 memcpy(oobbuf + column, buf, thislen);
2120 this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
2121
2122 if (ONENAND_IS_4KB_PAGE(this)) {
2123 /* Set main area of DataRAM to 0xff*/
2124 memset(this->page_buf, 0xff, mtd->writesize);
2125 this->write_bufferram(mtd, ONENAND_DATARAM,
2126 this->page_buf, 0, mtd->writesize);
2127 }
2128
2129 this->command(mtd, oobcmd, to, mtd->oobsize);
2130
2131 onenand_update_bufferram(mtd, to, 0);
2132 if (ONENAND_IS_2PLANE(this)) {
2133 ONENAND_SET_BUFFERRAM1(this);
2134 onenand_update_bufferram(mtd, to + this->writesize, 0);
2135 }
2136
2137 ret = this->wait(mtd, FL_WRITING);
2138 if (ret) {
2139 printk(KERN_ERR "%s: write failed %d\n", __func__, ret);
2140 break;
2141 }
2142
2143 ret = onenand_verify_oob(mtd, oobbuf, to);
2144 if (ret) {
2145 printk(KERN_ERR "%s: verify failed %d\n",
2146 __func__, ret);
2147 break;
2148 }
2149
2150 written += thislen;
2151 if (written == len)
2152 break;
2153
2154 to += mtd->writesize;
2155 buf += thislen;
2156 column = 0;
2157 }
2158
2159 ops->oobretlen = written;
2160
2161 return ret;
2162 }
2163
2164 /**
2165 * onenand_write - [MTD Interface] write buffer to FLASH
2166 * @param mtd MTD device structure
2167 * @param to offset to write to
2168 * @param len number of bytes to write
2169 * @param retlen pointer to variable to store the number of written bytes
2170 * @param buf the data to write
2171 *
2172 * Write with ECC
2173 */
2174 static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
2175 size_t *retlen, const u_char *buf)
2176 {
2177 struct mtd_oob_ops ops = {
2178 .len = len,
2179 .ooblen = 0,
2180 .datbuf = (u_char *) buf,
2181 .oobbuf = NULL,
2182 };
2183 int ret;
2184
2185 onenand_get_device(mtd, FL_WRITING);
2186 ret = onenand_write_ops_nolock(mtd, to, &ops);
2187 onenand_release_device(mtd);
2188
2189 *retlen = ops.retlen;
2190 return ret;
2191 }
2192
2193 /**
2194 * onenand_write_oob - [MTD Interface] NAND write data and/or out-of-band
2195 * @param mtd: MTD device structure
2196 * @param to: offset to write
2197 * @param ops: oob operation description structure
2198 */
2199 static int onenand_write_oob(struct mtd_info *mtd, loff_t to,
2200 struct mtd_oob_ops *ops)
2201 {
2202 int ret;
2203
2204 switch (ops->mode) {
2205 case MTD_OPS_PLACE_OOB:
2206 case MTD_OPS_AUTO_OOB:
2207 break;
2208 case MTD_OPS_RAW:
2209 /* Not implemented yet */
2210 default:
2211 return -EINVAL;
2212 }
2213
2214 onenand_get_device(mtd, FL_WRITING);
2215 if (ops->datbuf)
2216 ret = onenand_write_ops_nolock(mtd, to, ops);
2217 else
2218 ret = onenand_write_oob_nolock(mtd, to, ops);
2219 onenand_release_device(mtd);
2220
2221 return ret;
2222 }
2223
2224 /**
2225 * onenand_block_isbad_nolock - [GENERIC] Check if a block is marked bad
2226 * @param mtd MTD device structure
2227 * @param ofs offset from device start
2228 * @param allowbbt 1, if its allowed to access the bbt area
2229 *
2230 * Check, if the block is bad. Either by reading the bad block table or
2231 * calling of the scan function.
2232 */
2233 static int onenand_block_isbad_nolock(struct mtd_info *mtd, loff_t ofs, int allowbbt)
2234 {
2235 struct onenand_chip *this = mtd->priv;
2236 struct bbm_info *bbm = this->bbm;
2237
2238 /* Return info from the table */
2239 return bbm->isbad_bbt(mtd, ofs, allowbbt);
2240 }
2241
2242
2243 static int onenand_multiblock_erase_verify(struct mtd_info *mtd,
2244 struct erase_info *instr)
2245 {
2246 struct onenand_chip *this = mtd->priv;
2247 loff_t addr = instr->addr;
2248 int len = instr->len;
2249 unsigned int block_size = (1 << this->erase_shift);
2250 int ret = 0;
2251
2252 while (len) {
2253 this->command(mtd, ONENAND_CMD_ERASE_VERIFY, addr, block_size);
2254 ret = this->wait(mtd, FL_VERIFYING_ERASE);
2255 if (ret) {
2256 printk(KERN_ERR "%s: Failed verify, block %d\n",
2257 __func__, onenand_block(this, addr));
2258 instr->state = MTD_ERASE_FAILED;
2259 instr->fail_addr = addr;
2260 return -1;
2261 }
2262 len -= block_size;
2263 addr += block_size;
2264 }
2265 return 0;
2266 }
2267
2268 /**
2269 * onenand_multiblock_erase - [INTERN] erase block(s) using multiblock erase
2270 * @param mtd MTD device structure
2271 * @param instr erase instruction
2272 * @param region erase region
2273 *
2274 * Erase one or more blocks up to 64 block at a time
2275 */
2276 static int onenand_multiblock_erase(struct mtd_info *mtd,
2277 struct erase_info *instr,
2278 unsigned int block_size)
2279 {
2280 struct onenand_chip *this = mtd->priv;
2281 loff_t addr = instr->addr;
2282 int len = instr->len;
2283 int eb_count = 0;
2284 int ret = 0;
2285 int bdry_block = 0;
2286
2287 instr->state = MTD_ERASING;
2288
2289 if (ONENAND_IS_DDP(this)) {
2290 loff_t bdry_addr = this->chipsize >> 1;
2291 if (addr < bdry_addr && (addr + len) > bdry_addr)
2292 bdry_block = bdry_addr >> this->erase_shift;
2293 }
2294
2295 /* Pre-check bbs */
2296 while (len) {
2297 /* Check if we have a bad block, we do not erase bad blocks */
2298 if (onenand_block_isbad_nolock(mtd, addr, 0)) {
2299 printk(KERN_WARNING "%s: attempt to erase a bad block "
2300 "at addr 0x%012llx\n",
2301 __func__, (unsigned long long) addr);
2302 instr->state = MTD_ERASE_FAILED;
2303 return -EIO;
2304 }
2305 len -= block_size;
2306 addr += block_size;
2307 }
2308
2309 len = instr->len;
2310 addr = instr->addr;
2311
2312 /* loop over 64 eb batches */
2313 while (len) {
2314 struct erase_info verify_instr = *instr;
2315 int max_eb_count = MB_ERASE_MAX_BLK_COUNT;
2316
2317 verify_instr.addr = addr;
2318 verify_instr.len = 0;
2319
2320 /* do not cross chip boundary */
2321 if (bdry_block) {
2322 int this_block = (addr >> this->erase_shift);
2323
2324 if (this_block < bdry_block) {
2325 max_eb_count = min(max_eb_count,
2326 (bdry_block - this_block));
2327 }
2328 }
2329
2330 eb_count = 0;
2331
2332 while (len > block_size && eb_count < (max_eb_count - 1)) {
2333 this->command(mtd, ONENAND_CMD_MULTIBLOCK_ERASE,
2334 addr, block_size);
2335 onenand_invalidate_bufferram(mtd, addr, block_size);
2336
2337 ret = this->wait(mtd, FL_PREPARING_ERASE);
2338 if (ret) {
2339 printk(KERN_ERR "%s: Failed multiblock erase, "
2340 "block %d\n", __func__,
2341 onenand_block(this, addr));
2342 instr->state = MTD_ERASE_FAILED;
2343 instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
2344 return -EIO;
2345 }
2346
2347 len -= block_size;
2348 addr += block_size;
2349 eb_count++;
2350 }
2351
2352 /* last block of 64-eb series */
2353 cond_resched();
2354 this->command(mtd, ONENAND_CMD_ERASE, addr, block_size);
2355 onenand_invalidate_bufferram(mtd, addr, block_size);
2356
2357 ret = this->wait(mtd, FL_ERASING);
2358 /* Check if it is write protected */
2359 if (ret) {
2360 printk(KERN_ERR "%s: Failed erase, block %d\n",
2361 __func__, onenand_block(this, addr));
2362 instr->state = MTD_ERASE_FAILED;
2363 instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
2364 return -EIO;
2365 }
2366
2367 len -= block_size;
2368 addr += block_size;
2369 eb_count++;
2370
2371 /* verify */
2372 verify_instr.len = eb_count * block_size;
2373 if (onenand_multiblock_erase_verify(mtd, &verify_instr)) {
2374 instr->state = verify_instr.state;
2375 instr->fail_addr = verify_instr.fail_addr;
2376 return -EIO;
2377 }
2378
2379 }
2380 return 0;
2381 }
2382
2383
2384 /**
2385 * onenand_block_by_block_erase - [INTERN] erase block(s) using regular erase
2386 * @param mtd MTD device structure
2387 * @param instr erase instruction
2388 * @param region erase region
2389 * @param block_size erase block size
2390 *
2391 * Erase one or more blocks one block at a time
2392 */
2393 static int onenand_block_by_block_erase(struct mtd_info *mtd,
2394 struct erase_info *instr,
2395 struct mtd_erase_region_info *region,
2396 unsigned int block_size)
2397 {
2398 struct onenand_chip *this = mtd->priv;
2399 loff_t addr = instr->addr;
2400 int len = instr->len;
2401 loff_t region_end = 0;
2402 int ret = 0;
2403
2404 if (region) {
2405 /* region is set for Flex-OneNAND */
2406 region_end = region->offset + region->erasesize * region->numblocks;
2407 }
2408
2409 instr->state = MTD_ERASING;
2410
2411 /* Loop through the blocks */
2412 while (len) {
2413 cond_resched();
2414
2415 /* Check if we have a bad block, we do not erase bad blocks */
2416 if (onenand_block_isbad_nolock(mtd, addr, 0)) {
2417 printk(KERN_WARNING "%s: attempt to erase a bad block "
2418 "at addr 0x%012llx\n",
2419 __func__, (unsigned long long) addr);
2420 instr->state = MTD_ERASE_FAILED;
2421 return -EIO;
2422 }
2423
2424 this->command(mtd, ONENAND_CMD_ERASE, addr, block_size);
2425
2426 onenand_invalidate_bufferram(mtd, addr, block_size);
2427
2428 ret = this->wait(mtd, FL_ERASING);
2429 /* Check, if it is write protected */
2430 if (ret) {
2431 printk(KERN_ERR "%s: Failed erase, block %d\n",
2432 __func__, onenand_block(this, addr));
2433 instr->state = MTD_ERASE_FAILED;
2434 instr->fail_addr = addr;
2435 return -EIO;
2436 }
2437
2438 len -= block_size;
2439 addr += block_size;
2440
2441 if (region && addr == region_end) {
2442 if (!len)
2443 break;
2444 region++;
2445
2446 block_size = region->erasesize;
2447 region_end = region->offset + region->erasesize * region->numblocks;
2448
2449 if (len & (block_size - 1)) {
2450 /* FIXME: This should be handled at MTD partitioning level. */
2451 printk(KERN_ERR "%s: Unaligned address\n",
2452 __func__);
2453 return -EIO;
2454 }
2455 }
2456 }
2457 return 0;
2458 }
2459
2460 /**
2461 * onenand_erase - [MTD Interface] erase block(s)
2462 * @param mtd MTD device structure
2463 * @param instr erase instruction
2464 *
2465 * Erase one or more blocks
2466 */
2467 static int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
2468 {
2469 struct onenand_chip *this = mtd->priv;
2470 unsigned int block_size;
2471 loff_t addr = instr->addr;
2472 loff_t len = instr->len;
2473 int ret = 0;
2474 struct mtd_erase_region_info *region = NULL;
2475 loff_t region_offset = 0;
2476
2477 pr_debug("%s: start=0x%012llx, len=%llu\n", __func__,
2478 (unsigned long long)instr->addr,
2479 (unsigned long long)instr->len);
2480
2481 if (FLEXONENAND(this)) {
2482 /* Find the eraseregion of this address */
2483 int i = flexonenand_region(mtd, addr);
2484
2485 region = &mtd->eraseregions[i];
2486 block_size = region->erasesize;
2487
2488 /* Start address within region must align on block boundary.
2489 * Erase region's start offset is always block start address.
2490 */
2491 region_offset = region->offset;
2492 } else
2493 block_size = 1 << this->erase_shift;
2494
2495 /* Start address must align on block boundary */
2496 if (unlikely((addr - region_offset) & (block_size - 1))) {
2497 printk(KERN_ERR "%s: Unaligned address\n", __func__);
2498 return -EINVAL;
2499 }
2500
2501 /* Length must align on block boundary */
2502 if (unlikely(len & (block_size - 1))) {
2503 printk(KERN_ERR "%s: Length not block aligned\n", __func__);
2504 return -EINVAL;
2505 }
2506
2507 /* Grab the lock and see if the device is available */
2508 onenand_get_device(mtd, FL_ERASING);
2509
2510 if (ONENAND_IS_4KB_PAGE(this) || region ||
2511 instr->len < MB_ERASE_MIN_BLK_COUNT * block_size) {
2512 /* region is set for Flex-OneNAND (no mb erase) */
2513 ret = onenand_block_by_block_erase(mtd, instr,
2514 region, block_size);
2515 } else {
2516 ret = onenand_multiblock_erase(mtd, instr, block_size);
2517 }
2518
2519 /* Deselect and wake up anyone waiting on the device */
2520 onenand_release_device(mtd);
2521
2522 /* Do call back function */
2523 if (!ret) {
2524 instr->state = MTD_ERASE_DONE;
2525 mtd_erase_callback(instr);
2526 }
2527
2528 return ret;
2529 }
2530
2531 /**
2532 * onenand_sync - [MTD Interface] sync
2533 * @param mtd MTD device structure
2534 *
2535 * Sync is actually a wait for chip ready function
2536 */
2537 static void onenand_sync(struct mtd_info *mtd)
2538 {
2539 pr_debug("%s: called\n", __func__);
2540
2541 /* Grab the lock and see if the device is available */
2542 onenand_get_device(mtd, FL_SYNCING);
2543
2544 /* Release it and go back */
2545 onenand_release_device(mtd);
2546 }
2547
2548 /**
2549 * onenand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2550 * @param mtd MTD device structure
2551 * @param ofs offset relative to mtd start
2552 *
2553 * Check whether the block is bad
2554 */
2555 static int onenand_block_isbad(struct mtd_info *mtd, loff_t ofs)
2556 {
2557 int ret;
2558
2559 /* Check for invalid offset */
2560 if (ofs > mtd->size)
2561 return -EINVAL;
2562
2563 onenand_get_device(mtd, FL_READING);
2564 ret = onenand_block_isbad_nolock(mtd, ofs, 0);
2565 onenand_release_device(mtd);
2566 return ret;
2567 }
2568
2569 /**
2570 * onenand_default_block_markbad - [DEFAULT] mark a block bad
2571 * @param mtd MTD device structure
2572 * @param ofs offset from device start
2573 *
2574 * This is the default implementation, which can be overridden by
2575 * a hardware specific driver.
2576 */
2577 static int onenand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
2578 {
2579 struct onenand_chip *this = mtd->priv;
2580 struct bbm_info *bbm = this->bbm;
2581 u_char buf[2] = {0, 0};
2582 struct mtd_oob_ops ops = {
2583 .mode = MTD_OPS_PLACE_OOB,
2584 .ooblen = 2,
2585 .oobbuf = buf,
2586 .ooboffs = 0,
2587 };
2588 int block;
2589
2590 /* Get block number */
2591 block = onenand_block(this, ofs);
2592 if (bbm->bbt)
2593 bbm->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
2594
2595 /* We write two bytes, so we don't have to mess with 16-bit access */
2596 ofs += mtd->oobsize + (bbm->badblockpos & ~0x01);
2597 /* FIXME : What to do when marking SLC block in partition
2598 * with MLC erasesize? For now, it is not advisable to
2599 * create partitions containing both SLC and MLC regions.
2600 */
2601 return onenand_write_oob_nolock(mtd, ofs, &ops);
2602 }
2603
2604 /**
2605 * onenand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2606 * @param mtd MTD device structure
2607 * @param ofs offset relative to mtd start
2608 *
2609 * Mark the block as bad
2610 */
2611 static int onenand_block_markbad(struct mtd_info *mtd, loff_t ofs)
2612 {
2613 int ret;
2614
2615 ret = onenand_block_isbad(mtd, ofs);
2616 if (ret) {
2617 /* If it was bad already, return success and do nothing */
2618 if (ret > 0)
2619 return 0;
2620 return ret;
2621 }
2622
2623 onenand_get_device(mtd, FL_WRITING);
2624 ret = mtd_block_markbad(mtd, ofs);
2625 onenand_release_device(mtd);
2626 return ret;
2627 }
2628
2629 /**
2630 * onenand_do_lock_cmd - [OneNAND Interface] Lock or unlock block(s)
2631 * @param mtd MTD device structure
2632 * @param ofs offset relative to mtd start
2633 * @param len number of bytes to lock or unlock
2634 * @param cmd lock or unlock command
2635 *
2636 * Lock or unlock one or more blocks
2637 */
2638 static int onenand_do_lock_cmd(struct mtd_info *mtd, loff_t ofs, size_t len, int cmd)
2639 {
2640 struct onenand_chip *this = mtd->priv;
2641 int start, end, block, value, status;
2642 int wp_status_mask;
2643
2644 start = onenand_block(this, ofs);
2645 end = onenand_block(this, ofs + len) - 1;
2646
2647 if (cmd == ONENAND_CMD_LOCK)
2648 wp_status_mask = ONENAND_WP_LS;
2649 else
2650 wp_status_mask = ONENAND_WP_US;
2651
2652 /* Continuous lock scheme */
2653 if (this->options & ONENAND_HAS_CONT_LOCK) {
2654 /* Set start block address */
2655 this->write_word(start, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2656 /* Set end block address */
2657 this->write_word(end, this->base + ONENAND_REG_END_BLOCK_ADDRESS);
2658 /* Write lock command */
2659 this->command(mtd, cmd, 0, 0);
2660
2661 /* There's no return value */
2662 this->wait(mtd, FL_LOCKING);
2663
2664 /* Sanity check */
2665 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2666 & ONENAND_CTRL_ONGO)
2667 continue;
2668
2669 /* Check lock status */
2670 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2671 if (!(status & wp_status_mask))
2672 printk(KERN_ERR "%s: wp status = 0x%x\n",
2673 __func__, status);
2674
2675 return 0;
2676 }
2677
2678 /* Block lock scheme */
2679 for (block = start; block < end + 1; block++) {
2680 /* Set block address */
2681 value = onenand_block_address(this, block);
2682 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
2683 /* Select DataRAM for DDP */
2684 value = onenand_bufferram_address(this, block);
2685 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
2686 /* Set start block address */
2687 this->write_word(block, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2688 /* Write lock command */
2689 this->command(mtd, cmd, 0, 0);
2690
2691 /* There's no return value */
2692 this->wait(mtd, FL_LOCKING);
2693
2694 /* Sanity check */
2695 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2696 & ONENAND_CTRL_ONGO)
2697 continue;
2698
2699 /* Check lock status */
2700 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2701 if (!(status & wp_status_mask))
2702 printk(KERN_ERR "%s: block = %d, wp status = 0x%x\n",
2703 __func__, block, status);
2704 }
2705
2706 return 0;
2707 }
2708
2709 /**
2710 * onenand_lock - [MTD Interface] Lock block(s)
2711 * @param mtd MTD device structure
2712 * @param ofs offset relative to mtd start
2713 * @param len number of bytes to unlock
2714 *
2715 * Lock one or more blocks
2716 */
2717 static int onenand_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2718 {
2719 int ret;
2720
2721 onenand_get_device(mtd, FL_LOCKING);
2722 ret = onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_LOCK);
2723 onenand_release_device(mtd);
2724 return ret;
2725 }
2726
2727 /**
2728 * onenand_unlock - [MTD Interface] Unlock block(s)
2729 * @param mtd MTD device structure
2730 * @param ofs offset relative to mtd start
2731 * @param len number of bytes to unlock
2732 *
2733 * Unlock one or more blocks
2734 */
2735 static int onenand_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2736 {
2737 int ret;
2738
2739 onenand_get_device(mtd, FL_LOCKING);
2740 ret = onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_UNLOCK);
2741 onenand_release_device(mtd);
2742 return ret;
2743 }
2744
2745 /**
2746 * onenand_check_lock_status - [OneNAND Interface] Check lock status
2747 * @param this onenand chip data structure
2748 *
2749 * Check lock status
2750 */
2751 static int onenand_check_lock_status(struct onenand_chip *this)
2752 {
2753 unsigned int value, block, status;
2754 unsigned int end;
2755
2756 end = this->chipsize >> this->erase_shift;
2757 for (block = 0; block < end; block++) {
2758 /* Set block address */
2759 value = onenand_block_address(this, block);
2760 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
2761 /* Select DataRAM for DDP */
2762 value = onenand_bufferram_address(this, block);
2763 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
2764 /* Set start block address */
2765 this->write_word(block, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2766
2767 /* Check lock status */
2768 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2769 if (!(status & ONENAND_WP_US)) {
2770 printk(KERN_ERR "%s: block = %d, wp status = 0x%x\n",
2771 __func__, block, status);
2772 return 0;
2773 }
2774 }
2775
2776 return 1;
2777 }
2778
2779 /**
2780 * onenand_unlock_all - [OneNAND Interface] unlock all blocks
2781 * @param mtd MTD device structure
2782 *
2783 * Unlock all blocks
2784 */
2785 static void onenand_unlock_all(struct mtd_info *mtd)
2786 {
2787 struct onenand_chip *this = mtd->priv;
2788 loff_t ofs = 0;
2789 loff_t len = mtd->size;
2790
2791 if (this->options & ONENAND_HAS_UNLOCK_ALL) {
2792 /* Set start block address */
2793 this->write_word(0, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2794 /* Write unlock command */
2795 this->command(mtd, ONENAND_CMD_UNLOCK_ALL, 0, 0);
2796
2797 /* There's no return value */
2798 this->wait(mtd, FL_LOCKING);
2799
2800 /* Sanity check */
2801 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2802 & ONENAND_CTRL_ONGO)
2803 continue;
2804
2805 /* Don't check lock status */
2806 if (this->options & ONENAND_SKIP_UNLOCK_CHECK)
2807 return;
2808
2809 /* Check lock status */
2810 if (onenand_check_lock_status(this))
2811 return;
2812
2813 /* Workaround for all block unlock in DDP */
2814 if (ONENAND_IS_DDP(this) && !FLEXONENAND(this)) {
2815 /* All blocks on another chip */
2816 ofs = this->chipsize >> 1;
2817 len = this->chipsize >> 1;
2818 }
2819 }
2820
2821 onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_UNLOCK);
2822 }
2823
2824 #ifdef CONFIG_MTD_ONENAND_OTP
2825
2826 /**
2827 * onenand_otp_command - Send OTP specific command to OneNAND device
2828 * @param mtd MTD device structure
2829 * @param cmd the command to be sent
2830 * @param addr offset to read from or write to
2831 * @param len number of bytes to read or write
2832 */
2833 static int onenand_otp_command(struct mtd_info *mtd, int cmd, loff_t addr,
2834 size_t len)
2835 {
2836 struct onenand_chip *this = mtd->priv;
2837 int value, block, page;
2838
2839 /* Address translation */
2840 switch (cmd) {
2841 case ONENAND_CMD_OTP_ACCESS:
2842 block = (int) (addr >> this->erase_shift);
2843 page = -1;
2844 break;
2845
2846 default:
2847 block = (int) (addr >> this->erase_shift);
2848 page = (int) (addr >> this->page_shift);
2849
2850 if (ONENAND_IS_2PLANE(this)) {
2851 /* Make the even block number */
2852 block &= ~1;
2853 /* Is it the odd plane? */
2854 if (addr & this->writesize)
2855 block++;
2856 page >>= 1;
2857 }
2858 page &= this->page_mask;
2859 break;
2860 }
2861
2862 if (block != -1) {
2863 /* Write 'DFS, FBA' of Flash */
2864 value = onenand_block_address(this, block);
2865 this->write_word(value, this->base +
2866 ONENAND_REG_START_ADDRESS1);
2867 }
2868
2869 if (page != -1) {
2870 /* Now we use page size operation */
2871 int sectors = 4, count = 4;
2872 int dataram;
2873
2874 switch (cmd) {
2875 default:
2876 if (ONENAND_IS_2PLANE(this) && cmd == ONENAND_CMD_PROG)
2877 cmd = ONENAND_CMD_2X_PROG;
2878 dataram = ONENAND_CURRENT_BUFFERRAM(this);
2879 break;
2880 }
2881
2882 /* Write 'FPA, FSA' of Flash */
2883 value = onenand_page_address(page, sectors);
2884 this->write_word(value, this->base +
2885 ONENAND_REG_START_ADDRESS8);
2886
2887 /* Write 'BSA, BSC' of DataRAM */
2888 value = onenand_buffer_address(dataram, sectors, count);
2889 this->write_word(value, this->base + ONENAND_REG_START_BUFFER);
2890 }
2891
2892 /* Interrupt clear */
2893 this->write_word(ONENAND_INT_CLEAR, this->base + ONENAND_REG_INTERRUPT);
2894
2895 /* Write command */
2896 this->write_word(cmd, this->base + ONENAND_REG_COMMAND);
2897
2898 return 0;
2899 }
2900
2901 /**
2902 * onenand_otp_write_oob_nolock - [INTERN] OneNAND write out-of-band, specific to OTP
2903 * @param mtd MTD device structure
2904 * @param to offset to write to
2905 * @param len number of bytes to write
2906 * @param retlen pointer to variable to store the number of written bytes
2907 * @param buf the data to write
2908 *
2909 * OneNAND write out-of-band only for OTP
2910 */
2911 static int onenand_otp_write_oob_nolock(struct mtd_info *mtd, loff_t to,
2912 struct mtd_oob_ops *ops)
2913 {
2914 struct onenand_chip *this = mtd->priv;
2915 int column, ret = 0, oobsize;
2916 int written = 0;
2917 u_char *oobbuf;
2918 size_t len = ops->ooblen;
2919 const u_char *buf = ops->oobbuf;
2920 int block, value, status;
2921
2922 to += ops->ooboffs;
2923
2924 /* Initialize retlen, in case of early exit */
2925 ops->oobretlen = 0;
2926
2927 oobsize = mtd->oobsize;
2928
2929 column = to & (mtd->oobsize - 1);
2930
2931 oobbuf = this->oob_buf;
2932
2933 /* Loop until all data write */
2934 while (written < len) {
2935 int thislen = min_t(int, oobsize, len - written);
2936
2937 cond_resched();
2938
2939 block = (int) (to >> this->erase_shift);
2940 /*
2941 * Write 'DFS, FBA' of Flash
2942 * Add: F100h DQ=DFS, FBA
2943 */
2944
2945 value = onenand_block_address(this, block);
2946 this->write_word(value, this->base +
2947 ONENAND_REG_START_ADDRESS1);
2948
2949 /*
2950 * Select DataRAM for DDP
2951 * Add: F101h DQ=DBS
2952 */
2953
2954 value = onenand_bufferram_address(this, block);
2955 this->write_word(value, this->base +
2956 ONENAND_REG_START_ADDRESS2);
2957 ONENAND_SET_NEXT_BUFFERRAM(this);
2958
2959 /*
2960 * Enter OTP access mode
2961 */
2962 this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
2963 this->wait(mtd, FL_OTPING);
2964
2965 /* We send data to spare ram with oobsize
2966 * to prevent byte access */
2967 memcpy(oobbuf + column, buf, thislen);
2968
2969 /*
2970 * Write Data into DataRAM
2971 * Add: 8th Word
2972 * in sector0/spare/page0
2973 * DQ=XXFCh
2974 */
2975 this->write_bufferram(mtd, ONENAND_SPARERAM,
2976 oobbuf, 0, mtd->oobsize);
2977
2978 onenand_otp_command(mtd, ONENAND_CMD_PROGOOB, to, mtd->oobsize);
2979 onenand_update_bufferram(mtd, to, 0);
2980 if (ONENAND_IS_2PLANE(this)) {
2981 ONENAND_SET_BUFFERRAM1(this);
2982 onenand_update_bufferram(mtd, to + this->writesize, 0);
2983 }
2984
2985 ret = this->wait(mtd, FL_WRITING);
2986 if (ret) {
2987 printk(KERN_ERR "%s: write failed %d\n", __func__, ret);
2988 break;
2989 }
2990
2991 /* Exit OTP access mode */
2992 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
2993 this->wait(mtd, FL_RESETING);
2994
2995 status = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
2996 status &= 0x60;
2997
2998 if (status == 0x60) {
2999 printk(KERN_DEBUG "\nBLOCK\tSTATUS\n");
3000 printk(KERN_DEBUG "1st Block\tLOCKED\n");
3001 printk(KERN_DEBUG "OTP Block\tLOCKED\n");
3002 } else if (status == 0x20) {
3003 printk(KERN_DEBUG "\nBLOCK\tSTATUS\n");
3004 printk(KERN_DEBUG "1st Block\tLOCKED\n");
3005 printk(KERN_DEBUG "OTP Block\tUN-LOCKED\n");
3006 } else if (status == 0x40) {
3007 printk(KERN_DEBUG "\nBLOCK\tSTATUS\n");
3008 printk(KERN_DEBUG "1st Block\tUN-LOCKED\n");
3009 printk(KERN_DEBUG "OTP Block\tLOCKED\n");
3010 } else {
3011 printk(KERN_DEBUG "Reboot to check\n");
3012 }
3013
3014 written += thislen;
3015 if (written == len)
3016 break;
3017
3018 to += mtd->writesize;
3019 buf += thislen;
3020 column = 0;
3021 }
3022
3023 ops->oobretlen = written;
3024
3025 return ret;
3026 }
3027
3028 /* Internal OTP operation */
3029 typedef int (*otp_op_t)(struct mtd_info *mtd, loff_t form, size_t len,
3030 size_t *retlen, u_char *buf);
3031
3032 /**
3033 * do_otp_read - [DEFAULT] Read OTP block area
3034 * @param mtd MTD device structure
3035 * @param from The offset to read
3036 * @param len number of bytes to read
3037 * @param retlen pointer to variable to store the number of readbytes
3038 * @param buf the databuffer to put/get data
3039 *
3040 * Read OTP block area.
3041 */
3042 static int do_otp_read(struct mtd_info *mtd, loff_t from, size_t len,
3043 size_t *retlen, u_char *buf)
3044 {
3045 struct onenand_chip *this = mtd->priv;
3046 struct mtd_oob_ops ops = {
3047 .len = len,
3048 .ooblen = 0,
3049 .datbuf = buf,
3050 .oobbuf = NULL,
3051 };
3052 int ret;
3053
3054 /* Enter OTP access mode */
3055 this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
3056 this->wait(mtd, FL_OTPING);
3057
3058 ret = ONENAND_IS_4KB_PAGE(this) ?
3059 onenand_mlc_read_ops_nolock(mtd, from, &ops) :
3060 onenand_read_ops_nolock(mtd, from, &ops);
3061
3062 /* Exit OTP access mode */
3063 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3064 this->wait(mtd, FL_RESETING);
3065
3066 return ret;
3067 }
3068
3069 /**
3070 * do_otp_write - [DEFAULT] Write OTP block area
3071 * @param mtd MTD device structure
3072 * @param to The offset to write
3073 * @param len number of bytes to write
3074 * @param retlen pointer to variable to store the number of write bytes
3075 * @param buf the databuffer to put/get data
3076 *
3077 * Write OTP block area.
3078 */
3079 static int do_otp_write(struct mtd_info *mtd, loff_t to, size_t len,
3080 size_t *retlen, u_char *buf)
3081 {
3082 struct onenand_chip *this = mtd->priv;
3083 unsigned char *pbuf = buf;
3084 int ret;
3085 struct mtd_oob_ops ops;
3086
3087 /* Force buffer page aligned */
3088 if (len < mtd->writesize) {
3089 memcpy(this->page_buf, buf, len);
3090 memset(this->page_buf + len, 0xff, mtd->writesize - len);
3091 pbuf = this->page_buf;
3092 len = mtd->writesize;
3093 }
3094
3095 /* Enter OTP access mode */
3096 this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
3097 this->wait(mtd, FL_OTPING);
3098
3099 ops.len = len;
3100 ops.ooblen = 0;
3101 ops.datbuf = pbuf;
3102 ops.oobbuf = NULL;
3103 ret = onenand_write_ops_nolock(mtd, to, &ops);
3104 *retlen = ops.retlen;
3105
3106 /* Exit OTP access mode */
3107 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3108 this->wait(mtd, FL_RESETING);
3109
3110 return ret;
3111 }
3112
3113 /**
3114 * do_otp_lock - [DEFAULT] Lock OTP block area
3115 * @param mtd MTD device structure
3116 * @param from The offset to lock
3117 * @param len number of bytes to lock
3118 * @param retlen pointer to variable to store the number of lock bytes
3119 * @param buf the databuffer to put/get data
3120 *
3121 * Lock OTP block area.
3122 */
3123 static int do_otp_lock(struct mtd_info *mtd, loff_t from, size_t len,
3124 size_t *retlen, u_char *buf)
3125 {
3126 struct onenand_chip *this = mtd->priv;
3127 struct mtd_oob_ops ops;
3128 int ret;
3129
3130 if (FLEXONENAND(this)) {
3131
3132 /* Enter OTP access mode */
3133 this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
3134 this->wait(mtd, FL_OTPING);
3135 /*
3136 * For Flex-OneNAND, we write lock mark to 1st word of sector 4 of
3137 * main area of page 49.
3138 */
3139 ops.len = mtd->writesize;
3140 ops.ooblen = 0;
3141 ops.datbuf = buf;
3142 ops.oobbuf = NULL;
3143 ret = onenand_write_ops_nolock(mtd, mtd->writesize * 49, &ops);
3144 *retlen = ops.retlen;
3145
3146 /* Exit OTP access mode */
3147 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3148 this->wait(mtd, FL_RESETING);
3149 } else {
3150 ops.mode = MTD_OPS_PLACE_OOB;
3151 ops.ooblen = len;
3152 ops.oobbuf = buf;
3153 ops.ooboffs = 0;
3154 ret = onenand_otp_write_oob_nolock(mtd, from, &ops);
3155 *retlen = ops.oobretlen;
3156 }
3157
3158 return ret;
3159 }
3160
3161 /**
3162 * onenand_otp_walk - [DEFAULT] Handle OTP operation
3163 * @param mtd MTD device structure
3164 * @param from The offset to read/write
3165 * @param len number of bytes to read/write
3166 * @param retlen pointer to variable to store the number of read bytes
3167 * @param buf the databuffer to put/get data
3168 * @param action do given action
3169 * @param mode specify user and factory
3170 *
3171 * Handle OTP operation.
3172 */
3173 static int onenand_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
3174 size_t *retlen, u_char *buf,
3175 otp_op_t action, int mode)
3176 {
3177 struct onenand_chip *this = mtd->priv;
3178 int otp_pages;
3179 int density;
3180 int ret = 0;
3181
3182 *retlen = 0;
3183
3184 density = onenand_get_density(this->device_id);
3185 if (density < ONENAND_DEVICE_DENSITY_512Mb)
3186 otp_pages = 20;
3187 else
3188 otp_pages = 50;
3189
3190 if (mode == MTD_OTP_FACTORY) {
3191 from += mtd->writesize * otp_pages;
3192 otp_pages = ONENAND_PAGES_PER_BLOCK - otp_pages;
3193 }
3194
3195 /* Check User/Factory boundary */
3196 if (mode == MTD_OTP_USER) {
3197 if (mtd->writesize * otp_pages < from + len)
3198 return 0;
3199 } else {
3200 if (mtd->writesize * otp_pages < len)
3201 return 0;
3202 }
3203
3204 onenand_get_device(mtd, FL_OTPING);
3205 while (len > 0 && otp_pages > 0) {
3206 if (!action) { /* OTP Info functions */
3207 struct otp_info *otpinfo;
3208
3209 len -= sizeof(struct otp_info);
3210 if (len <= 0) {
3211 ret = -ENOSPC;
3212 break;
3213 }
3214
3215 otpinfo = (struct otp_info *) buf;
3216 otpinfo->start = from;
3217 otpinfo->length = mtd->writesize;
3218 otpinfo->locked = 0;
3219
3220 from += mtd->writesize;
3221 buf += sizeof(struct otp_info);
3222 *retlen += sizeof(struct otp_info);
3223 } else {
3224 size_t tmp_retlen;
3225
3226 ret = action(mtd, from, len, &tmp_retlen, buf);
3227
3228 buf += tmp_retlen;
3229 len -= tmp_retlen;
3230 *retlen += tmp_retlen;
3231
3232 if (ret)
3233 break;
3234 }
3235 otp_pages--;
3236 }
3237 onenand_release_device(mtd);
3238
3239 return ret;
3240 }
3241
3242 /**
3243 * onenand_get_fact_prot_info - [MTD Interface] Read factory OTP info
3244 * @param mtd MTD device structure
3245 * @param buf the databuffer to put/get data
3246 * @param len number of bytes to read
3247 *
3248 * Read factory OTP info.
3249 */
3250 static int onenand_get_fact_prot_info(struct mtd_info *mtd,
3251 struct otp_info *buf, size_t len)
3252 {
3253 size_t retlen;
3254 int ret;
3255
3256 ret = onenand_otp_walk(mtd, 0, len, &retlen, (u_char *) buf, NULL, MTD_OTP_FACTORY);
3257
3258 return ret ? : retlen;
3259 }
3260
3261 /**
3262 * onenand_read_fact_prot_reg - [MTD Interface] Read factory OTP area
3263 * @param mtd MTD device structure
3264 * @param from The offset to read
3265 * @param len number of bytes to read
3266 * @param retlen pointer to variable to store the number of read bytes
3267 * @param buf the databuffer to put/get data
3268 *
3269 * Read factory OTP area.
3270 */
3271 static int onenand_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
3272 size_t len, size_t *retlen, u_char *buf)
3273 {
3274 return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_read, MTD_OTP_FACTORY);
3275 }
3276
3277 /**
3278 * onenand_get_user_prot_info - [MTD Interface] Read user OTP info
3279 * @param mtd MTD device structure
3280 * @param buf the databuffer to put/get data
3281 * @param len number of bytes to read
3282 *
3283 * Read user OTP info.
3284 */
3285 static int onenand_get_user_prot_info(struct mtd_info *mtd,
3286 struct otp_info *buf, size_t len)
3287 {
3288 size_t retlen;
3289 int ret;
3290
3291 ret = onenand_otp_walk(mtd, 0, len, &retlen, (u_char *) buf, NULL, MTD_OTP_USER);
3292
3293 return ret ? : retlen;
3294 }
3295
3296 /**
3297 * onenand_read_user_prot_reg - [MTD Interface] Read user OTP area
3298 * @param mtd MTD device structure
3299 * @param from The offset to read
3300 * @param len number of bytes to read
3301 * @param retlen pointer to variable to store the number of read bytes
3302 * @param buf the databuffer to put/get data
3303 *
3304 * Read user OTP area.
3305 */
3306 static int onenand_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
3307 size_t len, size_t *retlen, u_char *buf)
3308 {
3309 return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_read, MTD_OTP_USER);
3310 }
3311
3312 /**
3313 * onenand_write_user_prot_reg - [MTD Interface] Write user OTP area
3314 * @param mtd MTD device structure
3315 * @param from The offset to write
3316 * @param len number of bytes to write
3317 * @param retlen pointer to variable to store the number of write bytes
3318 * @param buf the databuffer to put/get data
3319 *
3320 * Write user OTP area.
3321 */
3322 static int onenand_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
3323 size_t len, size_t *retlen, u_char *buf)
3324 {
3325 return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_write, MTD_OTP_USER);
3326 }
3327
3328 /**
3329 * onenand_lock_user_prot_reg - [MTD Interface] Lock user OTP area
3330 * @param mtd MTD device structure
3331 * @param from The offset to lock
3332 * @param len number of bytes to unlock
3333 *
3334 * Write lock mark on spare area in page 0 in OTP block
3335 */
3336 static int onenand_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
3337 size_t len)
3338 {
3339 struct onenand_chip *this = mtd->priv;
3340 u_char *buf = FLEXONENAND(this) ? this->page_buf : this->oob_buf;
3341 size_t retlen;
3342 int ret;
3343 unsigned int otp_lock_offset = ONENAND_OTP_LOCK_OFFSET;
3344
3345 memset(buf, 0xff, FLEXONENAND(this) ? this->writesize
3346 : mtd->oobsize);
3347 /*
3348 * Write lock mark to 8th word of sector0 of page0 of the spare0.
3349 * We write 16 bytes spare area instead of 2 bytes.
3350 * For Flex-OneNAND, we write lock mark to 1st word of sector 4 of
3351 * main area of page 49.
3352 */
3353
3354 from = 0;
3355 len = FLEXONENAND(this) ? mtd->writesize : 16;
3356
3357 /*
3358 * Note: OTP lock operation
3359 * OTP block : 0xXXFC XX 1111 1100
3360 * 1st block : 0xXXF3 (If chip support) XX 1111 0011
3361 * Both : 0xXXF0 (If chip support) XX 1111 0000
3362 */
3363 if (FLEXONENAND(this))
3364 otp_lock_offset = FLEXONENAND_OTP_LOCK_OFFSET;
3365
3366 /* ONENAND_OTP_AREA | ONENAND_OTP_BLOCK0 | ONENAND_OTP_AREA_BLOCK0 */
3367 if (otp == 1)
3368 buf[otp_lock_offset] = 0xFC;
3369 else if (otp == 2)
3370 buf[otp_lock_offset] = 0xF3;
3371 else if (otp == 3)
3372 buf[otp_lock_offset] = 0xF0;
3373 else if (otp != 0)
3374 printk(KERN_DEBUG "[OneNAND] Invalid option selected for OTP\n");
3375
3376 ret = onenand_otp_walk(mtd, from, len, &retlen, buf, do_otp_lock, MTD_OTP_USER);
3377
3378 return ret ? : retlen;
3379 }
3380
3381 #endif /* CONFIG_MTD_ONENAND_OTP */
3382
3383 /**
3384 * onenand_check_features - Check and set OneNAND features
3385 * @param mtd MTD data structure
3386 *
3387 * Check and set OneNAND features
3388 * - lock scheme
3389 * - two plane
3390 */
3391 static void onenand_check_features(struct mtd_info *mtd)
3392 {
3393 struct onenand_chip *this = mtd->priv;
3394 unsigned int density, process, numbufs;
3395
3396 /* Lock scheme depends on density and process */
3397 density = onenand_get_density(this->device_id);
3398 process = this->version_id >> ONENAND_VERSION_PROCESS_SHIFT;
3399 numbufs = this->read_word(this->base + ONENAND_REG_NUM_BUFFERS) >> 8;
3400
3401 /* Lock scheme */
3402 switch (density) {
3403 case ONENAND_DEVICE_DENSITY_4Gb:
3404 if (ONENAND_IS_DDP(this))
3405 this->options |= ONENAND_HAS_2PLANE;
3406 else if (numbufs == 1) {
3407 this->options |= ONENAND_HAS_4KB_PAGE;
3408 this->options |= ONENAND_HAS_CACHE_PROGRAM;
3409 /*
3410 * There are two different 4KiB pagesize chips
3411 * and no way to detect it by H/W config values.
3412 *
3413 * To detect the correct NOP for each chips,
3414 * It should check the version ID as workaround.
3415 *
3416 * Now it has as following
3417 * KFM4G16Q4M has NOP 4 with version ID 0x0131
3418 * KFM4G16Q5M has NOP 1 with versoin ID 0x013e
3419 */
3420 if ((this->version_id & 0xf) == 0xe)
3421 this->options |= ONENAND_HAS_NOP_1;
3422 }
3423
3424 case ONENAND_DEVICE_DENSITY_2Gb:
3425 /* 2Gb DDP does not have 2 plane */
3426 if (!ONENAND_IS_DDP(this))
3427 this->options |= ONENAND_HAS_2PLANE;
3428 this->options |= ONENAND_HAS_UNLOCK_ALL;
3429
3430 case ONENAND_DEVICE_DENSITY_1Gb:
3431 /* A-Die has all block unlock */
3432 if (process)
3433 this->options |= ONENAND_HAS_UNLOCK_ALL;
3434 break;
3435
3436 default:
3437 /* Some OneNAND has continuous lock scheme */
3438 if (!process)
3439 this->options |= ONENAND_HAS_CONT_LOCK;
3440 break;
3441 }
3442
3443 /* The MLC has 4KiB pagesize. */
3444 if (ONENAND_IS_MLC(this))
3445 this->options |= ONENAND_HAS_4KB_PAGE;
3446
3447 if (ONENAND_IS_4KB_PAGE(this))
3448 this->options &= ~ONENAND_HAS_2PLANE;
3449
3450 if (FLEXONENAND(this)) {
3451 this->options &= ~ONENAND_HAS_CONT_LOCK;
3452 this->options |= ONENAND_HAS_UNLOCK_ALL;
3453 }
3454
3455 if (this->options & ONENAND_HAS_CONT_LOCK)
3456 printk(KERN_DEBUG "Lock scheme is Continuous Lock\n");
3457 if (this->options & ONENAND_HAS_UNLOCK_ALL)
3458 printk(KERN_DEBUG "Chip support all block unlock\n");
3459 if (this->options & ONENAND_HAS_2PLANE)
3460 printk(KERN_DEBUG "Chip has 2 plane\n");
3461 if (this->options & ONENAND_HAS_4KB_PAGE)
3462 printk(KERN_DEBUG "Chip has 4KiB pagesize\n");
3463 if (this->options & ONENAND_HAS_CACHE_PROGRAM)
3464 printk(KERN_DEBUG "Chip has cache program feature\n");
3465 }
3466
3467 /**
3468 * onenand_print_device_info - Print device & version ID
3469 * @param device device ID
3470 * @param version version ID
3471 *
3472 * Print device & version ID
3473 */
3474 static void onenand_print_device_info(int device, int version)
3475 {
3476 int vcc, demuxed, ddp, density, flexonenand;
3477
3478 vcc = device & ONENAND_DEVICE_VCC_MASK;
3479 demuxed = device & ONENAND_DEVICE_IS_DEMUX;
3480 ddp = device & ONENAND_DEVICE_IS_DDP;
3481 density = onenand_get_density(device);
3482 flexonenand = device & DEVICE_IS_FLEXONENAND;
3483 printk(KERN_INFO "%s%sOneNAND%s %dMB %sV 16-bit (0x%02x)\n",
3484 demuxed ? "" : "Muxed ",
3485 flexonenand ? "Flex-" : "",
3486 ddp ? "(DDP)" : "",
3487 (16 << density),
3488 vcc ? "2.65/3.3" : "1.8",
3489 device);
3490 printk(KERN_INFO "OneNAND version = 0x%04x\n", version);
3491 }
3492
3493 static const struct onenand_manufacturers onenand_manuf_ids[] = {
3494 {ONENAND_MFR_SAMSUNG, "Samsung"},
3495 {ONENAND_MFR_NUMONYX, "Numonyx"},
3496 };
3497
3498 /**
3499 * onenand_check_maf - Check manufacturer ID
3500 * @param manuf manufacturer ID
3501 *
3502 * Check manufacturer ID
3503 */
3504 static int onenand_check_maf(int manuf)
3505 {
3506 int size = ARRAY_SIZE(onenand_manuf_ids);
3507 char *name;
3508 int i;
3509
3510 for (i = 0; i < size; i++)
3511 if (manuf == onenand_manuf_ids[i].id)
3512 break;
3513
3514 if (i < size)
3515 name = onenand_manuf_ids[i].name;
3516 else
3517 name = "Unknown";
3518
3519 printk(KERN_DEBUG "OneNAND Manufacturer: %s (0x%0x)\n", name, manuf);
3520
3521 return (i == size);
3522 }
3523
3524 /**
3525 * flexonenand_get_boundary - Reads the SLC boundary
3526 * @param onenand_info - onenand info structure
3527 **/
3528 static int flexonenand_get_boundary(struct mtd_info *mtd)
3529 {
3530 struct onenand_chip *this = mtd->priv;
3531 unsigned die, bdry;
3532 int ret, syscfg, locked;
3533
3534 /* Disable ECC */
3535 syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1);
3536 this->write_word((syscfg | 0x0100), this->base + ONENAND_REG_SYS_CFG1);
3537
3538 for (die = 0; die < this->dies; die++) {
3539 this->command(mtd, FLEXONENAND_CMD_PI_ACCESS, die, 0);
3540 this->wait(mtd, FL_SYNCING);
3541
3542 this->command(mtd, FLEXONENAND_CMD_READ_PI, die, 0);
3543 ret = this->wait(mtd, FL_READING);
3544
3545 bdry = this->read_word(this->base + ONENAND_DATARAM);
3546 if ((bdry >> FLEXONENAND_PI_UNLOCK_SHIFT) == 3)
3547 locked = 0;
3548 else
3549 locked = 1;
3550 this->boundary[die] = bdry & FLEXONENAND_PI_MASK;
3551
3552 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3553 ret = this->wait(mtd, FL_RESETING);
3554
3555 printk(KERN_INFO "Die %d boundary: %d%s\n", die,
3556 this->boundary[die], locked ? "(Locked)" : "(Unlocked)");
3557 }
3558
3559 /* Enable ECC */
3560 this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);
3561 return 0;
3562 }
3563
3564 /**
3565 * flexonenand_get_size - Fill up fields in onenand_chip and mtd_info
3566 * boundary[], diesize[], mtd->size, mtd->erasesize
3567 * @param mtd - MTD device structure
3568 */
3569 static void flexonenand_get_size(struct mtd_info *mtd)
3570 {
3571 struct onenand_chip *this = mtd->priv;
3572 int die, i, eraseshift, density;
3573 int blksperdie, maxbdry;
3574 loff_t ofs;
3575
3576 density = onenand_get_density(this->device_id);
3577 blksperdie = ((loff_t)(16 << density) << 20) >> (this->erase_shift);
3578 blksperdie >>= ONENAND_IS_DDP(this) ? 1 : 0;
3579 maxbdry = blksperdie - 1;
3580 eraseshift = this->erase_shift - 1;
3581
3582 mtd->numeraseregions = this->dies << 1;
3583
3584 /* This fills up the device boundary */
3585 flexonenand_get_boundary(mtd);
3586 die = ofs = 0;
3587 i = -1;
3588 for (; die < this->dies; die++) {
3589 if (!die || this->boundary[die-1] != maxbdry) {
3590 i++;
3591 mtd->eraseregions[i].offset = ofs;
3592 mtd->eraseregions[i].erasesize = 1 << eraseshift;
3593 mtd->eraseregions[i].numblocks =
3594 this->boundary[die] + 1;
3595 ofs += mtd->eraseregions[i].numblocks << eraseshift;
3596 eraseshift++;
3597 } else {
3598 mtd->numeraseregions -= 1;
3599 mtd->eraseregions[i].numblocks +=
3600 this->boundary[die] + 1;
3601 ofs += (this->boundary[die] + 1) << (eraseshift - 1);
3602 }
3603 if (this->boundary[die] != maxbdry) {
3604 i++;
3605 mtd->eraseregions[i].offset = ofs;
3606 mtd->eraseregions[i].erasesize = 1 << eraseshift;
3607 mtd->eraseregions[i].numblocks = maxbdry ^
3608 this->boundary[die];
3609 ofs += mtd->eraseregions[i].numblocks << eraseshift;
3610 eraseshift--;
3611 } else
3612 mtd->numeraseregions -= 1;
3613 }
3614
3615 /* Expose MLC erase size except when all blocks are SLC */
3616 mtd->erasesize = 1 << this->erase_shift;
3617 if (mtd->numeraseregions == 1)
3618 mtd->erasesize >>= 1;
3619
3620 printk(KERN_INFO "Device has %d eraseregions\n", mtd->numeraseregions);
3621 for (i = 0; i < mtd->numeraseregions; i++)
3622 printk(KERN_INFO "[offset: 0x%08x, erasesize: 0x%05x,"
3623 " numblocks: %04u]\n",
3624 (unsigned int) mtd->eraseregions[i].offset,
3625 mtd->eraseregions[i].erasesize,
3626 mtd->eraseregions[i].numblocks);
3627
3628 for (die = 0, mtd->size = 0; die < this->dies; die++) {
3629 this->diesize[die] = (loff_t)blksperdie << this->erase_shift;
3630 this->diesize[die] -= (loff_t)(this->boundary[die] + 1)
3631 << (this->erase_shift - 1);
3632 mtd->size += this->diesize[die];
3633 }
3634 }
3635
3636 /**
3637 * flexonenand_check_blocks_erased - Check if blocks are erased
3638 * @param mtd_info - mtd info structure
3639 * @param start - first erase block to check
3640 * @param end - last erase block to check
3641 *
3642 * Converting an unerased block from MLC to SLC
3643 * causes byte values to change. Since both data and its ECC
3644 * have changed, reads on the block give uncorrectable error.
3645 * This might lead to the block being detected as bad.
3646 *
3647 * Avoid this by ensuring that the block to be converted is
3648 * erased.
3649 */
3650 static int flexonenand_check_blocks_erased(struct mtd_info *mtd, int start, int end)
3651 {
3652 struct onenand_chip *this = mtd->priv;
3653 int i, ret;
3654 int block;
3655 struct mtd_oob_ops ops = {
3656 .mode = MTD_OPS_PLACE_OOB,
3657 .ooboffs = 0,
3658 .ooblen = mtd->oobsize,
3659 .datbuf = NULL,
3660 .oobbuf = this->oob_buf,
3661 };
3662 loff_t addr;
3663
3664 printk(KERN_DEBUG "Check blocks from %d to %d\n", start, end);
3665
3666 for (block = start; block <= end; block++) {
3667 addr = flexonenand_addr(this, block);
3668 if (onenand_block_isbad_nolock(mtd, addr, 0))
3669 continue;
3670
3671 /*
3672 * Since main area write results in ECC write to spare,
3673 * it is sufficient to check only ECC bytes for change.
3674 */
3675 ret = onenand_read_oob_nolock(mtd, addr, &ops);
3676 if (ret)
3677 return ret;
3678
3679 for (i = 0; i < mtd->oobsize; i++)
3680 if (this->oob_buf[i] != 0xff)
3681 break;
3682
3683 if (i != mtd->oobsize) {
3684 printk(KERN_WARNING "%s: Block %d not erased.\n",
3685 __func__, block);
3686 return 1;
3687 }
3688 }
3689
3690 return 0;
3691 }
3692
3693 /**
3694 * flexonenand_set_boundary - Writes the SLC boundary
3695 * @param mtd - mtd info structure
3696 */
3697 int flexonenand_set_boundary(struct mtd_info *mtd, int die,
3698 int boundary, int lock)
3699 {
3700 struct onenand_chip *this = mtd->priv;
3701 int ret, density, blksperdie, old, new, thisboundary;
3702 loff_t addr;
3703
3704 /* Change only once for SDP Flex-OneNAND */
3705 if (die && (!ONENAND_IS_DDP(this)))
3706 return 0;
3707
3708 /* boundary value of -1 indicates no required change */
3709 if (boundary < 0 || boundary == this->boundary[die])
3710 return 0;
3711
3712 density = onenand_get_density(this->device_id);
3713 blksperdie = ((16 << density) << 20) >> this->erase_shift;
3714 blksperdie >>= ONENAND_IS_DDP(this) ? 1 : 0;
3715
3716 if (boundary >= blksperdie) {
3717 printk(KERN_ERR "%s: Invalid boundary value. "
3718 "Boundary not changed.\n", __func__);
3719 return -EINVAL;
3720 }
3721
3722 /* Check if converting blocks are erased */
3723 old = this->boundary[die] + (die * this->density_mask);
3724 new = boundary + (die * this->density_mask);
3725 ret = flexonenand_check_blocks_erased(mtd, min(old, new) + 1, max(old, new));
3726 if (ret) {
3727 printk(KERN_ERR "%s: Please erase blocks "
3728 "before boundary change\n", __func__);
3729 return ret;
3730 }
3731
3732 this->command(mtd, FLEXONENAND_CMD_PI_ACCESS, die, 0);
3733 this->wait(mtd, FL_SYNCING);
3734
3735 /* Check is boundary is locked */
3736 this->command(mtd, FLEXONENAND_CMD_READ_PI, die, 0);
3737 ret = this->wait(mtd, FL_READING);
3738
3739 thisboundary = this->read_word(this->base + ONENAND_DATARAM);
3740 if ((thisboundary >> FLEXONENAND_PI_UNLOCK_SHIFT) != 3) {
3741 printk(KERN_ERR "%s: boundary locked\n", __func__);
3742 ret = 1;
3743 goto out;
3744 }
3745
3746 printk(KERN_INFO "Changing die %d boundary: %d%s\n",
3747 die, boundary, lock ? "(Locked)" : "(Unlocked)");
3748
3749 addr = die ? this->diesize[0] : 0;
3750
3751 boundary &= FLEXONENAND_PI_MASK;
3752 boundary |= lock ? 0 : (3 << FLEXONENAND_PI_UNLOCK_SHIFT);
3753
3754 this->command(mtd, ONENAND_CMD_ERASE, addr, 0);
3755 ret = this->wait(mtd, FL_ERASING);
3756 if (ret) {
3757 printk(KERN_ERR "%s: Failed PI erase for Die %d\n",
3758 __func__, die);
3759 goto out;
3760 }
3761
3762 this->write_word(boundary, this->base + ONENAND_DATARAM);
3763 this->command(mtd, ONENAND_CMD_PROG, addr, 0);
3764 ret = this->wait(mtd, FL_WRITING);
3765 if (ret) {
3766 printk(KERN_ERR "%s: Failed PI write for Die %d\n",
3767 __func__, die);
3768 goto out;
3769 }
3770
3771 this->command(mtd, FLEXONENAND_CMD_PI_UPDATE, die, 0);
3772 ret = this->wait(mtd, FL_WRITING);
3773 out:
3774 this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_REG_COMMAND);
3775 this->wait(mtd, FL_RESETING);
3776 if (!ret)
3777 /* Recalculate device size on boundary change*/
3778 flexonenand_get_size(mtd);
3779
3780 return ret;
3781 }
3782
3783 /**
3784 * onenand_chip_probe - [OneNAND Interface] The generic chip probe
3785 * @param mtd MTD device structure
3786 *
3787 * OneNAND detection method:
3788 * Compare the values from command with ones from register
3789 */
3790 static int onenand_chip_probe(struct mtd_info *mtd)
3791 {
3792 struct onenand_chip *this = mtd->priv;
3793 int bram_maf_id, bram_dev_id, maf_id, dev_id;
3794 int syscfg;
3795
3796 /* Save system configuration 1 */
3797 syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1);
3798 /* Clear Sync. Burst Read mode to read BootRAM */
3799 this->write_word((syscfg & ~ONENAND_SYS_CFG1_SYNC_READ & ~ONENAND_SYS_CFG1_SYNC_WRITE), this->base + ONENAND_REG_SYS_CFG1);
3800
3801 /* Send the command for reading device ID from BootRAM */
3802 this->write_word(ONENAND_CMD_READID, this->base + ONENAND_BOOTRAM);
3803
3804 /* Read manufacturer and device IDs from BootRAM */
3805 bram_maf_id = this->read_word(this->base + ONENAND_BOOTRAM + 0x0);
3806 bram_dev_id = this->read_word(this->base + ONENAND_BOOTRAM + 0x2);
3807
3808 /* Reset OneNAND to read default register values */
3809 this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_BOOTRAM);
3810 /* Wait reset */
3811 this->wait(mtd, FL_RESETING);
3812
3813 /* Restore system configuration 1 */
3814 this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);
3815
3816 /* Check manufacturer ID */
3817 if (onenand_check_maf(bram_maf_id))
3818 return -ENXIO;
3819
3820 /* Read manufacturer and device IDs from Register */
3821 maf_id = this->read_word(this->base + ONENAND_REG_MANUFACTURER_ID);
3822 dev_id = this->read_word(this->base + ONENAND_REG_DEVICE_ID);
3823
3824 /* Check OneNAND device */
3825 if (maf_id != bram_maf_id || dev_id != bram_dev_id)
3826 return -ENXIO;
3827
3828 return 0;
3829 }
3830
3831 /**
3832 * onenand_probe - [OneNAND Interface] Probe the OneNAND device
3833 * @param mtd MTD device structure
3834 */
3835 static int onenand_probe(struct mtd_info *mtd)
3836 {
3837 struct onenand_chip *this = mtd->priv;
3838 int maf_id, dev_id, ver_id;
3839 int density;
3840 int ret;
3841
3842 ret = this->chip_probe(mtd);
3843 if (ret)
3844 return ret;
3845
3846 /* Read manufacturer and device IDs from Register */
3847 maf_id = this->read_word(this->base + ONENAND_REG_MANUFACTURER_ID);
3848 dev_id = this->read_word(this->base + ONENAND_REG_DEVICE_ID);
3849 ver_id = this->read_word(this->base + ONENAND_REG_VERSION_ID);
3850 this->technology = this->read_word(this->base + ONENAND_REG_TECHNOLOGY);
3851
3852 /* Flash device information */
3853 onenand_print_device_info(dev_id, ver_id);
3854 this->device_id = dev_id;
3855 this->version_id = ver_id;
3856
3857 /* Check OneNAND features */
3858 onenand_check_features(mtd);
3859
3860 density = onenand_get_density(dev_id);
3861 if (FLEXONENAND(this)) {
3862 this->dies = ONENAND_IS_DDP(this) ? 2 : 1;
3863 /* Maximum possible erase regions */
3864 mtd->numeraseregions = this->dies << 1;
3865 mtd->eraseregions = kzalloc(sizeof(struct mtd_erase_region_info)
3866 * (this->dies << 1), GFP_KERNEL);
3867 if (!mtd->eraseregions)
3868 return -ENOMEM;
3869 }
3870
3871 /*
3872 * For Flex-OneNAND, chipsize represents maximum possible device size.
3873 * mtd->size represents the actual device size.
3874 */
3875 this->chipsize = (16 << density) << 20;
3876
3877 /* OneNAND page size & block size */
3878 /* The data buffer size is equal to page size */
3879 mtd->writesize = this->read_word(this->base + ONENAND_REG_DATA_BUFFER_SIZE);
3880 /* We use the full BufferRAM */
3881 if (ONENAND_IS_4KB_PAGE(this))
3882 mtd->writesize <<= 1;
3883
3884 mtd->oobsize = mtd->writesize >> 5;
3885 /* Pages per a block are always 64 in OneNAND */
3886 mtd->erasesize = mtd->writesize << 6;
3887 /*
3888 * Flex-OneNAND SLC area has 64 pages per block.
3889 * Flex-OneNAND MLC area has 128 pages per block.
3890 * Expose MLC erase size to find erase_shift and page_mask.
3891 */
3892 if (FLEXONENAND(this))
3893 mtd->erasesize <<= 1;
3894
3895 this->erase_shift = ffs(mtd->erasesize) - 1;
3896 this->page_shift = ffs(mtd->writesize) - 1;
3897 this->page_mask = (1 << (this->erase_shift - this->page_shift)) - 1;
3898 /* Set density mask. it is used for DDP */
3899 if (ONENAND_IS_DDP(this))
3900 this->density_mask = this->chipsize >> (this->erase_shift + 1);
3901 /* It's real page size */
3902 this->writesize = mtd->writesize;
3903
3904 /* REVISIT: Multichip handling */
3905
3906 if (FLEXONENAND(this))
3907 flexonenand_get_size(mtd);
3908 else
3909 mtd->size = this->chipsize;
3910
3911 /*
3912 * We emulate the 4KiB page and 256KiB erase block size
3913 * But oobsize is still 64 bytes.
3914 * It is only valid if you turn on 2X program support,
3915 * Otherwise it will be ignored by compiler.
3916 */
3917 if (ONENAND_IS_2PLANE(this)) {
3918 mtd->writesize <<= 1;
3919 mtd->erasesize <<= 1;
3920 }
3921
3922 return 0;
3923 }
3924
3925 /**
3926 * onenand_suspend - [MTD Interface] Suspend the OneNAND flash
3927 * @param mtd MTD device structure
3928 */
3929 static int onenand_suspend(struct mtd_info *mtd)
3930 {
3931 return onenand_get_device(mtd, FL_PM_SUSPENDED);
3932 }
3933
3934 /**
3935 * onenand_resume - [MTD Interface] Resume the OneNAND flash
3936 * @param mtd MTD device structure
3937 */
3938 static void onenand_resume(struct mtd_info *mtd)
3939 {
3940 struct onenand_chip *this = mtd->priv;
3941
3942 if (this->state == FL_PM_SUSPENDED)
3943 onenand_release_device(mtd);
3944 else
3945 printk(KERN_ERR "%s: resume() called for the chip which is not "
3946 "in suspended state\n", __func__);
3947 }
3948
3949 /**
3950 * onenand_scan - [OneNAND Interface] Scan for the OneNAND device
3951 * @param mtd MTD device structure
3952 * @param maxchips Number of chips to scan for
3953 *
3954 * This fills out all the not initialized function pointers
3955 * with the defaults.
3956 * The flash ID is read and the mtd/chip structures are
3957 * filled with the appropriate values.
3958 */
3959 int onenand_scan(struct mtd_info *mtd, int maxchips)
3960 {
3961 int i, ret;
3962 struct onenand_chip *this = mtd->priv;
3963
3964 if (!this->read_word)
3965 this->read_word = onenand_readw;
3966 if (!this->write_word)
3967 this->write_word = onenand_writew;
3968
3969 if (!this->command)
3970 this->command = onenand_command;
3971 if (!this->wait)
3972 onenand_setup_wait(mtd);
3973 if (!this->bbt_wait)
3974 this->bbt_wait = onenand_bbt_wait;
3975 if (!this->unlock_all)
3976 this->unlock_all = onenand_unlock_all;
3977
3978 if (!this->chip_probe)
3979 this->chip_probe = onenand_chip_probe;
3980
3981 if (!this->read_bufferram)
3982 this->read_bufferram = onenand_read_bufferram;
3983 if (!this->write_bufferram)
3984 this->write_bufferram = onenand_write_bufferram;
3985
3986 if (!this->block_markbad)
3987 this->block_markbad = onenand_default_block_markbad;
3988 if (!this->scan_bbt)
3989 this->scan_bbt = onenand_default_bbt;
3990
3991 if (onenand_probe(mtd))
3992 return -ENXIO;
3993
3994 /* Set Sync. Burst Read after probing */
3995 if (this->mmcontrol) {
3996 printk(KERN_INFO "OneNAND Sync. Burst Read support\n");
3997 this->read_bufferram = onenand_sync_read_bufferram;
3998 }
3999
4000 /* Allocate buffers, if necessary */
4001 if (!this->page_buf) {
4002 this->page_buf = kzalloc(mtd->writesize, GFP_KERNEL);
4003 if (!this->page_buf) {
4004 printk(KERN_ERR "%s: Can't allocate page_buf\n",
4005 __func__);
4006 return -ENOMEM;
4007 }
4008 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
4009 this->verify_buf = kzalloc(mtd->writesize, GFP_KERNEL);
4010 if (!this->verify_buf) {
4011 kfree(this->page_buf);
4012 return -ENOMEM;
4013 }
4014 #endif
4015 this->options |= ONENAND_PAGEBUF_ALLOC;
4016 }
4017 if (!this->oob_buf) {
4018 this->oob_buf = kzalloc(mtd->oobsize, GFP_KERNEL);
4019 if (!this->oob_buf) {
4020 printk(KERN_ERR "%s: Can't allocate oob_buf\n",
4021 __func__);
4022 if (this->options & ONENAND_PAGEBUF_ALLOC) {
4023 this->options &= ~ONENAND_PAGEBUF_ALLOC;
4024 kfree(this->page_buf);
4025 }
4026 return -ENOMEM;
4027 }
4028 this->options |= ONENAND_OOBBUF_ALLOC;
4029 }
4030
4031 this->state = FL_READY;
4032 init_waitqueue_head(&this->wq);
4033 spin_lock_init(&this->chip_lock);
4034
4035 /*
4036 * Allow subpage writes up to oobsize.
4037 */
4038 switch (mtd->oobsize) {
4039 case 128:
4040 if (FLEXONENAND(this)) {
4041 this->ecclayout = &flexonenand_oob_128;
4042 mtd->subpage_sft = 0;
4043 } else {
4044 this->ecclayout = &onenand_oob_128;
4045 mtd->subpage_sft = 2;
4046 }
4047 if (ONENAND_IS_NOP_1(this))
4048 mtd->subpage_sft = 0;
4049 break;
4050 case 64:
4051 this->ecclayout = &onenand_oob_64;
4052 mtd->subpage_sft = 2;
4053 break;
4054
4055 case 32:
4056 this->ecclayout = &onenand_oob_32;
4057 mtd->subpage_sft = 1;
4058 break;
4059
4060 default:
4061 printk(KERN_WARNING "%s: No OOB scheme defined for oobsize %d\n",
4062 __func__, mtd->oobsize);
4063 mtd->subpage_sft = 0;
4064 /* To prevent kernel oops */
4065 this->ecclayout = &onenand_oob_32;
4066 break;
4067 }
4068
4069 this->subpagesize = mtd->writesize >> mtd->subpage_sft;
4070
4071 /*
4072 * The number of bytes available for a client to place data into
4073 * the out of band area
4074 */
4075 this->ecclayout->oobavail = 0;
4076 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES &&
4077 this->ecclayout->oobfree[i].length; i++)
4078 this->ecclayout->oobavail +=
4079 this->ecclayout->oobfree[i].length;
4080 mtd->oobavail = this->ecclayout->oobavail;
4081
4082 mtd->ecclayout = this->ecclayout;
4083 mtd->ecc_strength = 1;
4084
4085 /* Fill in remaining MTD driver data */
4086 mtd->type = ONENAND_IS_MLC(this) ? MTD_MLCNANDFLASH : MTD_NANDFLASH;
4087 mtd->flags = MTD_CAP_NANDFLASH;
4088 mtd->_erase = onenand_erase;
4089 mtd->_point = NULL;
4090 mtd->_unpoint = NULL;
4091 mtd->_read = onenand_read;
4092 mtd->_write = onenand_write;
4093 mtd->_read_oob = onenand_read_oob;
4094 mtd->_write_oob = onenand_write_oob;
4095 mtd->_panic_write = onenand_panic_write;
4096 #ifdef CONFIG_MTD_ONENAND_OTP
4097 mtd->_get_fact_prot_info = onenand_get_fact_prot_info;
4098 mtd->_read_fact_prot_reg = onenand_read_fact_prot_reg;
4099 mtd->_get_user_prot_info = onenand_get_user_prot_info;
4100 mtd->_read_user_prot_reg = onenand_read_user_prot_reg;
4101 mtd->_write_user_prot_reg = onenand_write_user_prot_reg;
4102 mtd->_lock_user_prot_reg = onenand_lock_user_prot_reg;
4103 #endif
4104 mtd->_sync = onenand_sync;
4105 mtd->_lock = onenand_lock;
4106 mtd->_unlock = onenand_unlock;
4107 mtd->_suspend = onenand_suspend;
4108 mtd->_resume = onenand_resume;
4109 mtd->_block_isbad = onenand_block_isbad;
4110 mtd->_block_markbad = onenand_block_markbad;
4111 mtd->owner = THIS_MODULE;
4112 mtd->writebufsize = mtd->writesize;
4113
4114 /* Unlock whole block */
4115 if (!(this->options & ONENAND_SKIP_INITIAL_UNLOCKING))
4116 this->unlock_all(mtd);
4117
4118 ret = this->scan_bbt(mtd);
4119 if ((!FLEXONENAND(this)) || ret)
4120 return ret;
4121
4122 /* Change Flex-OneNAND boundaries if required */
4123 for (i = 0; i < MAX_DIES; i++)
4124 flexonenand_set_boundary(mtd, i, flex_bdry[2 * i],
4125 flex_bdry[(2 * i) + 1]);
4126
4127 return 0;
4128 }
4129
4130 /**
4131 * onenand_release - [OneNAND Interface] Free resources held by the OneNAND device
4132 * @param mtd MTD device structure
4133 */
4134 void onenand_release(struct mtd_info *mtd)
4135 {
4136 struct onenand_chip *this = mtd->priv;
4137
4138 /* Deregister partitions */
4139 mtd_device_unregister(mtd);
4140
4141 /* Free bad block table memory, if allocated */
4142 if (this->bbm) {
4143 struct bbm_info *bbm = this->bbm;
4144 kfree(bbm->bbt);
4145 kfree(this->bbm);
4146 }
4147 /* Buffers allocated by onenand_scan */
4148 if (this->options & ONENAND_PAGEBUF_ALLOC) {
4149 kfree(this->page_buf);
4150 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
4151 kfree(this->verify_buf);
4152 #endif
4153 }
4154 if (this->options & ONENAND_OOBBUF_ALLOC)
4155 kfree(this->oob_buf);
4156 kfree(mtd->eraseregions);
4157 }
4158
4159 EXPORT_SYMBOL_GPL(onenand_scan);
4160 EXPORT_SYMBOL_GPL(onenand_release);
4161
4162 MODULE_LICENSE("GPL");
4163 MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>");
4164 MODULE_DESCRIPTION("Generic OneNAND flash driver code");
Linus' kernel tree