?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: usb-storage: unusual_devs update for Super TOP SATA bridge
[linux/fpc-iii.git] / drivers / mtd / onenand / onenand_base.c
blobb3ce12ef359e83777280aff2b6f9fa9d58cc4dc9
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 mtd->ecc_stats.corrected - stats.corrected ? -EUCLEAN : 0;
1205 }
1206
1207 /**
1208 * onenand_read_ops_nolock - [OneNAND Interface] OneNAND read main and/or out-of-band
1209 * @param mtd MTD device structure
1210 * @param from offset to read from
1211 * @param ops: oob operation description structure
1212 *
1213 * OneNAND read main and/or out-of-band data
1214 */
1215 static int onenand_read_ops_nolock(struct mtd_info *mtd, loff_t from,
1216 struct mtd_oob_ops *ops)
1217 {
1218 struct onenand_chip *this = mtd->priv;
1219 struct mtd_ecc_stats stats;
1220 size_t len = ops->len;
1221 size_t ooblen = ops->ooblen;
1222 u_char *buf = ops->datbuf;
1223 u_char *oobbuf = ops->oobbuf;
1224 int read = 0, column, thislen;
1225 int oobread = 0, oobcolumn, thisooblen, oobsize;
1226 int ret = 0, boundary = 0;
1227 int writesize = this->writesize;
1228
1229 pr_debug("%s: from = 0x%08x, len = %i\n", __func__, (unsigned int)from,
1230 (int)len);
1231
1232 if (ops->mode == MTD_OPS_AUTO_OOB)
1233 oobsize = this->ecclayout->oobavail;
1234 else
1235 oobsize = mtd->oobsize;
1236
1237 oobcolumn = from & (mtd->oobsize - 1);
1238
1239 /* Do not allow reads past end of device */
1240 if ((from + len) > mtd->size) {
1241 printk(KERN_ERR "%s: Attempt read beyond end of device\n",
1242 __func__);
1243 ops->retlen = 0;
1244 ops->oobretlen = 0;
1245 return -EINVAL;
1246 }
1247
1248 stats = mtd->ecc_stats;
1249
1250 /* Read-while-load method */
1251
1252 /* Do first load to bufferRAM */
1253 if (read < len) {
1254 if (!onenand_check_bufferram(mtd, from)) {
1255 this->command(mtd, ONENAND_CMD_READ, from, writesize);
1256 ret = this->wait(mtd, FL_READING);
1257 onenand_update_bufferram(mtd, from, !ret);
1258 if (mtd_is_eccerr(ret))
1259 ret = 0;
1260 }
1261 }
1262
1263 thislen = min_t(int, writesize, len - read);
1264 column = from & (writesize - 1);
1265 if (column + thislen > writesize)
1266 thislen = writesize - column;
1267
1268 while (!ret) {
1269 /* If there is more to load then start next load */
1270 from += thislen;
1271 if (read + thislen < len) {
1272 this->command(mtd, ONENAND_CMD_READ, from, writesize);
1273 /*
1274 * Chip boundary handling in DDP
1275 * Now we issued chip 1 read and pointed chip 1
1276 * bufferram so we have to point chip 0 bufferram.
1277 */
1278 if (ONENAND_IS_DDP(this) &&
1279 unlikely(from == (this->chipsize >> 1))) {
1280 this->write_word(ONENAND_DDP_CHIP0, this->base + ONENAND_REG_START_ADDRESS2);
1281 boundary = 1;
1282 } else
1283 boundary = 0;
1284 ONENAND_SET_PREV_BUFFERRAM(this);
1285 }
1286 /* While load is going, read from last bufferRAM */
1287 this->read_bufferram(mtd, ONENAND_DATARAM, buf, column, thislen);
1288
1289 /* Read oob area if needed */
1290 if (oobbuf) {
1291 thisooblen = oobsize - oobcolumn;
1292 thisooblen = min_t(int, thisooblen, ooblen - oobread);
1293
1294 if (ops->mode == MTD_OPS_AUTO_OOB)
1295 onenand_transfer_auto_oob(mtd, oobbuf, oobcolumn, thisooblen);
1296 else
1297 this->read_bufferram(mtd, ONENAND_SPARERAM, oobbuf, oobcolumn, thisooblen);
1298 oobread += thisooblen;
1299 oobbuf += thisooblen;
1300 oobcolumn = 0;
1301 }
1302
1303 /* See if we are done */
1304 read += thislen;
1305 if (read == len)
1306 break;
1307 /* Set up for next read from bufferRAM */
1308 if (unlikely(boundary))
1309 this->write_word(ONENAND_DDP_CHIP1, this->base + ONENAND_REG_START_ADDRESS2);
1310 ONENAND_SET_NEXT_BUFFERRAM(this);
1311 buf += thislen;
1312 thislen = min_t(int, writesize, len - read);
1313 column = 0;
1314 cond_resched();
1315 /* Now wait for load */
1316 ret = this->wait(mtd, FL_READING);
1317 onenand_update_bufferram(mtd, from, !ret);
1318 if (mtd_is_eccerr(ret))
1319 ret = 0;
1320 }
1321
1322 /*
1323 * Return success, if no ECC failures, else -EBADMSG
1324 * fs driver will take care of that, because
1325 * retlen == desired len and result == -EBADMSG
1326 */
1327 ops->retlen = read;
1328 ops->oobretlen = oobread;
1329
1330 if (ret)
1331 return ret;
1332
1333 if (mtd->ecc_stats.failed - stats.failed)
1334 return -EBADMSG;
1335
1336 return mtd->ecc_stats.corrected - stats.corrected ? -EUCLEAN : 0;
1337 }
1338
1339 /**
1340 * onenand_read_oob_nolock - [MTD Interface] OneNAND read out-of-band
1341 * @param mtd MTD device structure
1342 * @param from offset to read from
1343 * @param ops: oob operation description structure
1344 *
1345 * OneNAND read out-of-band data from the spare area
1346 */
1347 static int onenand_read_oob_nolock(struct mtd_info *mtd, loff_t from,
1348 struct mtd_oob_ops *ops)
1349 {
1350 struct onenand_chip *this = mtd->priv;
1351 struct mtd_ecc_stats stats;
1352 int read = 0, thislen, column, oobsize;
1353 size_t len = ops->ooblen;
1354 unsigned int mode = ops->mode;
1355 u_char *buf = ops->oobbuf;
1356 int ret = 0, readcmd;
1357
1358 from += ops->ooboffs;
1359
1360 pr_debug("%s: from = 0x%08x, len = %i\n", __func__, (unsigned int)from,
1361 (int)len);
1362
1363 /* Initialize return length value */
1364 ops->oobretlen = 0;
1365
1366 if (mode == MTD_OPS_AUTO_OOB)
1367 oobsize = this->ecclayout->oobavail;
1368 else
1369 oobsize = mtd->oobsize;
1370
1371 column = from & (mtd->oobsize - 1);
1372
1373 if (unlikely(column >= oobsize)) {
1374 printk(KERN_ERR "%s: Attempted to start read outside oob\n",
1375 __func__);
1376 return -EINVAL;
1377 }
1378
1379 /* Do not allow reads past end of device */
1380 if (unlikely(from >= mtd->size ||
1381 column + len > ((mtd->size >> this->page_shift) -
1382 (from >> this->page_shift)) * oobsize)) {
1383 printk(KERN_ERR "%s: Attempted to read beyond end of device\n",
1384 __func__);
1385 return -EINVAL;
1386 }
1387
1388 stats = mtd->ecc_stats;
1389
1390 readcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1391
1392 while (read < len) {
1393 cond_resched();
1394
1395 thislen = oobsize - column;
1396 thislen = min_t(int, thislen, len);
1397
1398 this->command(mtd, readcmd, from, mtd->oobsize);
1399
1400 onenand_update_bufferram(mtd, from, 0);
1401
1402 ret = this->wait(mtd, FL_READING);
1403 if (unlikely(ret))
1404 ret = onenand_recover_lsb(mtd, from, ret);
1405
1406 if (ret && !mtd_is_eccerr(ret)) {
1407 printk(KERN_ERR "%s: read failed = 0x%x\n",
1408 __func__, ret);
1409 break;
1410 }
1411
1412 if (mode == MTD_OPS_AUTO_OOB)
1413 onenand_transfer_auto_oob(mtd, buf, column, thislen);
1414 else
1415 this->read_bufferram(mtd, ONENAND_SPARERAM, buf, column, thislen);
1416
1417 read += thislen;
1418
1419 if (read == len)
1420 break;
1421
1422 buf += thislen;
1423
1424 /* Read more? */
1425 if (read < len) {
1426 /* Page size */
1427 from += mtd->writesize;
1428 column = 0;
1429 }
1430 }
1431
1432 ops->oobretlen = read;
1433
1434 if (ret)
1435 return ret;
1436
1437 if (mtd->ecc_stats.failed - stats.failed)
1438 return -EBADMSG;
1439
1440 return 0;
1441 }
1442
1443 /**
1444 * onenand_read - [MTD Interface] Read data from flash
1445 * @param mtd MTD device structure
1446 * @param from offset to read from
1447 * @param len number of bytes to read
1448 * @param retlen pointer to variable to store the number of read bytes
1449 * @param buf the databuffer to put data
1450 *
1451 * Read with ecc
1452 */
1453 static int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
1454 size_t *retlen, u_char *buf)
1455 {
1456 struct onenand_chip *this = mtd->priv;
1457 struct mtd_oob_ops ops = {
1458 .len = len,
1459 .ooblen = 0,
1460 .datbuf = buf,
1461 .oobbuf = NULL,
1462 };
1463 int ret;
1464
1465 onenand_get_device(mtd, FL_READING);
1466 ret = ONENAND_IS_4KB_PAGE(this) ?
1467 onenand_mlc_read_ops_nolock(mtd, from, &ops) :
1468 onenand_read_ops_nolock(mtd, from, &ops);
1469 onenand_release_device(mtd);
1470
1471 *retlen = ops.retlen;
1472 return ret;
1473 }
1474
1475 /**
1476 * onenand_read_oob - [MTD Interface] Read main and/or out-of-band
1477 * @param mtd: MTD device structure
1478 * @param from: offset to read from
1479 * @param ops: oob operation description structure
1480
1481 * Read main and/or out-of-band
1482 */
1483 static int onenand_read_oob(struct mtd_info *mtd, loff_t from,
1484 struct mtd_oob_ops *ops)
1485 {
1486 struct onenand_chip *this = mtd->priv;
1487 int ret;
1488
1489 switch (ops->mode) {
1490 case MTD_OPS_PLACE_OOB:
1491 case MTD_OPS_AUTO_OOB:
1492 break;
1493 case MTD_OPS_RAW:
1494 /* Not implemented yet */
1495 default:
1496 return -EINVAL;
1497 }
1498
1499 onenand_get_device(mtd, FL_READING);
1500 if (ops->datbuf)
1501 ret = ONENAND_IS_4KB_PAGE(this) ?
1502 onenand_mlc_read_ops_nolock(mtd, from, ops) :
1503 onenand_read_ops_nolock(mtd, from, ops);
1504 else
1505 ret = onenand_read_oob_nolock(mtd, from, ops);
1506 onenand_release_device(mtd);
1507
1508 return ret;
1509 }
1510
1511 /**
1512 * onenand_bbt_wait - [DEFAULT] wait until the command is done
1513 * @param mtd MTD device structure
1514 * @param state state to select the max. timeout value
1515 *
1516 * Wait for command done.
1517 */
1518 static int onenand_bbt_wait(struct mtd_info *mtd, int state)
1519 {
1520 struct onenand_chip *this = mtd->priv;
1521 unsigned long timeout;
1522 unsigned int interrupt, ctrl, ecc, addr1, addr8;
1523
1524 /* The 20 msec is enough */
1525 timeout = jiffies + msecs_to_jiffies(20);
1526 while (time_before(jiffies, timeout)) {
1527 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1528 if (interrupt & ONENAND_INT_MASTER)
1529 break;
1530 }
1531 /* To get correct interrupt status in timeout case */
1532 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1533 ctrl = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
1534 addr1 = this->read_word(this->base + ONENAND_REG_START_ADDRESS1);
1535 addr8 = this->read_word(this->base + ONENAND_REG_START_ADDRESS8);
1536
1537 if (interrupt & ONENAND_INT_READ) {
1538 ecc = onenand_read_ecc(this);
1539 if (ecc & ONENAND_ECC_2BIT_ALL) {
1540 printk(KERN_DEBUG "%s: ecc 0x%04x ctrl 0x%04x "
1541 "intr 0x%04x addr1 %#x addr8 %#x\n",
1542 __func__, ecc, ctrl, interrupt, addr1, addr8);
1543 return ONENAND_BBT_READ_ECC_ERROR;
1544 }
1545 } else {
1546 printk(KERN_ERR "%s: read timeout! ctrl 0x%04x "
1547 "intr 0x%04x addr1 %#x addr8 %#x\n",
1548 __func__, ctrl, interrupt, addr1, addr8);
1549 return ONENAND_BBT_READ_FATAL_ERROR;
1550 }
1551
1552 /* Initial bad block case: 0x2400 or 0x0400 */
1553 if (ctrl & ONENAND_CTRL_ERROR) {
1554 printk(KERN_DEBUG "%s: ctrl 0x%04x intr 0x%04x addr1 %#x "
1555 "addr8 %#x\n", __func__, ctrl, interrupt, addr1, addr8);
1556 return ONENAND_BBT_READ_ERROR;
1557 }
1558
1559 return 0;
1560 }
1561
1562 /**
1563 * onenand_bbt_read_oob - [MTD Interface] OneNAND read out-of-band for bbt scan
1564 * @param mtd MTD device structure
1565 * @param from offset to read from
1566 * @param ops oob operation description structure
1567 *
1568 * OneNAND read out-of-band data from the spare area for bbt scan
1569 */
1570 int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from,
1571 struct mtd_oob_ops *ops)
1572 {
1573 struct onenand_chip *this = mtd->priv;
1574 int read = 0, thislen, column;
1575 int ret = 0, readcmd;
1576 size_t len = ops->ooblen;
1577 u_char *buf = ops->oobbuf;
1578
1579 pr_debug("%s: from = 0x%08x, len = %zi\n", __func__, (unsigned int)from,
1580 len);
1581
1582 /* Initialize return value */
1583 ops->oobretlen = 0;
1584
1585 /* Do not allow reads past end of device */
1586 if (unlikely((from + len) > mtd->size)) {
1587 printk(KERN_ERR "%s: Attempt read beyond end of device\n",
1588 __func__);
1589 return ONENAND_BBT_READ_FATAL_ERROR;
1590 }
1591
1592 /* Grab the lock and see if the device is available */
1593 onenand_get_device(mtd, FL_READING);
1594
1595 column = from & (mtd->oobsize - 1);
1596
1597 readcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1598
1599 while (read < len) {
1600 cond_resched();
1601
1602 thislen = mtd->oobsize - column;
1603 thislen = min_t(int, thislen, len);
1604
1605 this->command(mtd, readcmd, from, mtd->oobsize);
1606
1607 onenand_update_bufferram(mtd, from, 0);
1608
1609 ret = this->bbt_wait(mtd, FL_READING);
1610 if (unlikely(ret))
1611 ret = onenand_recover_lsb(mtd, from, ret);
1612
1613 if (ret)
1614 break;
1615
1616 this->read_bufferram(mtd, ONENAND_SPARERAM, buf, column, thislen);
1617 read += thislen;
1618 if (read == len)
1619 break;
1620
1621 buf += thislen;
1622
1623 /* Read more? */
1624 if (read < len) {
1625 /* Update Page size */
1626 from += this->writesize;
1627 column = 0;
1628 }
1629 }
1630
1631 /* Deselect and wake up anyone waiting on the device */
1632 onenand_release_device(mtd);
1633
1634 ops->oobretlen = read;
1635 return ret;
1636 }
1637
1638 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
1639 /**
1640 * onenand_verify_oob - [GENERIC] verify the oob contents after a write
1641 * @param mtd MTD device structure
1642 * @param buf the databuffer to verify
1643 * @param to offset to read from
1644 */
1645 static int onenand_verify_oob(struct mtd_info *mtd, const u_char *buf, loff_t to)
1646 {
1647 struct onenand_chip *this = mtd->priv;
1648 u_char *oob_buf = this->oob_buf;
1649 int status, i, readcmd;
1650
1651 readcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1652
1653 this->command(mtd, readcmd, to, mtd->oobsize);
1654 onenand_update_bufferram(mtd, to, 0);
1655 status = this->wait(mtd, FL_READING);
1656 if (status)
1657 return status;
1658
1659 this->read_bufferram(mtd, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize);
1660 for (i = 0; i < mtd->oobsize; i++)
1661 if (buf[i] != 0xFF && buf[i] != oob_buf[i])
1662 return -EBADMSG;
1663
1664 return 0;
1665 }
1666
1667 /**
1668 * onenand_verify - [GENERIC] verify the chip contents after a write
1669 * @param mtd MTD device structure
1670 * @param buf the databuffer to verify
1671 * @param addr offset to read from
1672 * @param len number of bytes to read and compare
1673 */
1674 static int onenand_verify(struct mtd_info *mtd, const u_char *buf, loff_t addr, size_t len)
1675 {
1676 struct onenand_chip *this = mtd->priv;
1677 int ret = 0;
1678 int thislen, column;
1679
1680 column = addr & (this->writesize - 1);
1681
1682 while (len != 0) {
1683 thislen = min_t(int, this->writesize - column, len);
1684
1685 this->command(mtd, ONENAND_CMD_READ, addr, this->writesize);
1686
1687 onenand_update_bufferram(mtd, addr, 0);
1688
1689 ret = this->wait(mtd, FL_READING);
1690 if (ret)
1691 return ret;
1692
1693 onenand_update_bufferram(mtd, addr, 1);
1694
1695 this->read_bufferram(mtd, ONENAND_DATARAM, this->verify_buf, 0, mtd->writesize);
1696
1697 if (memcmp(buf, this->verify_buf + column, thislen))
1698 return -EBADMSG;
1699
1700 len -= thislen;
1701 buf += thislen;
1702 addr += thislen;
1703 column = 0;
1704 }
1705
1706 return 0;
1707 }
1708 #else
1709 #define onenand_verify(...) (0)
1710 #define onenand_verify_oob(...) (0)
1711 #endif
1712
1713 #define NOTALIGNED(x) ((x & (this->subpagesize - 1)) != 0)
1714
1715 static void onenand_panic_wait(struct mtd_info *mtd)
1716 {
1717 struct onenand_chip *this = mtd->priv;
1718 unsigned int interrupt;
1719 int i;
1720
1721 for (i = 0; i < 2000; i++) {
1722 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1723 if (interrupt & ONENAND_INT_MASTER)
1724 break;
1725 udelay(10);
1726 }
1727 }
1728
1729 /**
1730 * onenand_panic_write - [MTD Interface] write buffer to FLASH in a panic context
1731 * @param mtd MTD device structure
1732 * @param to offset to write to
1733 * @param len number of bytes to write
1734 * @param retlen pointer to variable to store the number of written bytes
1735 * @param buf the data to write
1736 *
1737 * Write with ECC
1738 */
1739 static int onenand_panic_write(struct mtd_info *mtd, loff_t to, size_t len,
1740 size_t *retlen, const u_char *buf)
1741 {
1742 struct onenand_chip *this = mtd->priv;
1743 int column, subpage;
1744 int written = 0;
1745 int ret = 0;
1746
1747 if (this->state == FL_PM_SUSPENDED)
1748 return -EBUSY;
1749
1750 /* Wait for any existing operation to clear */
1751 onenand_panic_wait(mtd);
1752
1753 pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsigned int)to,
1754 (int)len);
1755
1756 /* Reject writes, which are not page aligned */
1757 if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) {
1758 printk(KERN_ERR "%s: Attempt to write not page aligned data\n",
1759 __func__);
1760 return -EINVAL;
1761 }
1762
1763 column = to & (mtd->writesize - 1);
1764
1765 /* Loop until all data write */
1766 while (written < len) {
1767 int thislen = min_t(int, mtd->writesize - column, len - written);
1768 u_char *wbuf = (u_char *) buf;
1769
1770 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
1771
1772 /* Partial page write */
1773 subpage = thislen < mtd->writesize;
1774 if (subpage) {
1775 memset(this->page_buf, 0xff, mtd->writesize);
1776 memcpy(this->page_buf + column, buf, thislen);
1777 wbuf = this->page_buf;
1778 }
1779
1780 this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
1781 this->write_bufferram(mtd, ONENAND_SPARERAM, ffchars, 0, mtd->oobsize);
1782
1783 this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
1784
1785 onenand_panic_wait(mtd);
1786
1787 /* In partial page write we don't update bufferram */
1788 onenand_update_bufferram(mtd, to, !ret && !subpage);
1789 if (ONENAND_IS_2PLANE(this)) {
1790 ONENAND_SET_BUFFERRAM1(this);
1791 onenand_update_bufferram(mtd, to + this->writesize, !ret && !subpage);
1792 }
1793
1794 if (ret) {
1795 printk(KERN_ERR "%s: write failed %d\n", __func__, ret);
1796 break;
1797 }
1798
1799 written += thislen;
1800
1801 if (written == len)
1802 break;
1803
1804 column = 0;
1805 to += thislen;
1806 buf += thislen;
1807 }
1808
1809 *retlen = written;
1810 return ret;
1811 }
1812
1813 /**
1814 * onenand_fill_auto_oob - [INTERN] oob auto-placement transfer
1815 * @param mtd MTD device structure
1816 * @param oob_buf oob buffer
1817 * @param buf source address
1818 * @param column oob offset to write to
1819 * @param thislen oob length to write
1820 */
1821 static int onenand_fill_auto_oob(struct mtd_info *mtd, u_char *oob_buf,
1822 const u_char *buf, int column, int thislen)
1823 {
1824 struct onenand_chip *this = mtd->priv;
1825 struct nand_oobfree *free;
1826 int writecol = column;
1827 int writeend = column + thislen;
1828 int lastgap = 0;
1829 unsigned int i;
1830
1831 free = this->ecclayout->oobfree;
1832 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
1833 if (writecol >= lastgap)
1834 writecol += free->offset - lastgap;
1835 if (writeend >= lastgap)
1836 writeend += free->offset - lastgap;
1837 lastgap = free->offset + free->length;
1838 }
1839 free = this->ecclayout->oobfree;
1840 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES && free->length; i++, free++) {
1841 int free_end = free->offset + free->length;
1842 if (free->offset < writeend && free_end > writecol) {
1843 int st = max_t(int,free->offset,writecol);
1844 int ed = min_t(int,free_end,writeend);
1845 int n = ed - st;
1846 memcpy(oob_buf + st, buf, n);
1847 buf += n;
1848 } else if (column == 0)
1849 break;
1850 }
1851 return 0;
1852 }
1853
1854 /**
1855 * onenand_write_ops_nolock - [OneNAND Interface] write main and/or out-of-band
1856 * @param mtd MTD device structure
1857 * @param to offset to write to
1858 * @param ops oob operation description structure
1859 *
1860 * Write main and/or oob with ECC
1861 */
1862 static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
1863 struct mtd_oob_ops *ops)
1864 {
1865 struct onenand_chip *this = mtd->priv;
1866 int written = 0, column, thislen = 0, subpage = 0;
1867 int prev = 0, prevlen = 0, prev_subpage = 0, first = 1;
1868 int oobwritten = 0, oobcolumn, thisooblen, oobsize;
1869 size_t len = ops->len;
1870 size_t ooblen = ops->ooblen;
1871 const u_char *buf = ops->datbuf;
1872 const u_char *oob = ops->oobbuf;
1873 u_char *oobbuf;
1874 int ret = 0, cmd;
1875
1876 pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsigned int)to,
1877 (int)len);
1878
1879 /* Initialize retlen, in case of early exit */
1880 ops->retlen = 0;
1881 ops->oobretlen = 0;
1882
1883 /* Reject writes, which are not page aligned */
1884 if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) {
1885 printk(KERN_ERR "%s: Attempt to write not page aligned data\n",
1886 __func__);
1887 return -EINVAL;
1888 }
1889
1890 /* Check zero length */
1891 if (!len)
1892 return 0;
1893
1894 if (ops->mode == MTD_OPS_AUTO_OOB)
1895 oobsize = this->ecclayout->oobavail;
1896 else
1897 oobsize = mtd->oobsize;
1898
1899 oobcolumn = to & (mtd->oobsize - 1);
1900
1901 column = to & (mtd->writesize - 1);
1902
1903 /* Loop until all data write */
1904 while (1) {
1905 if (written < len) {
1906 u_char *wbuf = (u_char *) buf;
1907
1908 thislen = min_t(int, mtd->writesize - column, len - written);
1909 thisooblen = min_t(int, oobsize - oobcolumn, ooblen - oobwritten);
1910
1911 cond_resched();
1912
1913 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
1914
1915 /* Partial page write */
1916 subpage = thislen < mtd->writesize;
1917 if (subpage) {
1918 memset(this->page_buf, 0xff, mtd->writesize);
1919 memcpy(this->page_buf + column, buf, thislen);
1920 wbuf = this->page_buf;
1921 }
1922
1923 this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
1924
1925 if (oob) {
1926 oobbuf = this->oob_buf;
1927
1928 /* We send data to spare ram with oobsize
1929 * to prevent byte access */
1930 memset(oobbuf, 0xff, mtd->oobsize);
1931 if (ops->mode == MTD_OPS_AUTO_OOB)
1932 onenand_fill_auto_oob(mtd, oobbuf, oob, oobcolumn, thisooblen);
1933 else
1934 memcpy(oobbuf + oobcolumn, oob, thisooblen);
1935
1936 oobwritten += thisooblen;
1937 oob += thisooblen;
1938 oobcolumn = 0;
1939 } else
1940 oobbuf = (u_char *) ffchars;
1941
1942 this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
1943 } else
1944 ONENAND_SET_NEXT_BUFFERRAM(this);
1945
1946 /*
1947 * 2 PLANE, MLC, and Flex-OneNAND do not support
1948 * write-while-program feature.
1949 */
1950 if (!ONENAND_IS_2PLANE(this) && !ONENAND_IS_4KB_PAGE(this) && !first) {
1951 ONENAND_SET_PREV_BUFFERRAM(this);
1952
1953 ret = this->wait(mtd, FL_WRITING);
1954
1955 /* In partial page write we don't update bufferram */
1956 onenand_update_bufferram(mtd, prev, !ret && !prev_subpage);
1957 if (ret) {
1958 written -= prevlen;
1959 printk(KERN_ERR "%s: write failed %d\n",
1960 __func__, ret);
1961 break;
1962 }
1963
1964 if (written == len) {
1965 /* Only check verify write turn on */
1966 ret = onenand_verify(mtd, buf - len, to - len, len);
1967 if (ret)
1968 printk(KERN_ERR "%s: verify failed %d\n",
1969 __func__, ret);
1970 break;
1971 }
1972
1973 ONENAND_SET_NEXT_BUFFERRAM(this);
1974 }
1975
1976 this->ongoing = 0;
1977 cmd = ONENAND_CMD_PROG;
1978
1979 /* Exclude 1st OTP and OTP blocks for cache program feature */
1980 if (ONENAND_IS_CACHE_PROGRAM(this) &&
1981 likely(onenand_block(this, to) != 0) &&
1982 ONENAND_IS_4KB_PAGE(this) &&
1983 ((written + thislen) < len)) {
1984 cmd = ONENAND_CMD_2X_CACHE_PROG;
1985 this->ongoing = 1;
1986 }
1987
1988 this->command(mtd, cmd, to, mtd->writesize);
1989
1990 /*
1991 * 2 PLANE, MLC, and Flex-OneNAND wait here
1992 */
1993 if (ONENAND_IS_2PLANE(this) || ONENAND_IS_4KB_PAGE(this)) {
1994 ret = this->wait(mtd, FL_WRITING);
1995
1996 /* In partial page write we don't update bufferram */
1997 onenand_update_bufferram(mtd, to, !ret && !subpage);
1998 if (ret) {
1999 printk(KERN_ERR "%s: write failed %d\n",
2000 __func__, ret);
2001 break;
2002 }
2003
2004 /* Only check verify write turn on */
2005 ret = onenand_verify(mtd, buf, to, thislen);
2006 if (ret) {
2007 printk(KERN_ERR "%s: verify failed %d\n",
2008 __func__, ret);
2009 break;
2010 }
2011
2012 written += thislen;
2013
2014 if (written == len)
2015 break;
2016
2017 } else
2018 written += thislen;
2019
2020 column = 0;
2021 prev_subpage = subpage;
2022 prev = to;
2023 prevlen = thislen;
2024 to += thislen;
2025 buf += thislen;
2026 first = 0;
2027 }
2028
2029 /* In error case, clear all bufferrams */
2030 if (written != len)
2031 onenand_invalidate_bufferram(mtd, 0, -1);
2032
2033 ops->retlen = written;
2034 ops->oobretlen = oobwritten;
2035
2036 return ret;
2037 }
2038
2039
2040 /**
2041 * onenand_write_oob_nolock - [INTERN] OneNAND write out-of-band
2042 * @param mtd MTD device structure
2043 * @param to offset to write to
2044 * @param len number of bytes to write
2045 * @param retlen pointer to variable to store the number of written bytes
2046 * @param buf the data to write
2047 * @param mode operation mode
2048 *
2049 * OneNAND write out-of-band
2050 */
2051 static int onenand_write_oob_nolock(struct mtd_info *mtd, loff_t to,
2052 struct mtd_oob_ops *ops)
2053 {
2054 struct onenand_chip *this = mtd->priv;
2055 int column, ret = 0, oobsize;
2056 int written = 0, oobcmd;
2057 u_char *oobbuf;
2058 size_t len = ops->ooblen;
2059 const u_char *buf = ops->oobbuf;
2060 unsigned int mode = ops->mode;
2061
2062 to += ops->ooboffs;
2063
2064 pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsigned int)to,
2065 (int)len);
2066
2067 /* Initialize retlen, in case of early exit */
2068 ops->oobretlen = 0;
2069
2070 if (mode == MTD_OPS_AUTO_OOB)
2071 oobsize = this->ecclayout->oobavail;
2072 else
2073 oobsize = mtd->oobsize;
2074
2075 column = to & (mtd->oobsize - 1);
2076
2077 if (unlikely(column >= oobsize)) {
2078 printk(KERN_ERR "%s: Attempted to start write outside oob\n",
2079 __func__);
2080 return -EINVAL;
2081 }
2082
2083 /* For compatibility with NAND: Do not allow write past end of page */
2084 if (unlikely(column + len > oobsize)) {
2085 printk(KERN_ERR "%s: Attempt to write past end of page\n",
2086 __func__);
2087 return -EINVAL;
2088 }
2089
2090 /* Do not allow reads past end of device */
2091 if (unlikely(to >= mtd->size ||
2092 column + len > ((mtd->size >> this->page_shift) -
2093 (to >> this->page_shift)) * oobsize)) {
2094 printk(KERN_ERR "%s: Attempted to write past end of device\n",
2095 __func__);
2096 return -EINVAL;
2097 }
2098
2099 oobbuf = this->oob_buf;
2100
2101 oobcmd = ONENAND_IS_4KB_PAGE(this) ? ONENAND_CMD_PROG : ONENAND_CMD_PROGOOB;
2102
2103 /* Loop until all data write */
2104 while (written < len) {
2105 int thislen = min_t(int, oobsize, len - written);
2106
2107 cond_resched();
2108
2109 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, mtd->oobsize);
2110
2111 /* We send data to spare ram with oobsize
2112 * to prevent byte access */
2113 memset(oobbuf, 0xff, mtd->oobsize);
2114 if (mode == MTD_OPS_AUTO_OOB)
2115 onenand_fill_auto_oob(mtd, oobbuf, buf, column, thislen);
2116 else
2117 memcpy(oobbuf + column, buf, thislen);
2118 this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
2119
2120 if (ONENAND_IS_4KB_PAGE(this)) {
2121 /* Set main area of DataRAM to 0xff*/
2122 memset(this->page_buf, 0xff, mtd->writesize);
2123 this->write_bufferram(mtd, ONENAND_DATARAM,
2124 this->page_buf, 0, mtd->writesize);
2125 }
2126
2127 this->command(mtd, oobcmd, to, mtd->oobsize);
2128
2129 onenand_update_bufferram(mtd, to, 0);
2130 if (ONENAND_IS_2PLANE(this)) {
2131 ONENAND_SET_BUFFERRAM1(this);
2132 onenand_update_bufferram(mtd, to + this->writesize, 0);
2133 }
2134
2135 ret = this->wait(mtd, FL_WRITING);
2136 if (ret) {
2137 printk(KERN_ERR "%s: write failed %d\n", __func__, ret);
2138 break;
2139 }
2140
2141 ret = onenand_verify_oob(mtd, oobbuf, to);
2142 if (ret) {
2143 printk(KERN_ERR "%s: verify failed %d\n",
2144 __func__, ret);
2145 break;
2146 }
2147
2148 written += thislen;
2149 if (written == len)
2150 break;
2151
2152 to += mtd->writesize;
2153 buf += thislen;
2154 column = 0;
2155 }
2156
2157 ops->oobretlen = written;
2158
2159 return ret;
2160 }
2161
2162 /**
2163 * onenand_write - [MTD Interface] write buffer to FLASH
2164 * @param mtd MTD device structure
2165 * @param to offset to write to
2166 * @param len number of bytes to write
2167 * @param retlen pointer to variable to store the number of written bytes
2168 * @param buf the data to write
2169 *
2170 * Write with ECC
2171 */
2172 static int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
2173 size_t *retlen, const u_char *buf)
2174 {
2175 struct mtd_oob_ops ops = {
2176 .len = len,
2177 .ooblen = 0,
2178 .datbuf = (u_char *) buf,
2179 .oobbuf = NULL,
2180 };
2181 int ret;
2182
2183 onenand_get_device(mtd, FL_WRITING);
2184 ret = onenand_write_ops_nolock(mtd, to, &ops);
2185 onenand_release_device(mtd);
2186
2187 *retlen = ops.retlen;
2188 return ret;
2189 }
2190
2191 /**
2192 * onenand_write_oob - [MTD Interface] NAND write data and/or out-of-band
2193 * @param mtd: MTD device structure
2194 * @param to: offset to write
2195 * @param ops: oob operation description structure
2196 */
2197 static int onenand_write_oob(struct mtd_info *mtd, loff_t to,
2198 struct mtd_oob_ops *ops)
2199 {
2200 int ret;
2201
2202 switch (ops->mode) {
2203 case MTD_OPS_PLACE_OOB:
2204 case MTD_OPS_AUTO_OOB:
2205 break;
2206 case MTD_OPS_RAW:
2207 /* Not implemented yet */
2208 default:
2209 return -EINVAL;
2210 }
2211
2212 onenand_get_device(mtd, FL_WRITING);
2213 if (ops->datbuf)
2214 ret = onenand_write_ops_nolock(mtd, to, ops);
2215 else
2216 ret = onenand_write_oob_nolock(mtd, to, ops);
2217 onenand_release_device(mtd);
2218
2219 return ret;
2220 }
2221
2222 /**
2223 * onenand_block_isbad_nolock - [GENERIC] Check if a block is marked bad
2224 * @param mtd MTD device structure
2225 * @param ofs offset from device start
2226 * @param allowbbt 1, if its allowed to access the bbt area
2227 *
2228 * Check, if the block is bad. Either by reading the bad block table or
2229 * calling of the scan function.
2230 */
2231 static int onenand_block_isbad_nolock(struct mtd_info *mtd, loff_t ofs, int allowbbt)
2232 {
2233 struct onenand_chip *this = mtd->priv;
2234 struct bbm_info *bbm = this->bbm;
2235
2236 /* Return info from the table */
2237 return bbm->isbad_bbt(mtd, ofs, allowbbt);
2238 }
2239
2240
2241 static int onenand_multiblock_erase_verify(struct mtd_info *mtd,
2242 struct erase_info *instr)
2243 {
2244 struct onenand_chip *this = mtd->priv;
2245 loff_t addr = instr->addr;
2246 int len = instr->len;
2247 unsigned int block_size = (1 << this->erase_shift);
2248 int ret = 0;
2249
2250 while (len) {
2251 this->command(mtd, ONENAND_CMD_ERASE_VERIFY, addr, block_size);
2252 ret = this->wait(mtd, FL_VERIFYING_ERASE);
2253 if (ret) {
2254 printk(KERN_ERR "%s: Failed verify, block %d\n",
2255 __func__, onenand_block(this, addr));
2256 instr->state = MTD_ERASE_FAILED;
2257 instr->fail_addr = addr;
2258 return -1;
2259 }
2260 len -= block_size;
2261 addr += block_size;
2262 }
2263 return 0;
2264 }
2265
2266 /**
2267 * onenand_multiblock_erase - [INTERN] erase block(s) using multiblock erase
2268 * @param mtd MTD device structure
2269 * @param instr erase instruction
2270 * @param region erase region
2271 *
2272 * Erase one or more blocks up to 64 block at a time
2273 */
2274 static int onenand_multiblock_erase(struct mtd_info *mtd,
2275 struct erase_info *instr,
2276 unsigned int block_size)
2277 {
2278 struct onenand_chip *this = mtd->priv;
2279 loff_t addr = instr->addr;
2280 int len = instr->len;
2281 int eb_count = 0;
2282 int ret = 0;
2283 int bdry_block = 0;
2284
2285 instr->state = MTD_ERASING;
2286
2287 if (ONENAND_IS_DDP(this)) {
2288 loff_t bdry_addr = this->chipsize >> 1;
2289 if (addr < bdry_addr && (addr + len) > bdry_addr)
2290 bdry_block = bdry_addr >> this->erase_shift;
2291 }
2292
2293 /* Pre-check bbs */
2294 while (len) {
2295 /* Check if we have a bad block, we do not erase bad blocks */
2296 if (onenand_block_isbad_nolock(mtd, addr, 0)) {
2297 printk(KERN_WARNING "%s: attempt to erase a bad block "
2298 "at addr 0x%012llx\n",
2299 __func__, (unsigned long long) addr);
2300 instr->state = MTD_ERASE_FAILED;
2301 return -EIO;
2302 }
2303 len -= block_size;
2304 addr += block_size;
2305 }
2306
2307 len = instr->len;
2308 addr = instr->addr;
2309
2310 /* loop over 64 eb batches */
2311 while (len) {
2312 struct erase_info verify_instr = *instr;
2313 int max_eb_count = MB_ERASE_MAX_BLK_COUNT;
2314
2315 verify_instr.addr = addr;
2316 verify_instr.len = 0;
2317
2318 /* do not cross chip boundary */
2319 if (bdry_block) {
2320 int this_block = (addr >> this->erase_shift);
2321
2322 if (this_block < bdry_block) {
2323 max_eb_count = min(max_eb_count,
2324 (bdry_block - this_block));
2325 }
2326 }
2327
2328 eb_count = 0;
2329
2330 while (len > block_size && eb_count < (max_eb_count - 1)) {
2331 this->command(mtd, ONENAND_CMD_MULTIBLOCK_ERASE,
2332 addr, block_size);
2333 onenand_invalidate_bufferram(mtd, addr, block_size);
2334
2335 ret = this->wait(mtd, FL_PREPARING_ERASE);
2336 if (ret) {
2337 printk(KERN_ERR "%s: Failed multiblock erase, "
2338 "block %d\n", __func__,
2339 onenand_block(this, addr));
2340 instr->state = MTD_ERASE_FAILED;
2341 instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
2342 return -EIO;
2343 }
2344
2345 len -= block_size;
2346 addr += block_size;
2347 eb_count++;
2348 }
2349
2350 /* last block of 64-eb series */
2351 cond_resched();
2352 this->command(mtd, ONENAND_CMD_ERASE, addr, block_size);
2353 onenand_invalidate_bufferram(mtd, addr, block_size);
2354
2355 ret = this->wait(mtd, FL_ERASING);
2356 /* Check if it is write protected */
2357 if (ret) {
2358 printk(KERN_ERR "%s: Failed erase, block %d\n",
2359 __func__, onenand_block(this, addr));
2360 instr->state = MTD_ERASE_FAILED;
2361 instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
2362 return -EIO;
2363 }
2364
2365 len -= block_size;
2366 addr += block_size;
2367 eb_count++;
2368
2369 /* verify */
2370 verify_instr.len = eb_count * block_size;
2371 if (onenand_multiblock_erase_verify(mtd, &verify_instr)) {
2372 instr->state = verify_instr.state;
2373 instr->fail_addr = verify_instr.fail_addr;
2374 return -EIO;
2375 }
2376
2377 }
2378 return 0;
2379 }
2380
2381
2382 /**
2383 * onenand_block_by_block_erase - [INTERN] erase block(s) using regular erase
2384 * @param mtd MTD device structure
2385 * @param instr erase instruction
2386 * @param region erase region
2387 * @param block_size erase block size
2388 *
2389 * Erase one or more blocks one block at a time
2390 */
2391 static int onenand_block_by_block_erase(struct mtd_info *mtd,
2392 struct erase_info *instr,
2393 struct mtd_erase_region_info *region,
2394 unsigned int block_size)
2395 {
2396 struct onenand_chip *this = mtd->priv;
2397 loff_t addr = instr->addr;
2398 int len = instr->len;
2399 loff_t region_end = 0;
2400 int ret = 0;
2401
2402 if (region) {
2403 /* region is set for Flex-OneNAND */
2404 region_end = region->offset + region->erasesize * region->numblocks;
2405 }
2406
2407 instr->state = MTD_ERASING;
2408
2409 /* Loop through the blocks */
2410 while (len) {
2411 cond_resched();
2412
2413 /* Check if we have a bad block, we do not erase bad blocks */
2414 if (onenand_block_isbad_nolock(mtd, addr, 0)) {
2415 printk(KERN_WARNING "%s: attempt to erase a bad block "
2416 "at addr 0x%012llx\n",
2417 __func__, (unsigned long long) addr);
2418 instr->state = MTD_ERASE_FAILED;
2419 return -EIO;
2420 }
2421
2422 this->command(mtd, ONENAND_CMD_ERASE, addr, block_size);
2423
2424 onenand_invalidate_bufferram(mtd, addr, block_size);
2425
2426 ret = this->wait(mtd, FL_ERASING);
2427 /* Check, if it is write protected */
2428 if (ret) {
2429 printk(KERN_ERR "%s: Failed erase, block %d\n",
2430 __func__, onenand_block(this, addr));
2431 instr->state = MTD_ERASE_FAILED;
2432 instr->fail_addr = addr;
2433 return -EIO;
2434 }
2435
2436 len -= block_size;
2437 addr += block_size;
2438
2439 if (region && addr == region_end) {
2440 if (!len)
2441 break;
2442 region++;
2443
2444 block_size = region->erasesize;
2445 region_end = region->offset + region->erasesize * region->numblocks;
2446
2447 if (len & (block_size - 1)) {
2448 /* FIXME: This should be handled at MTD partitioning level. */
2449 printk(KERN_ERR "%s: Unaligned address\n",
2450 __func__);
2451 return -EIO;
2452 }
2453 }
2454 }
2455 return 0;
2456 }
2457
2458 /**
2459 * onenand_erase - [MTD Interface] erase block(s)
2460 * @param mtd MTD device structure
2461 * @param instr erase instruction
2462 *
2463 * Erase one or more blocks
2464 */
2465 static int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
2466 {
2467 struct onenand_chip *this = mtd->priv;
2468 unsigned int block_size;
2469 loff_t addr = instr->addr;
2470 loff_t len = instr->len;
2471 int ret = 0;
2472 struct mtd_erase_region_info *region = NULL;
2473 loff_t region_offset = 0;
2474
2475 pr_debug("%s: start=0x%012llx, len=%llu\n", __func__,
2476 (unsigned long long)instr->addr,
2477 (unsigned long long)instr->len);
2478
2479 if (FLEXONENAND(this)) {
2480 /* Find the eraseregion of this address */
2481 int i = flexonenand_region(mtd, addr);
2482
2483 region = &mtd->eraseregions[i];
2484 block_size = region->erasesize;
2485
2486 /* Start address within region must align on block boundary.
2487 * Erase region's start offset is always block start address.
2488 */
2489 region_offset = region->offset;
2490 } else
2491 block_size = 1 << this->erase_shift;
2492
2493 /* Start address must align on block boundary */
2494 if (unlikely((addr - region_offset) & (block_size - 1))) {
2495 printk(KERN_ERR "%s: Unaligned address\n", __func__);
2496 return -EINVAL;
2497 }
2498
2499 /* Length must align on block boundary */
2500 if (unlikely(len & (block_size - 1))) {
2501 printk(KERN_ERR "%s: Length not block aligned\n", __func__);
2502 return -EINVAL;
2503 }
2504
2505 /* Grab the lock and see if the device is available */
2506 onenand_get_device(mtd, FL_ERASING);
2507
2508 if (ONENAND_IS_4KB_PAGE(this) || region ||
2509 instr->len < MB_ERASE_MIN_BLK_COUNT * block_size) {
2510 /* region is set for Flex-OneNAND (no mb erase) */
2511 ret = onenand_block_by_block_erase(mtd, instr,
2512 region, block_size);
2513 } else {
2514 ret = onenand_multiblock_erase(mtd, instr, block_size);
2515 }
2516
2517 /* Deselect and wake up anyone waiting on the device */
2518 onenand_release_device(mtd);
2519
2520 /* Do call back function */
2521 if (!ret) {
2522 instr->state = MTD_ERASE_DONE;
2523 mtd_erase_callback(instr);
2524 }
2525
2526 return ret;
2527 }
2528
2529 /**
2530 * onenand_sync - [MTD Interface] sync
2531 * @param mtd MTD device structure
2532 *
2533 * Sync is actually a wait for chip ready function
2534 */
2535 static void onenand_sync(struct mtd_info *mtd)
2536 {
2537 pr_debug("%s: called\n", __func__);
2538
2539 /* Grab the lock and see if the device is available */
2540 onenand_get_device(mtd, FL_SYNCING);
2541
2542 /* Release it and go back */
2543 onenand_release_device(mtd);
2544 }
2545
2546 /**
2547 * onenand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2548 * @param mtd MTD device structure
2549 * @param ofs offset relative to mtd start
2550 *
2551 * Check whether the block is bad
2552 */
2553 static int onenand_block_isbad(struct mtd_info *mtd, loff_t ofs)
2554 {
2555 int ret;
2556
2557 /* Check for invalid offset */
2558 if (ofs > mtd->size)
2559 return -EINVAL;
2560
2561 onenand_get_device(mtd, FL_READING);
2562 ret = onenand_block_isbad_nolock(mtd, ofs, 0);
2563 onenand_release_device(mtd);
2564 return ret;
2565 }
2566
2567 /**
2568 * onenand_default_block_markbad - [DEFAULT] mark a block bad
2569 * @param mtd MTD device structure
2570 * @param ofs offset from device start
2571 *
2572 * This is the default implementation, which can be overridden by
2573 * a hardware specific driver.
2574 */
2575 static int onenand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
2576 {
2577 struct onenand_chip *this = mtd->priv;
2578 struct bbm_info *bbm = this->bbm;
2579 u_char buf[2] = {0, 0};
2580 struct mtd_oob_ops ops = {
2581 .mode = MTD_OPS_PLACE_OOB,
2582 .ooblen = 2,
2583 .oobbuf = buf,
2584 .ooboffs = 0,
2585 };
2586 int block;
2587
2588 /* Get block number */
2589 block = onenand_block(this, ofs);
2590 if (bbm->bbt)
2591 bbm->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
2592
2593 /* We write two bytes, so we don't have to mess with 16-bit access */
2594 ofs += mtd->oobsize + (bbm->badblockpos & ~0x01);
2595 /* FIXME : What to do when marking SLC block in partition
2596 * with MLC erasesize? For now, it is not advisable to
2597 * create partitions containing both SLC and MLC regions.
2598 */
2599 return onenand_write_oob_nolock(mtd, ofs, &ops);
2600 }
2601
2602 /**
2603 * onenand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2604 * @param mtd MTD device structure
2605 * @param ofs offset relative to mtd start
2606 *
2607 * Mark the block as bad
2608 */
2609 static int onenand_block_markbad(struct mtd_info *mtd, loff_t ofs)
2610 {
2611 int ret;
2612
2613 ret = onenand_block_isbad(mtd, ofs);
2614 if (ret) {
2615 /* If it was bad already, return success and do nothing */
2616 if (ret > 0)
2617 return 0;
2618 return ret;
2619 }
2620
2621 onenand_get_device(mtd, FL_WRITING);
2622 ret = mtd_block_markbad(mtd, ofs);
2623 onenand_release_device(mtd);
2624 return ret;
2625 }
2626
2627 /**
2628 * onenand_do_lock_cmd - [OneNAND Interface] Lock or unlock block(s)
2629 * @param mtd MTD device structure
2630 * @param ofs offset relative to mtd start
2631 * @param len number of bytes to lock or unlock
2632 * @param cmd lock or unlock command
2633 *
2634 * Lock or unlock one or more blocks
2635 */
2636 static int onenand_do_lock_cmd(struct mtd_info *mtd, loff_t ofs, size_t len, int cmd)
2637 {
2638 struct onenand_chip *this = mtd->priv;
2639 int start, end, block, value, status;
2640 int wp_status_mask;
2641
2642 start = onenand_block(this, ofs);
2643 end = onenand_block(this, ofs + len) - 1;
2644
2645 if (cmd == ONENAND_CMD_LOCK)
2646 wp_status_mask = ONENAND_WP_LS;
2647 else
2648 wp_status_mask = ONENAND_WP_US;
2649
2650 /* Continuous lock scheme */
2651 if (this->options & ONENAND_HAS_CONT_LOCK) {
2652 /* Set start block address */
2653 this->write_word(start, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2654 /* Set end block address */
2655 this->write_word(end, this->base + ONENAND_REG_END_BLOCK_ADDRESS);
2656 /* Write lock command */
2657 this->command(mtd, cmd, 0, 0);
2658
2659 /* There's no return value */
2660 this->wait(mtd, FL_LOCKING);
2661
2662 /* Sanity check */
2663 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2664 & ONENAND_CTRL_ONGO)
2665 continue;
2666
2667 /* Check lock status */
2668 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2669 if (!(status & wp_status_mask))
2670 printk(KERN_ERR "%s: wp status = 0x%x\n",
2671 __func__, status);
2672
2673 return 0;
2674 }
2675
2676 /* Block lock scheme */
2677 for (block = start; block < end + 1; block++) {
2678 /* Set block address */
2679 value = onenand_block_address(this, block);
2680 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
2681 /* Select DataRAM for DDP */
2682 value = onenand_bufferram_address(this, block);
2683 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
2684 /* Set start block address */
2685 this->write_word(block, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2686 /* Write lock command */
2687 this->command(mtd, cmd, 0, 0);
2688
2689 /* There's no return value */
2690 this->wait(mtd, FL_LOCKING);
2691
2692 /* Sanity check */
2693 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2694 & ONENAND_CTRL_ONGO)
2695 continue;
2696
2697 /* Check lock status */
2698 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2699 if (!(status & wp_status_mask))
2700 printk(KERN_ERR "%s: block = %d, wp status = 0x%x\n",
2701 __func__, block, status);
2702 }
2703
2704 return 0;
2705 }
2706
2707 /**
2708 * onenand_lock - [MTD Interface] Lock block(s)
2709 * @param mtd MTD device structure
2710 * @param ofs offset relative to mtd start
2711 * @param len number of bytes to unlock
2712 *
2713 * Lock one or more blocks
2714 */
2715 static int onenand_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2716 {
2717 int ret;
2718
2719 onenand_get_device(mtd, FL_LOCKING);
2720 ret = onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_LOCK);
2721 onenand_release_device(mtd);
2722 return ret;
2723 }
2724
2725 /**
2726 * onenand_unlock - [MTD Interface] Unlock block(s)
2727 * @param mtd MTD device structure
2728 * @param ofs offset relative to mtd start
2729 * @param len number of bytes to unlock
2730 *
2731 * Unlock one or more blocks
2732 */
2733 static int onenand_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2734 {
2735 int ret;
2736
2737 onenand_get_device(mtd, FL_LOCKING);
2738 ret = onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_UNLOCK);
2739 onenand_release_device(mtd);
2740 return ret;
2741 }
2742
2743 /**
2744 * onenand_check_lock_status - [OneNAND Interface] Check lock status
2745 * @param this onenand chip data structure
2746 *
2747 * Check lock status
2748 */
2749 static int onenand_check_lock_status(struct onenand_chip *this)
2750 {
2751 unsigned int value, block, status;
2752 unsigned int end;
2753
2754 end = this->chipsize >> this->erase_shift;
2755 for (block = 0; block < end; block++) {
2756 /* Set block address */
2757 value = onenand_block_address(this, block);
2758 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
2759 /* Select DataRAM for DDP */
2760 value = onenand_bufferram_address(this, block);
2761 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
2762 /* Set start block address */
2763 this->write_word(block, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2764
2765 /* Check lock status */
2766 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2767 if (!(status & ONENAND_WP_US)) {
2768 printk(KERN_ERR "%s: block = %d, wp status = 0x%x\n",
2769 __func__, block, status);
2770 return 0;
2771 }
2772 }
2773
2774 return 1;
2775 }
2776
2777 /**
2778 * onenand_unlock_all - [OneNAND Interface] unlock all blocks
2779 * @param mtd MTD device structure
2780 *
2781 * Unlock all blocks
2782 */
2783 static void onenand_unlock_all(struct mtd_info *mtd)
2784 {
2785 struct onenand_chip *this = mtd->priv;
2786 loff_t ofs = 0;
2787 loff_t len = mtd->size;
2788
2789 if (this->options & ONENAND_HAS_UNLOCK_ALL) {
2790 /* Set start block address */
2791 this->write_word(0, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2792 /* Write unlock command */
2793 this->command(mtd, ONENAND_CMD_UNLOCK_ALL, 0, 0);
2794
2795 /* There's no return value */
2796 this->wait(mtd, FL_LOCKING);
2797
2798 /* Sanity check */
2799 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2800 & ONENAND_CTRL_ONGO)
2801 continue;
2802
2803 /* Don't check lock status */
2804 if (this->options & ONENAND_SKIP_UNLOCK_CHECK)
2805 return;
2806
2807 /* Check lock status */
2808 if (onenand_check_lock_status(this))
2809 return;
2810
2811 /* Workaround for all block unlock in DDP */
2812 if (ONENAND_IS_DDP(this) && !FLEXONENAND(this)) {
2813 /* All blocks on another chip */
2814 ofs = this->chipsize >> 1;
2815 len = this->chipsize >> 1;
2816 }
2817 }
2818
2819 onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_UNLOCK);
2820 }
2821
2822 #ifdef CONFIG_MTD_ONENAND_OTP
2823
2824 /**
2825 * onenand_otp_command - Send OTP specific command to OneNAND device
2826 * @param mtd MTD device structure
2827 * @param cmd the command to be sent
2828 * @param addr offset to read from or write to
2829 * @param len number of bytes to read or write
2830 */
2831 static int onenand_otp_command(struct mtd_info *mtd, int cmd, loff_t addr,
2832 size_t len)
2833 {
2834 struct onenand_chip *this = mtd->priv;
2835 int value, block, page;
2836
2837 /* Address translation */
2838 switch (cmd) {
2839 case ONENAND_CMD_OTP_ACCESS:
2840 block = (int) (addr >> this->erase_shift);
2841 page = -1;
2842 break;
2843
2844 default:
2845 block = (int) (addr >> this->erase_shift);
2846 page = (int) (addr >> this->page_shift);
2847
2848 if (ONENAND_IS_2PLANE(this)) {
2849 /* Make the even block number */
2850 block &= ~1;
2851 /* Is it the odd plane? */
2852 if (addr & this->writesize)
2853 block++;
2854 page >>= 1;
2855 }
2856 page &= this->page_mask;
2857 break;
2858 }
2859
2860 if (block != -1) {
2861 /* Write 'DFS, FBA' of Flash */
2862 value = onenand_block_address(this, block);
2863 this->write_word(value, this->base +
2864 ONENAND_REG_START_ADDRESS1);
2865 }
2866
2867 if (page != -1) {
2868 /* Now we use page size operation */
2869 int sectors = 4, count = 4;
2870 int dataram;
2871
2872 switch (cmd) {
2873 default:
2874 if (ONENAND_IS_2PLANE(this) && cmd == ONENAND_CMD_PROG)
2875 cmd = ONENAND_CMD_2X_PROG;
2876 dataram = ONENAND_CURRENT_BUFFERRAM(this);
2877 break;
2878 }
2879
2880 /* Write 'FPA, FSA' of Flash */
2881 value = onenand_page_address(page, sectors);
2882 this->write_word(value, this->base +
2883 ONENAND_REG_START_ADDRESS8);
2884
2885 /* Write 'BSA, BSC' of DataRAM */
2886 value = onenand_buffer_address(dataram, sectors, count);
2887 this->write_word(value, this->base + ONENAND_REG_START_BUFFER);
2888 }
2889
2890 /* Interrupt clear */
2891 this->write_word(ONENAND_INT_CLEAR, this->base + ONENAND_REG_INTERRUPT);
2892
2893 /* Write command */
2894 this->write_word(cmd, this->base + ONENAND_REG_COMMAND);
2895
2896 return 0;
2897 }
2898
2899 /**
2900 * onenand_otp_write_oob_nolock - [INTERN] OneNAND write out-of-band, specific to OTP
2901 * @param mtd MTD device structure
2902 * @param to offset to write to
2903 * @param len number of bytes to write
2904 * @param retlen pointer to variable to store the number of written bytes
2905 * @param buf the data to write
2906 *
2907 * OneNAND write out-of-band only for OTP
2908 */
2909 static int onenand_otp_write_oob_nolock(struct mtd_info *mtd, loff_t to,
2910 struct mtd_oob_ops *ops)
2911 {
2912 struct onenand_chip *this = mtd->priv;
2913 int column, ret = 0, oobsize;
2914 int written = 0;
2915 u_char *oobbuf;
2916 size_t len = ops->ooblen;
2917 const u_char *buf = ops->oobbuf;
2918 int block, value, status;
2919
2920 to += ops->ooboffs;
2921
2922 /* Initialize retlen, in case of early exit */
2923 ops->oobretlen = 0;
2924
2925 oobsize = mtd->oobsize;
2926
2927 column = to & (mtd->oobsize - 1);
2928
2929 oobbuf = this->oob_buf;
2930
2931 /* Loop until all data write */
2932 while (written < len) {
2933 int thislen = min_t(int, oobsize, len - written);
2934
2935 cond_resched();
2936
2937 block = (int) (to >> this->erase_shift);
2938 /*
2939 * Write 'DFS, FBA' of Flash
2940 * Add: F100h DQ=DFS, FBA
2941 */
2942
2943 value = onenand_block_address(this, block);
2944 this->write_word(value, this->base +
2945 ONENAND_REG_START_ADDRESS1);
2946
2947 /*
2948 * Select DataRAM for DDP
2949 * Add: F101h DQ=DBS
2950 */
2951
2952 value = onenand_bufferram_address(this, block);
2953 this->write_word(value, this->base +
2954 ONENAND_REG_START_ADDRESS2);
2955 ONENAND_SET_NEXT_BUFFERRAM(this);
2956
2957 /*
2958 * Enter OTP access mode
2959 */
2960 this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
2961 this->wait(mtd, FL_OTPING);
2962
2963 /* We send data to spare ram with oobsize
2964 * to prevent byte access */
2965 memcpy(oobbuf + column, buf, thislen);
2966
2967 /*
2968 * Write Data into DataRAM
2969 * Add: 8th Word
2970 * in sector0/spare/page0
2971 * DQ=XXFCh
2972 */
2973 this->write_bufferram(mtd, ONENAND_SPARERAM,
2974 oobbuf, 0, mtd->oobsize);
2975
2976 onenand_otp_command(mtd, ONENAND_CMD_PROGOOB, to, mtd->oobsize);
2977 onenand_update_bufferram(mtd, to, 0);
2978 if (ONENAND_IS_2PLANE(this)) {
2979 ONENAND_SET_BUFFERRAM1(this);
2980 onenand_update_bufferram(mtd, to + this->writesize, 0);
2981 }
2982
2983 ret = this->wait(mtd, FL_WRITING);
2984 if (ret) {
2985 printk(KERN_ERR "%s: write failed %d\n", __func__, ret);
2986 break;
2987 }
2988
2989 /* Exit OTP access mode */
2990 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
2991 this->wait(mtd, FL_RESETING);
2992
2993 status = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
2994 status &= 0x60;
2995
2996 if (status == 0x60) {
2997 printk(KERN_DEBUG "\nBLOCK\tSTATUS\n");
2998 printk(KERN_DEBUG "1st Block\tLOCKED\n");
2999 printk(KERN_DEBUG "OTP Block\tLOCKED\n");
3000 } else if (status == 0x20) {
3001 printk(KERN_DEBUG "\nBLOCK\tSTATUS\n");
3002 printk(KERN_DEBUG "1st Block\tLOCKED\n");
3003 printk(KERN_DEBUG "OTP Block\tUN-LOCKED\n");
3004 } else if (status == 0x40) {
3005 printk(KERN_DEBUG "\nBLOCK\tSTATUS\n");
3006 printk(KERN_DEBUG "1st Block\tUN-LOCKED\n");
3007 printk(KERN_DEBUG "OTP Block\tLOCKED\n");
3008 } else {
3009 printk(KERN_DEBUG "Reboot to check\n");
3010 }
3011
3012 written += thislen;
3013 if (written == len)
3014 break;
3015
3016 to += mtd->writesize;
3017 buf += thislen;
3018 column = 0;
3019 }
3020
3021 ops->oobretlen = written;
3022
3023 return ret;
3024 }
3025
3026 /* Internal OTP operation */
3027 typedef int (*otp_op_t)(struct mtd_info *mtd, loff_t form, size_t len,
3028 size_t *retlen, u_char *buf);
3029
3030 /**
3031 * do_otp_read - [DEFAULT] Read OTP block area
3032 * @param mtd MTD device structure
3033 * @param from The offset to read
3034 * @param len number of bytes to read
3035 * @param retlen pointer to variable to store the number of readbytes
3036 * @param buf the databuffer to put/get data
3037 *
3038 * Read OTP block area.
3039 */
3040 static int do_otp_read(struct mtd_info *mtd, loff_t from, size_t len,
3041 size_t *retlen, u_char *buf)
3042 {
3043 struct onenand_chip *this = mtd->priv;
3044 struct mtd_oob_ops ops = {
3045 .len = len,
3046 .ooblen = 0,
3047 .datbuf = buf,
3048 .oobbuf = NULL,
3049 };
3050 int ret;
3051
3052 /* Enter OTP access mode */
3053 this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
3054 this->wait(mtd, FL_OTPING);
3055
3056 ret = ONENAND_IS_4KB_PAGE(this) ?
3057 onenand_mlc_read_ops_nolock(mtd, from, &ops) :
3058 onenand_read_ops_nolock(mtd, from, &ops);
3059
3060 /* Exit OTP access mode */
3061 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3062 this->wait(mtd, FL_RESETING);
3063
3064 return ret;
3065 }
3066
3067 /**
3068 * do_otp_write - [DEFAULT] Write OTP block area
3069 * @param mtd MTD device structure
3070 * @param to The offset to write
3071 * @param len number of bytes to write
3072 * @param retlen pointer to variable to store the number of write bytes
3073 * @param buf the databuffer to put/get data
3074 *
3075 * Write OTP block area.
3076 */
3077 static int do_otp_write(struct mtd_info *mtd, loff_t to, size_t len,
3078 size_t *retlen, u_char *buf)
3079 {
3080 struct onenand_chip *this = mtd->priv;
3081 unsigned char *pbuf = buf;
3082 int ret;
3083 struct mtd_oob_ops ops;
3084
3085 /* Force buffer page aligned */
3086 if (len < mtd->writesize) {
3087 memcpy(this->page_buf, buf, len);
3088 memset(this->page_buf + len, 0xff, mtd->writesize - len);
3089 pbuf = this->page_buf;
3090 len = mtd->writesize;
3091 }
3092
3093 /* Enter OTP access mode */
3094 this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
3095 this->wait(mtd, FL_OTPING);
3096
3097 ops.len = len;
3098 ops.ooblen = 0;
3099 ops.datbuf = pbuf;
3100 ops.oobbuf = NULL;
3101 ret = onenand_write_ops_nolock(mtd, to, &ops);
3102 *retlen = ops.retlen;
3103
3104 /* Exit OTP access mode */
3105 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3106 this->wait(mtd, FL_RESETING);
3107
3108 return ret;
3109 }
3110
3111 /**
3112 * do_otp_lock - [DEFAULT] Lock OTP block area
3113 * @param mtd MTD device structure
3114 * @param from The offset to lock
3115 * @param len number of bytes to lock
3116 * @param retlen pointer to variable to store the number of lock bytes
3117 * @param buf the databuffer to put/get data
3118 *
3119 * Lock OTP block area.
3120 */
3121 static int do_otp_lock(struct mtd_info *mtd, loff_t from, size_t len,
3122 size_t *retlen, u_char *buf)
3123 {
3124 struct onenand_chip *this = mtd->priv;
3125 struct mtd_oob_ops ops;
3126 int ret;
3127
3128 if (FLEXONENAND(this)) {
3129
3130 /* Enter OTP access mode */
3131 this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
3132 this->wait(mtd, FL_OTPING);
3133 /*
3134 * For Flex-OneNAND, we write lock mark to 1st word of sector 4 of
3135 * main area of page 49.
3136 */
3137 ops.len = mtd->writesize;
3138 ops.ooblen = 0;
3139 ops.datbuf = buf;
3140 ops.oobbuf = NULL;
3141 ret = onenand_write_ops_nolock(mtd, mtd->writesize * 49, &ops);
3142 *retlen = ops.retlen;
3143
3144 /* Exit OTP access mode */
3145 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3146 this->wait(mtd, FL_RESETING);
3147 } else {
3148 ops.mode = MTD_OPS_PLACE_OOB;
3149 ops.ooblen = len;
3150 ops.oobbuf = buf;
3151 ops.ooboffs = 0;
3152 ret = onenand_otp_write_oob_nolock(mtd, from, &ops);
3153 *retlen = ops.oobretlen;
3154 }
3155
3156 return ret;
3157 }
3158
3159 /**
3160 * onenand_otp_walk - [DEFAULT] Handle OTP operation
3161 * @param mtd MTD device structure
3162 * @param from The offset to read/write
3163 * @param len number of bytes to read/write
3164 * @param retlen pointer to variable to store the number of read bytes
3165 * @param buf the databuffer to put/get data
3166 * @param action do given action
3167 * @param mode specify user and factory
3168 *
3169 * Handle OTP operation.
3170 */
3171 static int onenand_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
3172 size_t *retlen, u_char *buf,
3173 otp_op_t action, int mode)
3174 {
3175 struct onenand_chip *this = mtd->priv;
3176 int otp_pages;
3177 int density;
3178 int ret = 0;
3179
3180 *retlen = 0;
3181
3182 density = onenand_get_density(this->device_id);
3183 if (density < ONENAND_DEVICE_DENSITY_512Mb)
3184 otp_pages = 20;
3185 else
3186 otp_pages = 50;
3187
3188 if (mode == MTD_OTP_FACTORY) {
3189 from += mtd->writesize * otp_pages;
3190 otp_pages = ONENAND_PAGES_PER_BLOCK - otp_pages;
3191 }
3192
3193 /* Check User/Factory boundary */
3194 if (mode == MTD_OTP_USER) {
3195 if (mtd->writesize * otp_pages < from + len)
3196 return 0;
3197 } else {
3198 if (mtd->writesize * otp_pages < len)
3199 return 0;
3200 }
3201
3202 onenand_get_device(mtd, FL_OTPING);
3203 while (len > 0 && otp_pages > 0) {
3204 if (!action) { /* OTP Info functions */
3205 struct otp_info *otpinfo;
3206
3207 len -= sizeof(struct otp_info);
3208 if (len <= 0) {
3209 ret = -ENOSPC;
3210 break;
3211 }
3212
3213 otpinfo = (struct otp_info *) buf;
3214 otpinfo->start = from;
3215 otpinfo->length = mtd->writesize;
3216 otpinfo->locked = 0;
3217
3218 from += mtd->writesize;
3219 buf += sizeof(struct otp_info);
3220 *retlen += sizeof(struct otp_info);
3221 } else {
3222 size_t tmp_retlen;
3223
3224 ret = action(mtd, from, len, &tmp_retlen, buf);
3225
3226 buf += tmp_retlen;
3227 len -= tmp_retlen;
3228 *retlen += tmp_retlen;
3229
3230 if (ret)
3231 break;
3232 }
3233 otp_pages--;
3234 }
3235 onenand_release_device(mtd);
3236
3237 return ret;
3238 }
3239
3240 /**
3241 * onenand_get_fact_prot_info - [MTD Interface] Read factory OTP info
3242 * @param mtd MTD device structure
3243 * @param buf the databuffer to put/get data
3244 * @param len number of bytes to read
3245 *
3246 * Read factory OTP info.
3247 */
3248 static int onenand_get_fact_prot_info(struct mtd_info *mtd,
3249 struct otp_info *buf, size_t len)
3250 {
3251 size_t retlen;
3252 int ret;
3253
3254 ret = onenand_otp_walk(mtd, 0, len, &retlen, (u_char *) buf, NULL, MTD_OTP_FACTORY);
3255
3256 return ret ? : retlen;
3257 }
3258
3259 /**
3260 * onenand_read_fact_prot_reg - [MTD Interface] Read factory OTP area
3261 * @param mtd MTD device structure
3262 * @param from The offset to read
3263 * @param len number of bytes to read
3264 * @param retlen pointer to variable to store the number of read bytes
3265 * @param buf the databuffer to put/get data
3266 *
3267 * Read factory OTP area.
3268 */
3269 static int onenand_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
3270 size_t len, size_t *retlen, u_char *buf)
3271 {
3272 return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_read, MTD_OTP_FACTORY);
3273 }
3274
3275 /**
3276 * onenand_get_user_prot_info - [MTD Interface] Read user OTP info
3277 * @param mtd MTD device structure
3278 * @param buf the databuffer to put/get data
3279 * @param len number of bytes to read
3280 *
3281 * Read user OTP info.
3282 */
3283 static int onenand_get_user_prot_info(struct mtd_info *mtd,
3284 struct otp_info *buf, size_t len)
3285 {
3286 size_t retlen;
3287 int ret;
3288
3289 ret = onenand_otp_walk(mtd, 0, len, &retlen, (u_char *) buf, NULL, MTD_OTP_USER);
3290
3291 return ret ? : retlen;
3292 }
3293
3294 /**
3295 * onenand_read_user_prot_reg - [MTD Interface] Read user OTP area
3296 * @param mtd MTD device structure
3297 * @param from The offset to read
3298 * @param len number of bytes to read
3299 * @param retlen pointer to variable to store the number of read bytes
3300 * @param buf the databuffer to put/get data
3301 *
3302 * Read user OTP area.
3303 */
3304 static int onenand_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
3305 size_t len, size_t *retlen, u_char *buf)
3306 {
3307 return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_read, MTD_OTP_USER);
3308 }
3309
3310 /**
3311 * onenand_write_user_prot_reg - [MTD Interface] Write user OTP area
3312 * @param mtd MTD device structure
3313 * @param from The offset to write
3314 * @param len number of bytes to write
3315 * @param retlen pointer to variable to store the number of write bytes
3316 * @param buf the databuffer to put/get data
3317 *
3318 * Write user OTP area.
3319 */
3320 static int onenand_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
3321 size_t len, size_t *retlen, u_char *buf)
3322 {
3323 return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_write, MTD_OTP_USER);
3324 }
3325
3326 /**
3327 * onenand_lock_user_prot_reg - [MTD Interface] Lock user OTP area
3328 * @param mtd MTD device structure
3329 * @param from The offset to lock
3330 * @param len number of bytes to unlock
3331 *
3332 * Write lock mark on spare area in page 0 in OTP block
3333 */
3334 static int onenand_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
3335 size_t len)
3336 {
3337 struct onenand_chip *this = mtd->priv;
3338 u_char *buf = FLEXONENAND(this) ? this->page_buf : this->oob_buf;
3339 size_t retlen;
3340 int ret;
3341 unsigned int otp_lock_offset = ONENAND_OTP_LOCK_OFFSET;
3342
3343 memset(buf, 0xff, FLEXONENAND(this) ? this->writesize
3344 : mtd->oobsize);
3345 /*
3346 * Write lock mark to 8th word of sector0 of page0 of the spare0.
3347 * We write 16 bytes spare area instead of 2 bytes.
3348 * For Flex-OneNAND, we write lock mark to 1st word of sector 4 of
3349 * main area of page 49.
3350 */
3351
3352 from = 0;
3353 len = FLEXONENAND(this) ? mtd->writesize : 16;
3354
3355 /*
3356 * Note: OTP lock operation
3357 * OTP block : 0xXXFC XX 1111 1100
3358 * 1st block : 0xXXF3 (If chip support) XX 1111 0011
3359 * Both : 0xXXF0 (If chip support) XX 1111 0000
3360 */
3361 if (FLEXONENAND(this))
3362 otp_lock_offset = FLEXONENAND_OTP_LOCK_OFFSET;
3363
3364 /* ONENAND_OTP_AREA | ONENAND_OTP_BLOCK0 | ONENAND_OTP_AREA_BLOCK0 */
3365 if (otp == 1)
3366 buf[otp_lock_offset] = 0xFC;
3367 else if (otp == 2)
3368 buf[otp_lock_offset] = 0xF3;
3369 else if (otp == 3)
3370 buf[otp_lock_offset] = 0xF0;
3371 else if (otp != 0)
3372 printk(KERN_DEBUG "[OneNAND] Invalid option selected for OTP\n");
3373
3374 ret = onenand_otp_walk(mtd, from, len, &retlen, buf, do_otp_lock, MTD_OTP_USER);
3375
3376 return ret ? : retlen;
3377 }
3378
3379 #endif /* CONFIG_MTD_ONENAND_OTP */
3380
3381 /**
3382 * onenand_check_features - Check and set OneNAND features
3383 * @param mtd MTD data structure
3384 *
3385 * Check and set OneNAND features
3386 * - lock scheme
3387 * - two plane
3388 */
3389 static void onenand_check_features(struct mtd_info *mtd)
3390 {
3391 struct onenand_chip *this = mtd->priv;
3392 unsigned int density, process, numbufs;
3393
3394 /* Lock scheme depends on density and process */
3395 density = onenand_get_density(this->device_id);
3396 process = this->version_id >> ONENAND_VERSION_PROCESS_SHIFT;
3397 numbufs = this->read_word(this->base + ONENAND_REG_NUM_BUFFERS) >> 8;
3398
3399 /* Lock scheme */
3400 switch (density) {
3401 case ONENAND_DEVICE_DENSITY_4Gb:
3402 if (ONENAND_IS_DDP(this))
3403 this->options |= ONENAND_HAS_2PLANE;
3404 else if (numbufs == 1) {
3405 this->options |= ONENAND_HAS_4KB_PAGE;
3406 this->options |= ONENAND_HAS_CACHE_PROGRAM;
3407 /*
3408 * There are two different 4KiB pagesize chips
3409 * and no way to detect it by H/W config values.
3410 *
3411 * To detect the correct NOP for each chips,
3412 * It should check the version ID as workaround.
3413 *
3414 * Now it has as following
3415 * KFM4G16Q4M has NOP 4 with version ID 0x0131
3416 * KFM4G16Q5M has NOP 1 with versoin ID 0x013e
3417 */
3418 if ((this->version_id & 0xf) == 0xe)
3419 this->options |= ONENAND_HAS_NOP_1;
3420 }
3421
3422 case ONENAND_DEVICE_DENSITY_2Gb:
3423 /* 2Gb DDP does not have 2 plane */
3424 if (!ONENAND_IS_DDP(this))
3425 this->options |= ONENAND_HAS_2PLANE;
3426 this->options |= ONENAND_HAS_UNLOCK_ALL;
3427
3428 case ONENAND_DEVICE_DENSITY_1Gb:
3429 /* A-Die has all block unlock */
3430 if (process)
3431 this->options |= ONENAND_HAS_UNLOCK_ALL;
3432 break;
3433
3434 default:
3435 /* Some OneNAND has continuous lock scheme */
3436 if (!process)
3437 this->options |= ONENAND_HAS_CONT_LOCK;
3438 break;
3439 }
3440
3441 /* The MLC has 4KiB pagesize. */
3442 if (ONENAND_IS_MLC(this))
3443 this->options |= ONENAND_HAS_4KB_PAGE;
3444
3445 if (ONENAND_IS_4KB_PAGE(this))
3446 this->options &= ~ONENAND_HAS_2PLANE;
3447
3448 if (FLEXONENAND(this)) {
3449 this->options &= ~ONENAND_HAS_CONT_LOCK;
3450 this->options |= ONENAND_HAS_UNLOCK_ALL;
3451 }
3452
3453 if (this->options & ONENAND_HAS_CONT_LOCK)
3454 printk(KERN_DEBUG "Lock scheme is Continuous Lock\n");
3455 if (this->options & ONENAND_HAS_UNLOCK_ALL)
3456 printk(KERN_DEBUG "Chip support all block unlock\n");
3457 if (this->options & ONENAND_HAS_2PLANE)
3458 printk(KERN_DEBUG "Chip has 2 plane\n");
3459 if (this->options & ONENAND_HAS_4KB_PAGE)
3460 printk(KERN_DEBUG "Chip has 4KiB pagesize\n");
3461 if (this->options & ONENAND_HAS_CACHE_PROGRAM)
3462 printk(KERN_DEBUG "Chip has cache program feature\n");
3463 }
3464
3465 /**
3466 * onenand_print_device_info - Print device & version ID
3467 * @param device device ID
3468 * @param version version ID
3469 *
3470 * Print device & version ID
3471 */
3472 static void onenand_print_device_info(int device, int version)
3473 {
3474 int vcc, demuxed, ddp, density, flexonenand;
3475
3476 vcc = device & ONENAND_DEVICE_VCC_MASK;
3477 demuxed = device & ONENAND_DEVICE_IS_DEMUX;
3478 ddp = device & ONENAND_DEVICE_IS_DDP;
3479 density = onenand_get_density(device);
3480 flexonenand = device & DEVICE_IS_FLEXONENAND;
3481 printk(KERN_INFO "%s%sOneNAND%s %dMB %sV 16-bit (0x%02x)\n",
3482 demuxed ? "" : "Muxed ",
3483 flexonenand ? "Flex-" : "",
3484 ddp ? "(DDP)" : "",
3485 (16 << density),
3486 vcc ? "2.65/3.3" : "1.8",
3487 device);
3488 printk(KERN_INFO "OneNAND version = 0x%04x\n", version);
3489 }
3490
3491 static const struct onenand_manufacturers onenand_manuf_ids[] = {
3492 {ONENAND_MFR_SAMSUNG, "Samsung"},
3493 {ONENAND_MFR_NUMONYX, "Numonyx"},
3494 };
3495
3496 /**
3497 * onenand_check_maf - Check manufacturer ID
3498 * @param manuf manufacturer ID
3499 *
3500 * Check manufacturer ID
3501 */
3502 static int onenand_check_maf(int manuf)
3503 {
3504 int size = ARRAY_SIZE(onenand_manuf_ids);
3505 char *name;
3506 int i;
3507
3508 for (i = 0; i < size; i++)
3509 if (manuf == onenand_manuf_ids[i].id)
3510 break;
3511
3512 if (i < size)
3513 name = onenand_manuf_ids[i].name;
3514 else
3515 name = "Unknown";
3516
3517 printk(KERN_DEBUG "OneNAND Manufacturer: %s (0x%0x)\n", name, manuf);
3518
3519 return (i == size);
3520 }
3521
3522 /**
3523 * flexonenand_get_boundary - Reads the SLC boundary
3524 * @param onenand_info - onenand info structure
3525 **/
3526 static int flexonenand_get_boundary(struct mtd_info *mtd)
3527 {
3528 struct onenand_chip *this = mtd->priv;
3529 unsigned die, bdry;
3530 int ret, syscfg, locked;
3531
3532 /* Disable ECC */
3533 syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1);
3534 this->write_word((syscfg | 0x0100), this->base + ONENAND_REG_SYS_CFG1);
3535
3536 for (die = 0; die < this->dies; die++) {
3537 this->command(mtd, FLEXONENAND_CMD_PI_ACCESS, die, 0);
3538 this->wait(mtd, FL_SYNCING);
3539
3540 this->command(mtd, FLEXONENAND_CMD_READ_PI, die, 0);
3541 ret = this->wait(mtd, FL_READING);
3542
3543 bdry = this->read_word(this->base + ONENAND_DATARAM);
3544 if ((bdry >> FLEXONENAND_PI_UNLOCK_SHIFT) == 3)
3545 locked = 0;
3546 else
3547 locked = 1;
3548 this->boundary[die] = bdry & FLEXONENAND_PI_MASK;
3549
3550 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
3551 ret = this->wait(mtd, FL_RESETING);
3552
3553 printk(KERN_INFO "Die %d boundary: %d%s\n", die,
3554 this->boundary[die], locked ? "(Locked)" : "(Unlocked)");
3555 }
3556
3557 /* Enable ECC */
3558 this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);
3559 return 0;
3560 }
3561
3562 /**
3563 * flexonenand_get_size - Fill up fields in onenand_chip and mtd_info
3564 * boundary[], diesize[], mtd->size, mtd->erasesize
3565 * @param mtd - MTD device structure
3566 */
3567 static void flexonenand_get_size(struct mtd_info *mtd)
3568 {
3569 struct onenand_chip *this = mtd->priv;
3570 int die, i, eraseshift, density;
3571 int blksperdie, maxbdry;
3572 loff_t ofs;
3573
3574 density = onenand_get_density(this->device_id);
3575 blksperdie = ((loff_t)(16 << density) << 20) >> (this->erase_shift);
3576 blksperdie >>= ONENAND_IS_DDP(this) ? 1 : 0;
3577 maxbdry = blksperdie - 1;
3578 eraseshift = this->erase_shift - 1;
3579
3580 mtd->numeraseregions = this->dies << 1;
3581
3582 /* This fills up the device boundary */
3583 flexonenand_get_boundary(mtd);
3584 die = ofs = 0;
3585 i = -1;
3586 for (; die < this->dies; die++) {
3587 if (!die || this->boundary[die-1] != maxbdry) {
3588 i++;
3589 mtd->eraseregions[i].offset = ofs;
3590 mtd->eraseregions[i].erasesize = 1 << eraseshift;
3591 mtd->eraseregions[i].numblocks =
3592 this->boundary[die] + 1;
3593 ofs += mtd->eraseregions[i].numblocks << eraseshift;
3594 eraseshift++;
3595 } else {
3596 mtd->numeraseregions -= 1;
3597 mtd->eraseregions[i].numblocks +=
3598 this->boundary[die] + 1;
3599 ofs += (this->boundary[die] + 1) << (eraseshift - 1);
3600 }
3601 if (this->boundary[die] != maxbdry) {
3602 i++;
3603 mtd->eraseregions[i].offset = ofs;
3604 mtd->eraseregions[i].erasesize = 1 << eraseshift;
3605 mtd->eraseregions[i].numblocks = maxbdry ^
3606 this->boundary[die];
3607 ofs += mtd->eraseregions[i].numblocks << eraseshift;
3608 eraseshift--;
3609 } else
3610 mtd->numeraseregions -= 1;
3611 }
3612
3613 /* Expose MLC erase size except when all blocks are SLC */
3614 mtd->erasesize = 1 << this->erase_shift;
3615 if (mtd->numeraseregions == 1)
3616 mtd->erasesize >>= 1;
3617
3618 printk(KERN_INFO "Device has %d eraseregions\n", mtd->numeraseregions);
3619 for (i = 0; i < mtd->numeraseregions; i++)
3620 printk(KERN_INFO "[offset: 0x%08x, erasesize: 0x%05x,"
3621 " numblocks: %04u]\n",
3622 (unsigned int) mtd->eraseregions[i].offset,
3623 mtd->eraseregions[i].erasesize,
3624 mtd->eraseregions[i].numblocks);
3625
3626 for (die = 0, mtd->size = 0; die < this->dies; die++) {
3627 this->diesize[die] = (loff_t)blksperdie << this->erase_shift;
3628 this->diesize[die] -= (loff_t)(this->boundary[die] + 1)
3629 << (this->erase_shift - 1);
3630 mtd->size += this->diesize[die];
3631 }
3632 }
3633
3634 /**
3635 * flexonenand_check_blocks_erased - Check if blocks are erased
3636 * @param mtd_info - mtd info structure
3637 * @param start - first erase block to check
3638 * @param end - last erase block to check
3639 *
3640 * Converting an unerased block from MLC to SLC
3641 * causes byte values to change. Since both data and its ECC
3642 * have changed, reads on the block give uncorrectable error.
3643 * This might lead to the block being detected as bad.
3644 *
3645 * Avoid this by ensuring that the block to be converted is
3646 * erased.
3647 */
3648 static int flexonenand_check_blocks_erased(struct mtd_info *mtd, int start, int end)
3649 {
3650 struct onenand_chip *this = mtd->priv;
3651 int i, ret;
3652 int block;
3653 struct mtd_oob_ops ops = {
3654 .mode = MTD_OPS_PLACE_OOB,
3655 .ooboffs = 0,
3656 .ooblen = mtd->oobsize,
3657 .datbuf = NULL,
3658 .oobbuf = this->oob_buf,
3659 };
3660 loff_t addr;
3661
3662 printk(KERN_DEBUG "Check blocks from %d to %d\n", start, end);
3663
3664 for (block = start; block <= end; block++) {
3665 addr = flexonenand_addr(this, block);
3666 if (onenand_block_isbad_nolock(mtd, addr, 0))
3667 continue;
3668
3669 /*
3670 * Since main area write results in ECC write to spare,
3671 * it is sufficient to check only ECC bytes for change.
3672 */
3673 ret = onenand_read_oob_nolock(mtd, addr, &ops);
3674 if (ret)
3675 return ret;
3676
3677 for (i = 0; i < mtd->oobsize; i++)
3678 if (this->oob_buf[i] != 0xff)
3679 break;
3680
3681 if (i != mtd->oobsize) {
3682 printk(KERN_WARNING "%s: Block %d not erased.\n",
3683 __func__, block);
3684 return 1;
3685 }
3686 }
3687
3688 return 0;
3689 }
3690
3691 /**
3692 * flexonenand_set_boundary - Writes the SLC boundary
3693 * @param mtd - mtd info structure
3694 */
3695 int flexonenand_set_boundary(struct mtd_info *mtd, int die,
3696 int boundary, int lock)
3697 {
3698 struct onenand_chip *this = mtd->priv;
3699 int ret, density, blksperdie, old, new, thisboundary;
3700 loff_t addr;
3701
3702 /* Change only once for SDP Flex-OneNAND */
3703 if (die && (!ONENAND_IS_DDP(this)))
3704 return 0;
3705
3706 /* boundary value of -1 indicates no required change */
3707 if (boundary < 0 || boundary == this->boundary[die])
3708 return 0;
3709
3710 density = onenand_get_density(this->device_id);
3711 blksperdie = ((16 << density) << 20) >> this->erase_shift;
3712 blksperdie >>= ONENAND_IS_DDP(this) ? 1 : 0;
3713
3714 if (boundary >= blksperdie) {
3715 printk(KERN_ERR "%s: Invalid boundary value. "
3716 "Boundary not changed.\n", __func__);
3717 return -EINVAL;
3718 }
3719
3720 /* Check if converting blocks are erased */
3721 old = this->boundary[die] + (die * this->density_mask);
3722 new = boundary + (die * this->density_mask);
3723 ret = flexonenand_check_blocks_erased(mtd, min(old, new) + 1, max(old, new));
3724 if (ret) {
3725 printk(KERN_ERR "%s: Please erase blocks "
3726 "before boundary change\n", __func__);
3727 return ret;
3728 }
3729
3730 this->command(mtd, FLEXONENAND_CMD_PI_ACCESS, die, 0);
3731 this->wait(mtd, FL_SYNCING);
3732
3733 /* Check is boundary is locked */
3734 this->command(mtd, FLEXONENAND_CMD_READ_PI, die, 0);
3735 ret = this->wait(mtd, FL_READING);
3736
3737 thisboundary = this->read_word(this->base + ONENAND_DATARAM);
3738 if ((thisboundary >> FLEXONENAND_PI_UNLOCK_SHIFT) != 3) {
3739 printk(KERN_ERR "%s: boundary locked\n", __func__);
3740 ret = 1;
3741 goto out;
3742 }
3743
3744 printk(KERN_INFO "Changing die %d boundary: %d%s\n",
3745 die, boundary, lock ? "(Locked)" : "(Unlocked)");
3746
3747 addr = die ? this->diesize[0] : 0;
3748
3749 boundary &= FLEXONENAND_PI_MASK;
3750 boundary |= lock ? 0 : (3 << FLEXONENAND_PI_UNLOCK_SHIFT);
3751
3752 this->command(mtd, ONENAND_CMD_ERASE, addr, 0);
3753 ret = this->wait(mtd, FL_ERASING);
3754 if (ret) {
3755 printk(KERN_ERR "%s: Failed PI erase for Die %d\n",
3756 __func__, die);
3757 goto out;
3758 }
3759
3760 this->write_word(boundary, this->base + ONENAND_DATARAM);
3761 this->command(mtd, ONENAND_CMD_PROG, addr, 0);
3762 ret = this->wait(mtd, FL_WRITING);
3763 if (ret) {
3764 printk(KERN_ERR "%s: Failed PI write for Die %d\n",
3765 __func__, die);
3766 goto out;
3767 }
3768
3769 this->command(mtd, FLEXONENAND_CMD_PI_UPDATE, die, 0);
3770 ret = this->wait(mtd, FL_WRITING);
3771 out:
3772 this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_REG_COMMAND);
3773 this->wait(mtd, FL_RESETING);
3774 if (!ret)
3775 /* Recalculate device size on boundary change*/
3776 flexonenand_get_size(mtd);
3777
3778 return ret;
3779 }
3780
3781 /**
3782 * onenand_chip_probe - [OneNAND Interface] The generic chip probe
3783 * @param mtd MTD device structure
3784 *
3785 * OneNAND detection method:
3786 * Compare the values from command with ones from register
3787 */
3788 static int onenand_chip_probe(struct mtd_info *mtd)
3789 {
3790 struct onenand_chip *this = mtd->priv;
3791 int bram_maf_id, bram_dev_id, maf_id, dev_id;
3792 int syscfg;
3793
3794 /* Save system configuration 1 */
3795 syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1);
3796 /* Clear Sync. Burst Read mode to read BootRAM */
3797 this->write_word((syscfg & ~ONENAND_SYS_CFG1_SYNC_READ & ~ONENAND_SYS_CFG1_SYNC_WRITE), this->base + ONENAND_REG_SYS_CFG1);
3798
3799 /* Send the command for reading device ID from BootRAM */
3800 this->write_word(ONENAND_CMD_READID, this->base + ONENAND_BOOTRAM);
3801
3802 /* Read manufacturer and device IDs from BootRAM */
3803 bram_maf_id = this->read_word(this->base + ONENAND_BOOTRAM + 0x0);
3804 bram_dev_id = this->read_word(this->base + ONENAND_BOOTRAM + 0x2);
3805
3806 /* Reset OneNAND to read default register values */
3807 this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_BOOTRAM);
3808 /* Wait reset */
3809 this->wait(mtd, FL_RESETING);
3810
3811 /* Restore system configuration 1 */
3812 this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);
3813
3814 /* Check manufacturer ID */
3815 if (onenand_check_maf(bram_maf_id))
3816 return -ENXIO;
3817
3818 /* Read manufacturer and device IDs from Register */
3819 maf_id = this->read_word(this->base + ONENAND_REG_MANUFACTURER_ID);
3820 dev_id = this->read_word(this->base + ONENAND_REG_DEVICE_ID);
3821
3822 /* Check OneNAND device */
3823 if (maf_id != bram_maf_id || dev_id != bram_dev_id)
3824 return -ENXIO;
3825
3826 return 0;
3827 }
3828
3829 /**
3830 * onenand_probe - [OneNAND Interface] Probe the OneNAND device
3831 * @param mtd MTD device structure
3832 */
3833 static int onenand_probe(struct mtd_info *mtd)
3834 {
3835 struct onenand_chip *this = mtd->priv;
3836 int maf_id, dev_id, ver_id;
3837 int density;
3838 int ret;
3839
3840 ret = this->chip_probe(mtd);
3841 if (ret)
3842 return ret;
3843
3844 /* Read manufacturer and device IDs from Register */
3845 maf_id = this->read_word(this->base + ONENAND_REG_MANUFACTURER_ID);
3846 dev_id = this->read_word(this->base + ONENAND_REG_DEVICE_ID);
3847 ver_id = this->read_word(this->base + ONENAND_REG_VERSION_ID);
3848 this->technology = this->read_word(this->base + ONENAND_REG_TECHNOLOGY);
3849
3850 /* Flash device information */
3851 onenand_print_device_info(dev_id, ver_id);
3852 this->device_id = dev_id;
3853 this->version_id = ver_id;
3854
3855 /* Check OneNAND features */
3856 onenand_check_features(mtd);
3857
3858 density = onenand_get_density(dev_id);
3859 if (FLEXONENAND(this)) {
3860 this->dies = ONENAND_IS_DDP(this) ? 2 : 1;
3861 /* Maximum possible erase regions */
3862 mtd->numeraseregions = this->dies << 1;
3863 mtd->eraseregions = kzalloc(sizeof(struct mtd_erase_region_info)
3864 * (this->dies << 1), GFP_KERNEL);
3865 if (!mtd->eraseregions)
3866 return -ENOMEM;
3867 }
3868
3869 /*
3870 * For Flex-OneNAND, chipsize represents maximum possible device size.
3871 * mtd->size represents the actual device size.
3872 */
3873 this->chipsize = (16 << density) << 20;
3874
3875 /* OneNAND page size & block size */
3876 /* The data buffer size is equal to page size */
3877 mtd->writesize = this->read_word(this->base + ONENAND_REG_DATA_BUFFER_SIZE);
3878 /* We use the full BufferRAM */
3879 if (ONENAND_IS_4KB_PAGE(this))
3880 mtd->writesize <<= 1;
3881
3882 mtd->oobsize = mtd->writesize >> 5;
3883 /* Pages per a block are always 64 in OneNAND */
3884 mtd->erasesize = mtd->writesize << 6;
3885 /*
3886 * Flex-OneNAND SLC area has 64 pages per block.
3887 * Flex-OneNAND MLC area has 128 pages per block.
3888 * Expose MLC erase size to find erase_shift and page_mask.
3889 */
3890 if (FLEXONENAND(this))
3891 mtd->erasesize <<= 1;
3892
3893 this->erase_shift = ffs(mtd->erasesize) - 1;
3894 this->page_shift = ffs(mtd->writesize) - 1;
3895 this->page_mask = (1 << (this->erase_shift - this->page_shift)) - 1;
3896 /* Set density mask. it is used for DDP */
3897 if (ONENAND_IS_DDP(this))
3898 this->density_mask = this->chipsize >> (this->erase_shift + 1);
3899 /* It's real page size */
3900 this->writesize = mtd->writesize;
3901
3902 /* REVISIT: Multichip handling */
3903
3904 if (FLEXONENAND(this))
3905 flexonenand_get_size(mtd);
3906 else
3907 mtd->size = this->chipsize;
3908
3909 /*
3910 * We emulate the 4KiB page and 256KiB erase block size
3911 * But oobsize is still 64 bytes.
3912 * It is only valid if you turn on 2X program support,
3913 * Otherwise it will be ignored by compiler.
3914 */
3915 if (ONENAND_IS_2PLANE(this)) {
3916 mtd->writesize <<= 1;
3917 mtd->erasesize <<= 1;
3918 }
3919
3920 return 0;
3921 }
3922
3923 /**
3924 * onenand_suspend - [MTD Interface] Suspend the OneNAND flash
3925 * @param mtd MTD device structure
3926 */
3927 static int onenand_suspend(struct mtd_info *mtd)
3928 {
3929 return onenand_get_device(mtd, FL_PM_SUSPENDED);
3930 }
3931
3932 /**
3933 * onenand_resume - [MTD Interface] Resume the OneNAND flash
3934 * @param mtd MTD device structure
3935 */
3936 static void onenand_resume(struct mtd_info *mtd)
3937 {
3938 struct onenand_chip *this = mtd->priv;
3939
3940 if (this->state == FL_PM_SUSPENDED)
3941 onenand_release_device(mtd);
3942 else
3943 printk(KERN_ERR "%s: resume() called for the chip which is not "
3944 "in suspended state\n", __func__);
3945 }
3946
3947 /**
3948 * onenand_scan - [OneNAND Interface] Scan for the OneNAND device
3949 * @param mtd MTD device structure
3950 * @param maxchips Number of chips to scan for
3951 *
3952 * This fills out all the not initialized function pointers
3953 * with the defaults.
3954 * The flash ID is read and the mtd/chip structures are
3955 * filled with the appropriate values.
3956 */
3957 int onenand_scan(struct mtd_info *mtd, int maxchips)
3958 {
3959 int i, ret;
3960 struct onenand_chip *this = mtd->priv;
3961
3962 if (!this->read_word)
3963 this->read_word = onenand_readw;
3964 if (!this->write_word)
3965 this->write_word = onenand_writew;
3966
3967 if (!this->command)
3968 this->command = onenand_command;
3969 if (!this->wait)
3970 onenand_setup_wait(mtd);
3971 if (!this->bbt_wait)
3972 this->bbt_wait = onenand_bbt_wait;
3973 if (!this->unlock_all)
3974 this->unlock_all = onenand_unlock_all;
3975
3976 if (!this->chip_probe)
3977 this->chip_probe = onenand_chip_probe;
3978
3979 if (!this->read_bufferram)
3980 this->read_bufferram = onenand_read_bufferram;
3981 if (!this->write_bufferram)
3982 this->write_bufferram = onenand_write_bufferram;
3983
3984 if (!this->block_markbad)
3985 this->block_markbad = onenand_default_block_markbad;
3986 if (!this->scan_bbt)
3987 this->scan_bbt = onenand_default_bbt;
3988
3989 if (onenand_probe(mtd))
3990 return -ENXIO;
3991
3992 /* Set Sync. Burst Read after probing */
3993 if (this->mmcontrol) {
3994 printk(KERN_INFO "OneNAND Sync. Burst Read support\n");
3995 this->read_bufferram = onenand_sync_read_bufferram;
3996 }
3997
3998 /* Allocate buffers, if necessary */
3999 if (!this->page_buf) {
4000 this->page_buf = kzalloc(mtd->writesize, GFP_KERNEL);
4001 if (!this->page_buf) {
4002 printk(KERN_ERR "%s: Can't allocate page_buf\n",
4003 __func__);
4004 return -ENOMEM;
4005 }
4006 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
4007 this->verify_buf = kzalloc(mtd->writesize, GFP_KERNEL);
4008 if (!this->verify_buf) {
4009 kfree(this->page_buf);
4010 return -ENOMEM;
4011 }
4012 #endif
4013 this->options |= ONENAND_PAGEBUF_ALLOC;
4014 }
4015 if (!this->oob_buf) {
4016 this->oob_buf = kzalloc(mtd->oobsize, GFP_KERNEL);
4017 if (!this->oob_buf) {
4018 printk(KERN_ERR "%s: Can't allocate oob_buf\n",
4019 __func__);
4020 if (this->options & ONENAND_PAGEBUF_ALLOC) {
4021 this->options &= ~ONENAND_PAGEBUF_ALLOC;
4022 kfree(this->page_buf);
4023 }
4024 return -ENOMEM;
4025 }
4026 this->options |= ONENAND_OOBBUF_ALLOC;
4027 }
4028
4029 this->state = FL_READY;
4030 init_waitqueue_head(&this->wq);
4031 spin_lock_init(&this->chip_lock);
4032
4033 /*
4034 * Allow subpage writes up to oobsize.
4035 */
4036 switch (mtd->oobsize) {
4037 case 128:
4038 if (FLEXONENAND(this)) {
4039 this->ecclayout = &flexonenand_oob_128;
4040 mtd->subpage_sft = 0;
4041 } else {
4042 this->ecclayout = &onenand_oob_128;
4043 mtd->subpage_sft = 2;
4044 }
4045 if (ONENAND_IS_NOP_1(this))
4046 mtd->subpage_sft = 0;
4047 break;
4048 case 64:
4049 this->ecclayout = &onenand_oob_64;
4050 mtd->subpage_sft = 2;
4051 break;
4052
4053 case 32:
4054 this->ecclayout = &onenand_oob_32;
4055 mtd->subpage_sft = 1;
4056 break;
4057
4058 default:
4059 printk(KERN_WARNING "%s: No OOB scheme defined for oobsize %d\n",
4060 __func__, mtd->oobsize);
4061 mtd->subpage_sft = 0;
4062 /* To prevent kernel oops */
4063 this->ecclayout = &onenand_oob_32;
4064 break;
4065 }
4066
4067 this->subpagesize = mtd->writesize >> mtd->subpage_sft;
4068
4069 /*
4070 * The number of bytes available for a client to place data into
4071 * the out of band area
4072 */
4073 this->ecclayout->oobavail = 0;
4074 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES &&
4075 this->ecclayout->oobfree[i].length; i++)
4076 this->ecclayout->oobavail +=
4077 this->ecclayout->oobfree[i].length;
4078 mtd->oobavail = this->ecclayout->oobavail;
4079
4080 mtd->ecclayout = this->ecclayout;
4081 mtd->ecc_strength = 1;
4082
4083 /* Fill in remaining MTD driver data */
4084 mtd->type = ONENAND_IS_MLC(this) ? MTD_MLCNANDFLASH : MTD_NANDFLASH;
4085 mtd->flags = MTD_CAP_NANDFLASH;
4086 mtd->_erase = onenand_erase;
4087 mtd->_point = NULL;
4088 mtd->_unpoint = NULL;
4089 mtd->_read = onenand_read;
4090 mtd->_write = onenand_write;
4091 mtd->_read_oob = onenand_read_oob;
4092 mtd->_write_oob = onenand_write_oob;
4093 mtd->_panic_write = onenand_panic_write;
4094 #ifdef CONFIG_MTD_ONENAND_OTP
4095 mtd->_get_fact_prot_info = onenand_get_fact_prot_info;
4096 mtd->_read_fact_prot_reg = onenand_read_fact_prot_reg;
4097 mtd->_get_user_prot_info = onenand_get_user_prot_info;
4098 mtd->_read_user_prot_reg = onenand_read_user_prot_reg;
4099 mtd->_write_user_prot_reg = onenand_write_user_prot_reg;
4100 mtd->_lock_user_prot_reg = onenand_lock_user_prot_reg;
4101 #endif
4102 mtd->_sync = onenand_sync;
4103 mtd->_lock = onenand_lock;
4104 mtd->_unlock = onenand_unlock;
4105 mtd->_suspend = onenand_suspend;
4106 mtd->_resume = onenand_resume;
4107 mtd->_block_isbad = onenand_block_isbad;
4108 mtd->_block_markbad = onenand_block_markbad;
4109 mtd->owner = THIS_MODULE;
4110 mtd->writebufsize = mtd->writesize;
4111
4112 /* Unlock whole block */
4113 if (!(this->options & ONENAND_SKIP_INITIAL_UNLOCKING))
4114 this->unlock_all(mtd);
4115
4116 ret = this->scan_bbt(mtd);
4117 if ((!FLEXONENAND(this)) || ret)
4118 return ret;
4119
4120 /* Change Flex-OneNAND boundaries if required */
4121 for (i = 0; i < MAX_DIES; i++)
4122 flexonenand_set_boundary(mtd, i, flex_bdry[2 * i],
4123 flex_bdry[(2 * i) + 1]);
4124
4125 return 0;
4126 }
4127
4128 /**
4129 * onenand_release - [OneNAND Interface] Free resources held by the OneNAND device
4130 * @param mtd MTD device structure
4131 */
4132 void onenand_release(struct mtd_info *mtd)
4133 {
4134 struct onenand_chip *this = mtd->priv;
4135
4136 /* Deregister partitions */
4137 mtd_device_unregister(mtd);
4138
4139 /* Free bad block table memory, if allocated */
4140 if (this->bbm) {
4141 struct bbm_info *bbm = this->bbm;
4142 kfree(bbm->bbt);
4143 kfree(this->bbm);
4144 }
4145 /* Buffers allocated by onenand_scan */
4146 if (this->options & ONENAND_PAGEBUF_ALLOC) {
4147 kfree(this->page_buf);
4148 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
4149 kfree(this->verify_buf);
4150 #endif
4151 }
4152 if (this->options & ONENAND_OOBBUF_ALLOC)
4153 kfree(this->oob_buf);
4154 kfree(mtd->eraseregions);
4155 }
4156
4157 EXPORT_SYMBOL_GPL(onenand_scan);
4158 EXPORT_SYMBOL_GPL(onenand_release);
4159
4160 MODULE_LICENSE("GPL");
4161 MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>");
4162 MODULE_DESCRIPTION("Generic OneNAND flash driver code");
Linux with added FPC-III support