1 /*
2  * Copyright © 2009 - Maxim Levitsky
3  * Common routines & support for xD format
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  */
9 #include <linux/kernel.h>
10 #include <linux/mtd/nand.h>
11 #include <linux/module.h>
12 #include "sm_common.h"
13 
14 static struct nand_ecclayout nand_oob_sm = {
15 	.eccbytes = 6,
16 	.eccpos = {8, 9, 10, 13, 14, 15},
17 	.oobfree = {
18 		{.offset = 0 , .length = 4}, /* reserved */
19 		{.offset = 6 , .length = 2}, /* LBA1 */
20 		{.offset = 11, .length = 2}  /* LBA2 */
21 	}
22 };
23 
24 /* NOTE: This layout is is not compatabable with SmartMedia, */
25 /* because the 256 byte devices have page depenent oob layout */
26 /* However it does preserve the bad block markers */
27 /* If you use smftl, it will bypass this and work correctly */
28 /* If you not, then you break SmartMedia compliance anyway */
29 
30 static struct nand_ecclayout nand_oob_sm_small = {
31 	.eccbytes = 3,
32 	.eccpos = {0, 1, 2},
33 	.oobfree = {
34 		{.offset = 3 , .length = 2}, /* reserved */
35 		{.offset = 6 , .length = 2}, /* LBA1 */
36 	}
37 };
38 
39 
sm_block_markbad(struct mtd_info * mtd,loff_t ofs)40 static int sm_block_markbad(struct mtd_info *mtd, loff_t ofs)
41 {
42 	struct mtd_oob_ops ops;
43 	struct sm_oob oob;
44 	int ret, error = 0;
45 
46 	memset(&oob, -1, SM_OOB_SIZE);
47 	oob.block_status = 0x0F;
48 
49 	/* As long as this function is called on erase block boundaries
50 		it will work correctly for 256 byte nand */
51 	ops.mode = MTD_OPS_PLACE_OOB;
52 	ops.ooboffs = 0;
53 	ops.ooblen = mtd->oobsize;
54 	ops.oobbuf = (void *)&oob;
55 	ops.datbuf = NULL;
56 
57 
58 	ret = mtd_write_oob(mtd, ofs, &ops);
59 	if (ret < 0 || ops.oobretlen != SM_OOB_SIZE) {
60 		printk(KERN_NOTICE
61 			"sm_common: can't mark sector at %i as bad\n",
62 								(int)ofs);
63 		error = -EIO;
64 	} else
65 		mtd->ecc_stats.badblocks++;
66 
67 	return error;
68 }
69 
70 
71 static struct nand_flash_dev nand_smartmedia_flash_ids[] = {
72 	{"SmartMedia 1MiB 5V",          0x6e, 256, 1, 0x1000, 0},
73 	{"SmartMedia 1MiB 3,3V",        0xe8, 256, 1, 0x1000, 0},
74 	{"SmartMedia 1MiB 3,3V",        0xec, 256, 1, 0x1000, 0},
75 	{"SmartMedia 2MiB 3,3V",        0xea, 256, 2, 0x1000, 0},
76 	{"SmartMedia 2MiB 5V",          0x64, 256, 2, 0x1000, 0},
77 	{"SmartMedia 2MiB 3,3V ROM",    0x5d, 512, 2, 0x2000, NAND_ROM},
78 	{"SmartMedia 4MiB 3,3V",        0xe3, 512, 4, 0x2000, 0},
79 	{"SmartMedia 4MiB 3,3/5V",      0xe5, 512, 4, 0x2000, 0},
80 	{"SmartMedia 4MiB 5V",          0x6b, 512, 4, 0x2000, 0},
81 	{"SmartMedia 4MiB 3,3V ROM",    0xd5, 512, 4, 0x2000, NAND_ROM},
82 	{"SmartMedia 8MiB 3,3V",        0xe6, 512, 8, 0x2000, 0},
83 	{"SmartMedia 8MiB 3,3V ROM",    0xd6, 512, 8, 0x2000, NAND_ROM},
84 	{"SmartMedia 16MiB 3,3V",       0x73, 512, 16, 0x4000, 0},
85 	{"SmartMedia 16MiB 3,3V ROM",   0x57, 512, 16, 0x4000, NAND_ROM},
86 	{"SmartMedia 32MiB 3,3V",       0x75, 512, 32, 0x4000, 0},
87 	{"SmartMedia 32MiB 3,3V ROM",   0x58, 512, 32, 0x4000, NAND_ROM},
88 	{"SmartMedia 64MiB 3,3V",       0x76, 512, 64, 0x4000, 0},
89 	{"SmartMedia 64MiB 3,3V ROM",   0xd9, 512, 64, 0x4000, NAND_ROM},
90 	{"SmartMedia 128MiB 3,3V",      0x79, 512, 128, 0x4000, 0},
91 	{"SmartMedia 128MiB 3,3V ROM",  0xda, 512, 128, 0x4000, NAND_ROM},
92 	{"SmartMedia 256MiB 3,3V",      0x71, 512, 256, 0x4000 },
93 	{"SmartMedia 256MiB 3,3V ROM",  0x5b, 512, 256, 0x4000, NAND_ROM},
94 	{NULL,}
95 };
96 
97 #define XD_TYPEM       (NAND_NO_AUTOINCR | NAND_BROKEN_XD)
98 static struct nand_flash_dev nand_xd_flash_ids[] = {
99 
100 	{"xD 16MiB 3,3V",    0x73, 512, 16, 0x4000, 0},
101 	{"xD 32MiB 3,3V",    0x75, 512, 32, 0x4000, 0},
102 	{"xD 64MiB 3,3V",    0x76, 512, 64, 0x4000, 0},
103 	{"xD 128MiB 3,3V",   0x79, 512, 128, 0x4000, 0},
104 	{"xD 256MiB 3,3V",   0x71, 512, 256, 0x4000, XD_TYPEM},
105 	{"xD 512MiB 3,3V",   0xdc, 512, 512, 0x4000, XD_TYPEM},
106 	{"xD 1GiB 3,3V",     0xd3, 512, 1024, 0x4000, XD_TYPEM},
107 	{"xD 2GiB 3,3V",     0xd5, 512, 2048, 0x4000, XD_TYPEM},
108 	{NULL,}
109 };
110 
sm_register_device(struct mtd_info * mtd,int smartmedia)111 int sm_register_device(struct mtd_info *mtd, int smartmedia)
112 {
113 	struct nand_chip *chip = mtd->priv;
114 	int ret;
115 
116 	chip->options |= NAND_SKIP_BBTSCAN;
117 
118 	/* Scan for card properties */
119 	ret = nand_scan_ident(mtd, 1, smartmedia ?
120 		nand_smartmedia_flash_ids : nand_xd_flash_ids);
121 
122 	if (ret)
123 		return ret;
124 
125 	/* Bad block marker position */
126 	chip->badblockpos = 0x05;
127 	chip->badblockbits = 7;
128 	chip->block_markbad = sm_block_markbad;
129 
130 	/* ECC layout */
131 	if (mtd->writesize == SM_SECTOR_SIZE)
132 		chip->ecc.layout = &nand_oob_sm;
133 	else if (mtd->writesize == SM_SMALL_PAGE)
134 		chip->ecc.layout = &nand_oob_sm_small;
135 	else
136 		return -ENODEV;
137 
138 	ret = nand_scan_tail(mtd);
139 
140 	if (ret)
141 		return ret;
142 
143 	return mtd_device_register(mtd, NULL, 0);
144 }
145 EXPORT_SYMBOL_GPL(sm_register_device);
146 
147 MODULE_LICENSE("GPL");
148 MODULE_AUTHOR("Maxim Levitsky <maximlevitsky@gmail.com>");
149 MODULE_DESCRIPTION("Common SmartMedia/xD functions");
150