2 * drivers/mtd/nand/rtc_from4.c
4 * Copyright (C) 2004 Red Hat, Inc.
6 * Derived from drivers/mtd/nand/spia.c
7 * Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
9 * $Id: rtc_from4.c,v 1.10 2005/11/07 11:14:31 gleixner Exp $
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
16 * This is a device driver for the AG-AND flash device found on the
17 * Renesas Technology Corp. Flash ROM 4-slot interface board (FROM_BOARD4),
18 * which utilizes the Renesas HN29V1G91T-30 part.
19 * This chip is a 1 GBibit (128MiB x 8 bits) AG-AND flash device.
22 #include <linux/delay.h>
23 #include <linux/kernel.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/rslib.h>
27 #include <linux/module.h>
28 #include <linux/mtd/compatmac.h>
29 #include <linux/mtd/mtd.h>
30 #include <linux/mtd/nand.h>
31 #include <linux/mtd/partitions.h>
35 * MTD structure for Renesas board
37 static struct mtd_info *rtc_from4_mtd = NULL;
39 #define RTC_FROM4_MAX_CHIPS 2
41 /* HS77x9 processor register defines */
42 #define SH77X9_BCR1 ((volatile unsigned short *)(0xFFFFFF60))
43 #define SH77X9_BCR2 ((volatile unsigned short *)(0xFFFFFF62))
44 #define SH77X9_WCR1 ((volatile unsigned short *)(0xFFFFFF64))
45 #define SH77X9_WCR2 ((volatile unsigned short *)(0xFFFFFF66))
46 #define SH77X9_MCR ((volatile unsigned short *)(0xFFFFFF68))
47 #define SH77X9_PCR ((volatile unsigned short *)(0xFFFFFF6C))
48 #define SH77X9_FRQCR ((volatile unsigned short *)(0xFFFFFF80))
51 * Values specific to the Renesas Technology Corp. FROM_BOARD4 (used with HS77x9 processor)
53 /* Address where flash is mapped */
54 #define RTC_FROM4_FIO_BASE 0x14000000
56 /* CLE and ALE are tied to address lines 5 & 4, respectively */
57 #define RTC_FROM4_CLE (1 << 5)
58 #define RTC_FROM4_ALE (1 << 4)
60 /* address lines A24-A22 used for chip selection */
61 #define RTC_FROM4_NAND_ADDR_SLOT3 (0x00800000)
62 #define RTC_FROM4_NAND_ADDR_SLOT4 (0x00C00000)
63 #define RTC_FROM4_NAND_ADDR_FPGA (0x01000000)
64 /* mask address lines A24-A22 used for chip selection */
65 #define RTC_FROM4_NAND_ADDR_MASK (RTC_FROM4_NAND_ADDR_SLOT3 | RTC_FROM4_NAND_ADDR_SLOT4 | RTC_FROM4_NAND_ADDR_FPGA)
67 /* FPGA status register for checking device ready (bit zero) */
68 #define RTC_FROM4_FPGA_SR (RTC_FROM4_NAND_ADDR_FPGA | 0x00000002)
69 #define RTC_FROM4_DEVICE_READY 0x0001
71 /* FPGA Reed-Solomon ECC Control register */
73 #define RTC_FROM4_RS_ECC_CTL (RTC_FROM4_NAND_ADDR_FPGA | 0x00000050)
74 #define RTC_FROM4_RS_ECC_CTL_CLR (1 << 7)
75 #define RTC_FROM4_RS_ECC_CTL_GEN (1 << 6)
76 #define RTC_FROM4_RS_ECC_CTL_FD_E (1 << 5)
78 /* FPGA Reed-Solomon ECC code base */
79 #define RTC_FROM4_RS_ECC (RTC_FROM4_NAND_ADDR_FPGA | 0x00000060)
80 #define RTC_FROM4_RS_ECCN (RTC_FROM4_NAND_ADDR_FPGA | 0x00000080)
82 /* FPGA Reed-Solomon ECC check register */
83 #define RTC_FROM4_RS_ECC_CHK (RTC_FROM4_NAND_ADDR_FPGA | 0x00000070)
84 #define RTC_FROM4_RS_ECC_CHK_ERROR (1 << 7)
86 #define ERR_STAT_ECC_AVAILABLE 0x20
88 /* Undefine for software ECC */
89 #define RTC_FROM4_HWECC 1
91 /* Define as 1 for no virtual erase blocks (in JFFS2) */
92 #define RTC_FROM4_NO_VIRTBLOCKS 0
97 static void __iomem *rtc_from4_fio_base = (void *)P2SEGADDR(RTC_FROM4_FIO_BASE);
99 static const struct mtd_partition partition_info[] = {
101 .name = "Renesas flash partition 1",
103 .size = MTDPART_SIZ_FULL},
106 #define NUM_PARTITIONS 1
109 * hardware specific flash bbt decriptors
110 * Note: this is to allow debugging by disabling
111 * NAND_BBT_CREATE and/or NAND_BBT_WRITE
114 static uint8_t bbt_pattern[] = { 'B', 'b', 't', '0' };
115 static uint8_t mirror_pattern[] = { '1', 't', 'b', 'B' };
117 static struct nand_bbt_descr rtc_from4_bbt_main_descr = {
118 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
119 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
124 .pattern = bbt_pattern
127 static struct nand_bbt_descr rtc_from4_bbt_mirror_descr = {
128 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
129 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
134 .pattern = mirror_pattern
137 #ifdef RTC_FROM4_HWECC
139 /* the Reed Solomon control structure */
140 static struct rs_control *rs_decoder;
143 * hardware specific Out Of Band information
145 static struct nand_oobinfo rtc_from4_nand_oobinfo = {
146 .useecc = MTD_NANDECC_AUTOPLACE,
149 0, 1, 2, 3, 4, 5, 6, 7,
150 8, 9, 10, 11, 12, 13, 14, 15,
151 16, 17, 18, 19, 20, 21, 22, 23,
152 24, 25, 26, 27, 28, 29, 30, 31},
153 .oobfree = {{32, 32}}
156 /* Aargh. I missed the reversed bit order, when I
157 * was talking to Renesas about the FPGA.
159 * The table is used for bit reordering and inversion
160 * of the ecc byte which we get from the FPGA
162 static uint8_t revbits[256] = {
163 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
164 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
165 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
166 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
167 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
168 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
169 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
170 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
171 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
172 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
173 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
174 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
175 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
176 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
177 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
178 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
179 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
180 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
181 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
182 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
183 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
184 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
185 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
186 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
187 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
188 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
189 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
190 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
191 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
192 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
193 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
194 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
200 * rtc_from4_hwcontrol - hardware specific access to control-lines
201 * @mtd: MTD device structure
202 * @cmd: hardware control command
204 * Address lines (A5 and A4) are used to control Command and Address Latch
205 * Enable on this board, so set the read/write address appropriately.
207 * Chip Enable is also controlled by the Chip Select (CS5) and
208 * Address lines (A24-A22), so no action is required here.
211 static void rtc_from4_hwcontrol(struct mtd_info *mtd, int cmd,
214 struct nand_chip *chip = (mtd->priv);
216 if (cmd == NAND_CMD_NONE)
220 writeb(cmd, chip->IO_ADDR_W | RTC_FROM4_CLE);
222 writeb(cmd, chip->IO_ADDR_W | RTC_FROM4_ALE);
226 * rtc_from4_nand_select_chip - hardware specific chip select
227 * @mtd: MTD device structure
228 * @chip: Chip to select (0 == slot 3, 1 == slot 4)
230 * The chip select is based on address lines A24-A22.
231 * This driver uses flash slots 3 and 4 (A23-A22).
234 static void rtc_from4_nand_select_chip(struct mtd_info *mtd, int chip)
236 struct nand_chip *this = mtd->priv;
238 this->IO_ADDR_R = (void __iomem *)((unsigned long)this->IO_ADDR_R & ~RTC_FROM4_NAND_ADDR_MASK);
239 this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W & ~RTC_FROM4_NAND_ADDR_MASK);
243 case 0: /* select slot 3 chip */
244 this->IO_ADDR_R = (void __iomem *)((unsigned long)this->IO_ADDR_R | RTC_FROM4_NAND_ADDR_SLOT3);
245 this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W | RTC_FROM4_NAND_ADDR_SLOT3);
247 case 1: /* select slot 4 chip */
248 this->IO_ADDR_R = (void __iomem *)((unsigned long)this->IO_ADDR_R | RTC_FROM4_NAND_ADDR_SLOT4);
249 this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W | RTC_FROM4_NAND_ADDR_SLOT4);
256 * rtc_from4_nand_device_ready - hardware specific ready/busy check
257 * @mtd: MTD device structure
259 * This board provides the Ready/Busy state in the status register
260 * of the FPGA. Bit zero indicates the RDY(1)/BSY(0) signal.
263 static int rtc_from4_nand_device_ready(struct mtd_info *mtd)
265 unsigned short status;
267 status = *((volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_FPGA_SR));
269 return (status & RTC_FROM4_DEVICE_READY);
274 * deplete - code to perform device recovery in case there was a power loss
275 * @mtd: MTD device structure
276 * @chip: Chip to select (0 == slot 3, 1 == slot 4)
278 * If there was a sudden loss of power during an erase operation, a
279 * "device recovery" operation must be performed when power is restored
280 * to ensure correct operation. This routine performs the required steps
281 * for the requested chip.
283 * See page 86 of the data sheet for details.
286 static void deplete(struct mtd_info *mtd, int chip)
288 struct nand_chip *this = mtd->priv;
290 /* wait until device is ready */
291 while (!this->dev_ready(mtd)) ;
293 this->select_chip(mtd, chip);
295 /* Send the commands for device recovery, phase 1 */
296 this->cmdfunc(mtd, NAND_CMD_DEPLETE1, 0x0000, 0x0000);
297 this->cmdfunc(mtd, NAND_CMD_DEPLETE2, -1, -1);
299 /* Send the commands for device recovery, phase 2 */
300 this->cmdfunc(mtd, NAND_CMD_DEPLETE1, 0x0000, 0x0004);
301 this->cmdfunc(mtd, NAND_CMD_DEPLETE2, -1, -1);
305 #ifdef RTC_FROM4_HWECC
307 * rtc_from4_enable_hwecc - hardware specific hardware ECC enable function
308 * @mtd: MTD device structure
309 * @mode: I/O mode; read or write
311 * enable hardware ECC for data read or write
314 static void rtc_from4_enable_hwecc(struct mtd_info *mtd, int mode)
316 volatile unsigned short *rs_ecc_ctl = (volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_RS_ECC_CTL);
317 unsigned short status;
321 status = RTC_FROM4_RS_ECC_CTL_CLR | RTC_FROM4_RS_ECC_CTL_FD_E;
323 *rs_ecc_ctl = status;
326 case NAND_ECC_READSYN:
329 *rs_ecc_ctl = status;
333 status = RTC_FROM4_RS_ECC_CTL_CLR | RTC_FROM4_RS_ECC_CTL_GEN | RTC_FROM4_RS_ECC_CTL_FD_E;
335 *rs_ecc_ctl = status;
346 * rtc_from4_calculate_ecc - hardware specific code to read ECC code
347 * @mtd: MTD device structure
348 * @dat: buffer containing the data to generate ECC codes
349 * @ecc_code ECC codes calculated
351 * The ECC code is calculated by the FPGA. All we have to do is read the values
352 * from the FPGA registers.
354 * Note: We read from the inverted registers, since data is inverted before
355 * the code is calculated. So all 0xff data (blank page) results in all 0xff rs code
358 static void rtc_from4_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code)
360 volatile unsigned short *rs_eccn = (volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_RS_ECCN);
361 unsigned short value;
364 for (i = 0; i < 8; i++) {
366 ecc_code[i] = (unsigned char)value;
369 ecc_code[7] |= 0x0f; /* set the last four bits (not used) */
373 * rtc_from4_correct_data - hardware specific code to correct data using ECC code
374 * @mtd: MTD device structure
375 * @buf: buffer containing the data to generate ECC codes
376 * @ecc1 ECC codes read
377 * @ecc2 ECC codes calculated
379 * The FPGA tells us fast, if there's an error or not. If no, we go back happy
380 * else we read the ecc results from the fpga and call the rs library to decode
381 * and hopefully correct the error.
384 static int rtc_from4_correct_data(struct mtd_info *mtd, const u_char *buf, u_char *ecc1, u_char *ecc2)
387 unsigned short status;
388 uint16_t par[6], syn[6];
390 volatile unsigned short *rs_ecc;
392 status = *((volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_RS_ECC_CHK));
394 if (!(status & RTC_FROM4_RS_ECC_CHK_ERROR)) {
398 /* Read the syndrom pattern from the FPGA and correct the bitorder */
399 rs_ecc = (volatile unsigned short *)(rtc_from4_fio_base + RTC_FROM4_RS_ECC);
400 for (i = 0; i < 8; i++) {
401 ecc[i] = revbits[(*rs_ecc) & 0xFF];
405 /* convert into 6 10bit syndrome fields */
406 par[5] = rs_decoder->index_of[(((uint16_t) ecc[0] >> 0) & 0x0ff) | (((uint16_t) ecc[1] << 8) & 0x300)];
407 par[4] = rs_decoder->index_of[(((uint16_t) ecc[1] >> 2) & 0x03f) | (((uint16_t) ecc[2] << 6) & 0x3c0)];
408 par[3] = rs_decoder->index_of[(((uint16_t) ecc[2] >> 4) & 0x00f) | (((uint16_t) ecc[3] << 4) & 0x3f0)];
409 par[2] = rs_decoder->index_of[(((uint16_t) ecc[3] >> 6) & 0x003) | (((uint16_t) ecc[4] << 2) & 0x3fc)];
410 par[1] = rs_decoder->index_of[(((uint16_t) ecc[5] >> 0) & 0x0ff) | (((uint16_t) ecc[6] << 8) & 0x300)];
411 par[0] = (((uint16_t) ecc[6] >> 2) & 0x03f) | (((uint16_t) ecc[7] << 6) & 0x3c0);
413 /* Convert to computable syndrome */
414 for (i = 0; i < 6; i++) {
416 for (j = 1; j < 6; j++)
417 if (par[j] != rs_decoder->nn)
418 syn[i] ^= rs_decoder->alpha_to[rs_modnn(rs_decoder, par[j] + i * j)];
420 /* Convert to index form */
421 syn[i] = rs_decoder->index_of[syn[i]];
424 /* Let the library code do its magic. */
425 res = decode_rs8(rs_decoder, (uint8_t *) buf, par, 512, syn, 0, NULL, 0xff, NULL);
427 DEBUG(MTD_DEBUG_LEVEL0, "rtc_from4_correct_data: " "ECC corrected %d errors on read\n", res);
433 * rtc_from4_errstat - perform additional error status checks
434 * @mtd: MTD device structure
435 * @this: NAND chip structure
436 * @state: state or the operation
437 * @status: status code returned from read status
438 * @page: startpage inside the chip, must be called with (page & this->pagemask)
440 * Perform additional error status checks on erase and write failures
441 * to determine if errors are correctable. For this device, correctable
442 * 1-bit errors on erase and write are considered acceptable.
444 * note: see pages 34..37 of data sheet for details.
447 static int rtc_from4_errstat(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page)
455 this->cmdfunc(mtd, NAND_CMD_STATUS_CLEAR, -1, -1);
457 if (state == FL_ERASING) {
458 for (i = 0; i < 4; i++) {
459 if (status & 1 << (i + 1)) {
460 this->cmdfunc(mtd, (NAND_CMD_STATUS_ERROR + i + 1), -1, -1);
461 rtn = this->read_byte(mtd);
462 this->cmdfunc(mtd, NAND_CMD_STATUS_RESET, -1, -1);
463 if (!(rtn & ERR_STAT_ECC_AVAILABLE)) {
464 er_stat |= 1 << (i + 1); /* err_ecc_not_avail */
468 } else if (state == FL_WRITING) {
469 /* single bank write logic */
470 this->cmdfunc(mtd, NAND_CMD_STATUS_ERROR, -1, -1);
471 rtn = this->read_byte(mtd);
472 this->cmdfunc(mtd, NAND_CMD_STATUS_RESET, -1, -1);
473 if (!(rtn & ERR_STAT_ECC_AVAILABLE)) {
474 er_stat |= 1 << 1; /* err_ecc_not_avail */
476 len = mtd->writesize;
477 buf = kmalloc(len, GFP_KERNEL);
479 printk(KERN_ERR "rtc_from4_errstat: Out of memory!\n");
480 er_stat = 1; /* if we can't check, assume failed */
484 rtn = nand_do_read_ecc(mtd, page, len, &retlen, buf, NULL, this->autooob, 1);
485 if (rtn) { /* if read failed or > 1-bit error corrected */
486 er_stat |= 1 << 1; /* ECC read failed */
494 if (er_stat == 0) { /* if ECC is available */
495 rtn = (status & ~NAND_STATUS_FAIL); /* clear the error bit */
503 * Main initialization routine
505 static int __init rtc_from4_init(void)
507 struct nand_chip *this;
508 unsigned short bcr1, bcr2, wcr2;
511 /* Allocate memory for MTD device structure and private data */
512 rtc_from4_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
513 if (!rtc_from4_mtd) {
514 printk("Unable to allocate Renesas NAND MTD device structure.\n");
518 /* Get pointer to private data */
519 this = (struct nand_chip *)(&rtc_from4_mtd[1]);
521 /* Initialize structures */
522 memset(rtc_from4_mtd, 0, sizeof(struct mtd_info));
523 memset(this, 0, sizeof(struct nand_chip));
525 /* Link the private data with the MTD structure */
526 rtc_from4_mtd->priv = this;
527 rtc_from4_mtd->owner = THIS_MODULE;
529 /* set area 5 as PCMCIA mode to clear the spec of tDH(Data hold time;9ns min) */
530 bcr1 = *SH77X9_BCR1 & ~0x0002;
535 bcr2 = *SH77X9_BCR2 & ~0x0c00;
539 /* set area 5 wait states */
540 wcr2 = *SH77X9_WCR2 & ~0x1c00;
544 /* Set address of NAND IO lines */
545 this->IO_ADDR_R = rtc_from4_fio_base;
546 this->IO_ADDR_W = rtc_from4_fio_base;
547 /* Set address of hardware control function */
548 this->cmd_ctrl = rtc_from4_hwcontrol;
549 /* Set address of chip select function */
550 this->select_chip = rtc_from4_nand_select_chip;
551 /* command delay time (in us) */
552 this->chip_delay = 100;
553 /* return the status of the Ready/Busy line */
554 this->dev_ready = rtc_from4_nand_device_ready;
556 #ifdef RTC_FROM4_HWECC
557 printk(KERN_INFO "rtc_from4_init: using hardware ECC detection.\n");
559 this->ecc.mode = NAND_ECC_HW_SYNDROME;
560 this->ecc.size = 512;
562 this->options |= NAND_HWECC_SYNDROME;
563 /* return the status of extra status and ECC checks */
564 this->errstat = rtc_from4_errstat;
565 /* set the nand_oobinfo to support FPGA H/W error detection */
566 this->autooob = &rtc_from4_nand_oobinfo;
567 this->ecc.hwctl = rtc_from4_enable_hwecc;
568 this->ecc.calculate = rtc_from4_calculate_ecc;
569 this->ecc.correct = rtc_from4_correct_data;
571 printk(KERN_INFO "rtc_from4_init: using software ECC detection.\n");
573 this->ecc.mode = NAND_ECC_SOFT;
576 /* set the bad block tables to support debugging */
577 this->bbt_td = &rtc_from4_bbt_main_descr;
578 this->bbt_md = &rtc_from4_bbt_mirror_descr;
580 /* Scan to find existence of the device */
581 if (nand_scan(rtc_from4_mtd, RTC_FROM4_MAX_CHIPS)) {
582 kfree(rtc_from4_mtd);
586 /* Perform 'device recovery' for each chip in case there was a power loss. */
587 for (i = 0; i < this->numchips; i++) {
588 deplete(rtc_from4_mtd, i);
591 #if RTC_FROM4_NO_VIRTBLOCKS
592 /* use a smaller erase block to minimize wasted space when a block is bad */
593 /* note: this uses eight times as much RAM as using the default and makes */
594 /* mounts take four times as long. */
595 rtc_from4_mtd->flags |= MTD_NO_VIRTBLOCKS;
598 /* Register the partitions */
599 add_mtd_partitions(rtc_from4_mtd, partition_info, NUM_PARTITIONS);
601 #ifdef RTC_FROM4_HWECC
602 /* We could create the decoder on demand, if memory is a concern.
603 * This way we have it handy, if an error happens
605 * Symbolsize is 10 (bits)
606 * Primitve polynomial is x^10+x^3+1
607 * first consecutive root is 0
608 * primitve element to generate roots = 1
609 * generator polinomial degree = 6
611 rs_decoder = init_rs(10, 0x409, 0, 1, 6);
613 printk(KERN_ERR "Could not create a RS decoder\n");
614 nand_release(rtc_from4_mtd);
615 kfree(rtc_from4_mtd);
623 module_init(rtc_from4_init);
628 static void __exit rtc_from4_cleanup(void)
630 /* Release resource, unregister partitions */
631 nand_release(rtc_from4_mtd);
633 /* Free the MTD device structure */
634 kfree(rtc_from4_mtd);
636 #ifdef RTC_FROM4_HWECC
637 /* Free the reed solomon resources */
644 module_exit(rtc_from4_cleanup);
646 MODULE_LICENSE("GPL");
647 MODULE_AUTHOR("d.marlin <dmarlin@redhat.com");
648 MODULE_DESCRIPTION("Board-specific glue layer for AG-AND flash on Renesas FROM_BOARD4");