~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,24 +1,10 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* Core registration and callback routines for MTD
3	4	* drivers and users.
4	5	*
5	6	* Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
6	7	* Copyright © 2006 Red Hat UK Limited
7		- *
8		- * This program is free software; you can redistribute it and/or modify
9		- * it under the terms of the GNU General Public License as published by
10		- * the Free Software Foundation; either version 2 of the License, or
11		- * (at your option) any later version.
12		- *
13		- * This program is distributed in the hope that it will be useful,
14		- * but WITHOUT ANY WARRANTY; without even the implied warranty of
15		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16		- * GNU General Public License for more details.
17		- *
18		- * You should have received a copy of the GNU General Public License
19		- * along with this program; if not, write to the Free Software
20		- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21		- *
22	8	*/
23	9
24	10	#include <linux/module.h>
..	..	@@ -41,6 +27,7 @@
41	27	#include <linux/reboot.h>
42	28	#include <linux/leds.h>
43	29	#include <linux/debugfs.h>
	30	+#include <linux/nvmem-provider.h>
44	31
45	32	#include <linux/mtd/mtd.h>
46	33	#include <linux/mtd/partitions.h>
..	..	@@ -154,7 +141,6 @@
154	141	struct mtd_info *mtd = dev_get_drvdata(dev);
155	142
156	143	return snprintf(buf, PAGE_SIZE, "0x%lx\n", (unsigned long)mtd->flags);
157		-
158	144	}
159	145	static DEVICE_ATTR(flags, S_IRUGO, mtd_flags_show, NULL);
160	146
..	..	@@ -165,7 +151,6 @@
165	151
166	152	return snprintf(buf, PAGE_SIZE, "%llu\n",
167	153	(unsigned long long)mtd->size);
168		-
169	154	}
170	155	static DEVICE_ATTR(size, S_IRUGO, mtd_size_show, NULL);
171	156
..	..	@@ -175,7 +160,6 @@
175	160	struct mtd_info *mtd = dev_get_drvdata(dev);
176	161
177	162	return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->erasesize);
178		-
179	163	}
180	164	static DEVICE_ATTR(erasesize, S_IRUGO, mtd_erasesize_show, NULL);
181	165
..	..	@@ -185,7 +169,6 @@
185	169	struct mtd_info *mtd = dev_get_drvdata(dev);
186	170
187	171	return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->writesize);
188		-
189	172	}
190	173	static DEVICE_ATTR(writesize, S_IRUGO, mtd_writesize_show, NULL);
191	174
..	..	@@ -196,7 +179,6 @@
196	179	unsigned int subpagesize = mtd->writesize >> mtd->subpage_sft;
197	180
198	181	return snprintf(buf, PAGE_SIZE, "%u\n", subpagesize);
199		-
200	182	}
201	183	static DEVICE_ATTR(subpagesize, S_IRUGO, mtd_subpagesize_show, NULL);
202	184
..	..	@@ -206,7 +188,6 @@
206	188	struct mtd_info *mtd = dev_get_drvdata(dev);
207	189
208	190	return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->oobsize);
209		-
210	191	}
211	192	static DEVICE_ATTR(oobsize, S_IRUGO, mtd_oobsize_show, NULL);
212	193
..	..	@@ -225,7 +206,6 @@
225	206	struct mtd_info *mtd = dev_get_drvdata(dev);
226	207
227	208	return snprintf(buf, PAGE_SIZE, "%u\n", mtd->numeraseregions);
228		-
229	209	}
230	210	static DEVICE_ATTR(numeraseregions, S_IRUGO, mtd_numeraseregions_show,
231	211	NULL);
..	..	@@ -236,7 +216,6 @@
236	216	struct mtd_info *mtd = dev_get_drvdata(dev);
237	217
238	218	return snprintf(buf, PAGE_SIZE, "%s\n", mtd->name);
239		-
240	219	}
241	220	static DEVICE_ATTR(name, S_IRUGO, mtd_name_show, NULL);
242	221
..	..	@@ -356,6 +335,50 @@
356	335	.release = mtd_release,
357	336	};
358	337
	338	+static int mtd_partid_debug_show(struct seq_file s, void p)
	339	+{
	340	+ struct mtd_info *mtd = s->private;
	341	+
	342	+ seq_printf(s, "%s\n", mtd->dbg.partid);
	343	+
	344	+ return 0;
	345	+}
	346	+
	347	+DEFINE_SHOW_ATTRIBUTE(mtd_partid_debug);
	348	+
	349	+static int mtd_partname_debug_show(struct seq_file s, void p)
	350	+{
	351	+ struct mtd_info *mtd = s->private;
	352	+
	353	+ seq_printf(s, "%s\n", mtd->dbg.partname);
	354	+
	355	+ return 0;
	356	+}
	357	+
	358	+DEFINE_SHOW_ATTRIBUTE(mtd_partname_debug);
	359	+
	360	+static struct dentry *dfs_dir_mtd;
	361	+
	362	+static void mtd_debugfs_populate(struct mtd_info *mtd)
	363	+{
	364	+ struct device *dev = &mtd->dev;
	365	+ struct dentry *root;
	366	+
	367	+ if (IS_ERR_OR_NULL(dfs_dir_mtd))
	368	+ return;
	369	+
	370	+ root = debugfs_create_dir(dev_name(dev), dfs_dir_mtd);
	371	+ mtd->dbg.dfs_dir = root;
	372	+
	373	+ if (mtd->dbg.partid)
	374	+ debugfs_create_file("partid", 0400, root, mtd,
	375	+ &mtd_partid_debug_fops);
	376	+
	377	+ if (mtd->dbg.partname)
	378	+ debugfs_create_file("partname", 0400, root, mtd,
	379	+ &mtd_partname_debug_fops);
	380	+}
	381	+
359	382	#ifndef CONFIG_MMU
360	383	unsigned mtd_mmap_capabilities(struct mtd_info *mtd)
361	384	{
..	..	@@ -413,13 +436,14 @@
413	436	int mtd_wunit_to_pairing_info(struct mtd_info *mtd, int wunit,
414	437	struct mtd_pairing_info *info)
415	438	{
416		- int npairs = mtd_wunit_per_eb(mtd) / mtd_pairing_groups(mtd);
	439	+ struct mtd_info *master = mtd_get_master(mtd);
	440	+ int npairs = mtd_wunit_per_eb(master) / mtd_pairing_groups(master);
417	441
418	442	if (wunit < 0 \|\| wunit >= npairs)
419	443	return -EINVAL;
420	444
421		- if (mtd->pairing && mtd->pairing->get_info)
422		- return mtd->pairing->get_info(mtd, wunit, info);
	445	+ if (master->pairing && master->pairing->get_info)
	446	+ return master->pairing->get_info(master, wunit, info);
423	447
424	448	info->group = 0;
425	449	info->pair = wunit;
..	..	@@ -455,15 +479,16 @@
455	479	int mtd_pairing_info_to_wunit(struct mtd_info *mtd,
456	480	const struct mtd_pairing_info *info)
457	481	{
458		- int ngroups = mtd_pairing_groups(mtd);
459		- int npairs = mtd_wunit_per_eb(mtd) / ngroups;
	482	+ struct mtd_info *master = mtd_get_master(mtd);
	483	+ int ngroups = mtd_pairing_groups(master);
	484	+ int npairs = mtd_wunit_per_eb(master) / ngroups;
460	485
461	486	if (!info \|\| info->pair < 0 \|\| info->pair >= npairs \|\|
462	487	info->group < 0 \|\| info->group >= ngroups)
463	488	return -EINVAL;
464	489
465		- if (mtd->pairing && mtd->pairing->get_wunit)
466		- return mtd->pairing->get_wunit(mtd, info);
	490	+ if (master->pairing && master->pairing->get_wunit)
	491	+ return mtd->pairing->get_wunit(master, info);
467	492
468	493	return info->pair;
469	494	}
..	..	@@ -481,14 +506,59 @@
481	506	*/
482	507	int mtd_pairing_groups(struct mtd_info *mtd)
483	508	{
484		- if (!mtd->pairing \|\| !mtd->pairing->ngroups)
	509	+ struct mtd_info *master = mtd_get_master(mtd);
	510	+
	511	+ if (!master->pairing \|\| !master->pairing->ngroups)
485	512	return 1;
486	513
487		- return mtd->pairing->ngroups;
	514	+ return master->pairing->ngroups;
488	515	}
489	516	EXPORT_SYMBOL_GPL(mtd_pairing_groups);
490	517
491		-static struct dentry *dfs_dir_mtd;
	518	+static int mtd_nvmem_reg_read(void *priv, unsigned int offset,
	519	+ void *val, size_t bytes)
	520	+{
	521	+ struct mtd_info *mtd = priv;
	522	+ size_t retlen;
	523	+ int err;
	524	+
	525	+ err = mtd_read(mtd, offset, bytes, &retlen, val);
	526	+ if (err && err != -EUCLEAN)
	527	+ return err;
	528	+
	529	+ return retlen == bytes ? 0 : -EIO;
	530	+}
	531	+
	532	+static int mtd_nvmem_add(struct mtd_info *mtd)
	533	+{
	534	+ struct nvmem_config config = {};
	535	+
	536	+ config.id = -1;
	537	+ config.dev = &mtd->dev;
	538	+ config.name = dev_name(&mtd->dev);
	539	+ config.owner = THIS_MODULE;
	540	+ config.reg_read = mtd_nvmem_reg_read;
	541	+ config.size = mtd->size;
	542	+ config.word_size = 1;
	543	+ config.stride = 1;
	544	+ config.read_only = true;
	545	+ config.root_only = true;
	546	+ config.no_of_node = true;
	547	+ config.priv = mtd;
	548	+
	549	+ mtd->nvmem = nvmem_register(&config);
	550	+ if (IS_ERR(mtd->nvmem)) {
	551	+ /* Just ignore if there is no NVMEM support in the kernel */
	552	+ if (PTR_ERR(mtd->nvmem) == -EOPNOTSUPP) {
	553	+ mtd->nvmem = NULL;
	554	+ } else {
	555	+ dev_err(&mtd->dev, "Failed to register NVMEM device\n");
	556	+ return PTR_ERR(mtd->nvmem);
	557	+ }
	558	+ }
	559	+
	560	+ return 0;
	561	+}
492	562
493	563	/**
494	564	* add_mtd_device - register an MTD device
..	..	@@ -501,6 +571,7 @@
501	571
502	572	int add_mtd_device(struct mtd_info *mtd)
503	573	{
	574	+ struct mtd_info *master = mtd_get_master(mtd);
504	575	struct mtd_notifier *not;
505	576	int i, error;
506	577
..	..	@@ -514,8 +585,29 @@
514	585
515	586	BUG_ON(mtd->writesize == 0);
516	587
517		- if (WARN_ON((!mtd->erasesize \|\| !mtd->_erase) &&
	588	+ /*
	589	+ * MTD drivers should implement ->_{write,read}() or
	590	+ * ->_{write,read}_oob(), but not both.
	591	+ */
	592	+ if (WARN_ON((mtd->_write && mtd->_write_oob) \|\|
	593	+ (mtd->_read && mtd->_read_oob)))
	594	+ return -EINVAL;
	595	+
	596	+ if (WARN_ON((!mtd->erasesize \|\| !master->_erase) &&
518	597	!(mtd->flags & MTD_NO_ERASE)))
	598	+ return -EINVAL;
	599	+
	600	+ /*
	601	+ * MTD_SLC_ON_MLC_EMULATION can only be set on partitions, when the
	602	+ * master is an MLC NAND and has a proper pairing scheme defined.
	603	+ * We also reject masters that implement ->_writev() for now, because
	604	+ * NAND controller drivers don't implement this hook, and adding the
	605	+ * SLC -> MLC address/length conversion to this path is useless if we
	606	+ * don't have a user.
	607	+ */
	608	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION &&
	609	+ (!mtd_is_partition(mtd) \|\| master->type != MTD_MLCNANDFLASH \|\|
	610	+ !master->pairing \|\| master->_writev))
519	611	return -EINVAL;
520	612
521	613	mutex_lock(&mtd_table_mutex);
..	..	@@ -532,6 +624,14 @@
532	624	/* default value if not set by driver */
533	625	if (mtd->bitflip_threshold == 0)
534	626	mtd->bitflip_threshold = mtd->ecc_strength;
	627	+
	628	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
	629	+ int ngroups = mtd_pairing_groups(master);
	630	+
	631	+ mtd->erasesize /= ngroups;
	632	+ mtd->size = (u64)mtd_div_by_eb(mtd->size, master) *
	633	+ mtd->erasesize;
	634	+ }
535	635
536	636	if (is_power_of_2(mtd->erasesize))
537	637	mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
..	..	@@ -567,16 +667,17 @@
567	667	dev_set_drvdata(&mtd->dev, mtd);
568	668	of_node_get(mtd_get_of_node(mtd));
569	669	error = device_register(&mtd->dev);
570		- if (error)
	670	+ if (error) {
	671	+ put_device(&mtd->dev);
571	672	goto fail_added;
572		-
573		- if (!IS_ERR_OR_NULL(dfs_dir_mtd)) {
574		- mtd->dbg.dfs_dir = debugfs_create_dir(dev_name(&mtd->dev), dfs_dir_mtd);
575		- if (IS_ERR_OR_NULL(mtd->dbg.dfs_dir)) {
576		- pr_debug("mtd device %s won't show data in debugfs\n",
577		- dev_name(&mtd->dev));
578		- }
579	673	}
	674	+
	675	+ /* Add the nvmem provider */
	676	+ error = mtd_nvmem_add(mtd);
	677	+ if (error)
	678	+ goto fail_nvmem_add;
	679	+
	680	+ mtd_debugfs_populate(mtd);
580	681
581	682	device_create(&mtd_class, mtd->dev.parent, MTD_DEVT(i) + 1, NULL,
582	683	"mtd%dro", i);
..	..	@@ -595,6 +696,8 @@
595	696	__module_get(THIS_MODULE);
596	697	return 0;
597	698
	699	+fail_nvmem_add:
	700	+ device_unregister(&mtd->dev);
598	701	fail_added:
599	702	of_node_put(mtd_get_of_node(mtd));
600	703	idr_remove(&mtd_idr, i);
..	..	@@ -620,8 +723,6 @@
620	723
621	724	mutex_lock(&mtd_table_mutex);
622	725
623		- debugfs_remove_recursive(mtd->dbg.dfs_dir);
624		-
625	726	if (idr_find(&mtd_idr, mtd->index) != mtd) {
626	727	ret = -ENODEV;
627	728	goto out_error;
..	..	@@ -637,6 +738,12 @@
637	738	mtd->index, mtd->name, mtd->usecount);
638	739	ret = -EBUSY;
639	740	} else {
	741	+ debugfs_remove_recursive(mtd->dbg.dfs_dir);
	742	+
	743	+ /* Try to remove the NVMEM provider */
	744	+ if (mtd->nvmem)
	745	+ nvmem_unregister(mtd->nvmem);
	746	+
640	747	device_unregister(&mtd->dev);
641	748
642	749	idr_remove(&mtd_idr, mtd->index);
..	..	@@ -665,6 +772,9 @@
665	772	} else {
666	773	pr_debug("mtd device won't show a device symlink in sysfs\n");
667	774	}
	775	+
	776	+ INIT_LIST_HEAD(&mtd->partitions);
	777	+ mutex_init(&mtd->master.partitions_lock);
668	778	}
669	779
670	780	/**
..	..	@@ -873,20 +983,28 @@
873	983
874	984	int __get_mtd_device(struct mtd_info *mtd)
875	985	{
	986	+ struct mtd_info *master = mtd_get_master(mtd);
876	987	int err;
877	988
878		- if (!try_module_get(mtd->owner))
	989	+ if (!try_module_get(master->owner))
879	990	return -ENODEV;
880	991
881		- if (mtd->_get_device) {
882		- err = mtd->_get_device(mtd);
	992	+ if (master->_get_device) {
	993	+ err = master->_get_device(mtd);
883	994
884	995	if (err) {
885		- module_put(mtd->owner);
	996	+ module_put(master->owner);
886	997	return err;
887	998	}
888	999	}
889		- mtd->usecount++;
	1000	+
	1001	+ master->usecount++;
	1002	+
	1003	+ while (mtd->parent) {
	1004	+ mtd->usecount++;
	1005	+ mtd = mtd->parent;
	1006	+ }
	1007	+
890	1008	return 0;
891	1009	}
892	1010	EXPORT_SYMBOL_GPL(__get_mtd_device);
..	..	@@ -940,13 +1058,20 @@
940	1058
941	1059	void __put_mtd_device(struct mtd_info *mtd)
942	1060	{
943		- --mtd->usecount;
944		- BUG_ON(mtd->usecount < 0);
	1061	+ struct mtd_info *master = mtd_get_master(mtd);
945	1062
946		- if (mtd->_put_device)
947		- mtd->_put_device(mtd);
	1063	+ while (mtd->parent) {
	1064	+ --mtd->usecount;
	1065	+ BUG_ON(mtd->usecount < 0);
	1066	+ mtd = mtd->parent;
	1067	+ }
948	1068
949		- module_put(mtd->owner);
	1069	+ master->usecount--;
	1070	+
	1071	+ if (master->_put_device)
	1072	+ master->_put_device(master);
	1073	+
	1074	+ module_put(master->owner);
950	1075	}
951	1076	EXPORT_SYMBOL_GPL(__put_mtd_device);
952	1077
..	..	@@ -957,9 +1082,15 @@
957	1082	*/
958	1083	int mtd_erase(struct mtd_info mtd, struct erase_info instr)
959	1084	{
960		- instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
	1085	+ struct mtd_info *master = mtd_get_master(mtd);
	1086	+ u64 mst_ofs = mtd_get_master_ofs(mtd, 0);
	1087	+ struct erase_info adjinstr;
	1088	+ int ret;
961	1089
962		- if (!mtd->erasesize \|\| !mtd->_erase)
	1090	+ instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
	1091	+ adjinstr = *instr;
	1092	+
	1093	+ if (!mtd->erasesize \|\| !master->_erase)
963	1094	return -ENOTSUPP;
964	1095
965	1096	if (instr->addr >= mtd->size \|\| instr->len > mtd->size - instr->addr)
..	..	@@ -971,7 +1102,29 @@
971	1102	return 0;
972	1103
973	1104	ledtrig_mtd_activity();
974		- return mtd->_erase(mtd, instr);
	1105	+
	1106	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
	1107	+ adjinstr.addr = (loff_t)mtd_div_by_eb(instr->addr, mtd) *
	1108	+ master->erasesize;
	1109	+ adjinstr.len = ((u64)mtd_div_by_eb(instr->addr + instr->len, mtd) *
	1110	+ master->erasesize) -
	1111	+ adjinstr.addr;
	1112	+ }
	1113	+
	1114	+ adjinstr.addr += mst_ofs;
	1115	+
	1116	+ ret = master->_erase(master, &adjinstr);
	1117	+
	1118	+ if (adjinstr.fail_addr != MTD_FAIL_ADDR_UNKNOWN) {
	1119	+ instr->fail_addr = adjinstr.fail_addr - mst_ofs;
	1120	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
	1121	+ instr->fail_addr = mtd_div_by_eb(instr->fail_addr,
	1122	+ master);
	1123	+ instr->fail_addr *= mtd->erasesize;
	1124	+ }
	1125	+ }
	1126	+
	1127	+ return ret;
975	1128	}
976	1129	EXPORT_SYMBOL_GPL(mtd_erase);
977	1130
..	..	@@ -981,30 +1134,36 @@
981	1134	int mtd_point(struct mtd_info mtd, loff_t from, size_t len, size_t retlen,
982	1135	void *virt, resource_size_t phys)
983	1136	{
	1137	+ struct mtd_info *master = mtd_get_master(mtd);
	1138	+
984	1139	*retlen = 0;
985	1140	*virt = NULL;
986	1141	if (phys)
987	1142	*phys = 0;
988		- if (!mtd->_point)
	1143	+ if (!master->_point)
989	1144	return -EOPNOTSUPP;
990	1145	if (from < 0 \|\| from >= mtd->size \|\| len > mtd->size - from)
991	1146	return -EINVAL;
992	1147	if (!len)
993	1148	return 0;
994		- return mtd->_point(mtd, from, len, retlen, virt, phys);
	1149	+
	1150	+ from = mtd_get_master_ofs(mtd, from);
	1151	+ return master->_point(master, from, len, retlen, virt, phys);
995	1152	}
996	1153	EXPORT_SYMBOL_GPL(mtd_point);
997	1154
998	1155	/* We probably shouldn't allow XIP if the unpoint isn't a NULL */
999	1156	int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
1000	1157	{
1001		- if (!mtd->_unpoint)
	1158	+ struct mtd_info *master = mtd_get_master(mtd);
	1159	+
	1160	+ if (!master->_unpoint)
1002	1161	return -EOPNOTSUPP;
1003	1162	if (from < 0 \|\| from >= mtd->size \|\| len > mtd->size - from)
1004	1163	return -EINVAL;
1005	1164	if (!len)
1006	1165	return 0;
1007		- return mtd->_unpoint(mtd, from, len);
	1166	+ return master->_unpoint(master, mtd_get_master_ofs(mtd, from), len);
1008	1167	}
1009	1168	EXPORT_SYMBOL_GPL(mtd_unpoint);
1010	1169
..	..	@@ -1031,70 +1190,54 @@
1031	1190	}
1032	1191	EXPORT_SYMBOL_GPL(mtd_get_unmapped_area);
1033	1192
	1193	+static void mtd_update_ecc_stats(struct mtd_info mtd, struct mtd_info master,
	1194	+ const struct mtd_ecc_stats *old_stats)
	1195	+{
	1196	+ struct mtd_ecc_stats diff;
	1197	+
	1198	+ if (master == mtd)
	1199	+ return;
	1200	+
	1201	+ diff = master->ecc_stats;
	1202	+ diff.failed -= old_stats->failed;
	1203	+ diff.corrected -= old_stats->corrected;
	1204	+
	1205	+ while (mtd->parent) {
	1206	+ mtd->ecc_stats.failed += diff.failed;
	1207	+ mtd->ecc_stats.corrected += diff.corrected;
	1208	+ mtd = mtd->parent;
	1209	+ }
	1210	+}
	1211	+
1034	1212	int mtd_read(struct mtd_info mtd, loff_t from, size_t len, size_t retlen,
1035	1213	u_char *buf)
1036	1214	{
1037		- int ret_code;
1038		- *retlen = 0;
1039		- if (from < 0 \|\| from >= mtd->size \|\| len > mtd->size - from)
1040		- return -EINVAL;
1041		- if (!len)
1042		- return 0;
	1215	+ struct mtd_oob_ops ops = {
	1216	+ .len = len,
	1217	+ .datbuf = buf,
	1218	+ };
	1219	+ int ret;
1043	1220
1044		- ledtrig_mtd_activity();
1045		- /*
1046		- * In the absence of an error, drivers return a non-negative integer
1047		- * representing the maximum number of bitflips that were corrected on
1048		- * any one ecc region (if applicable; zero otherwise).
1049		- */
1050		- if (mtd->_read) {
1051		- ret_code = mtd->_read(mtd, from, len, retlen, buf);
1052		- } else if (mtd->_read_oob) {
1053		- struct mtd_oob_ops ops = {
1054		- .len = len,
1055		- .datbuf = buf,
1056		- };
	1221	+ ret = mtd_read_oob(mtd, from, &ops);
	1222	+ *retlen = ops.retlen;
1057	1223
1058		- ret_code = mtd->_read_oob(mtd, from, &ops);
1059		- *retlen = ops.retlen;
1060		- } else {
1061		- return -ENOTSUPP;
1062		- }
1063		-
1064		- if (unlikely(ret_code < 0))
1065		- return ret_code;
1066		- if (mtd->ecc_strength == 0)
1067		- return 0; /* device lacks ecc */
1068		- return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0;
	1224	+ return ret;
1069	1225	}
1070	1226	EXPORT_SYMBOL_GPL(mtd_read);
1071	1227
1072	1228	int mtd_write(struct mtd_info mtd, loff_t to, size_t len, size_t retlen,
1073	1229	const u_char *buf)
1074	1230	{
1075		- *retlen = 0;
1076		- if (to < 0 \|\| to >= mtd->size \|\| len > mtd->size - to)
1077		- return -EINVAL;
1078		- if ((!mtd->_write && !mtd->_write_oob) \|\|
1079		- !(mtd->flags & MTD_WRITEABLE))
1080		- return -EROFS;
1081		- if (!len)
1082		- return 0;
1083		- ledtrig_mtd_activity();
	1231	+ struct mtd_oob_ops ops = {
	1232	+ .len = len,
	1233	+ .datbuf = (u8 *)buf,
	1234	+ };
	1235	+ int ret;
1084	1236
1085		- if (!mtd->_write) {
1086		- struct mtd_oob_ops ops = {
1087		- .len = len,
1088		- .datbuf = (u8 *)buf,
1089		- };
1090		- int ret;
	1237	+ ret = mtd_write_oob(mtd, to, &ops);
	1238	+ *retlen = ops.retlen;
1091	1239
1092		- ret = mtd->_write_oob(mtd, to, &ops);
1093		- *retlen = ops.retlen;
1094		- return ret;
1095		- }
1096		-
1097		- return mtd->_write(mtd, to, len, retlen, buf);
	1240	+ return ret;
1098	1241	}
1099	1242	EXPORT_SYMBOL_GPL(mtd_write);
1100	1243
..	..	@@ -1108,8 +1251,10 @@
1108	1251	int mtd_panic_write(struct mtd_info mtd, loff_t to, size_t len, size_t retlen,
1109	1252	const u_char *buf)
1110	1253	{
	1254	+ struct mtd_info *master = mtd_get_master(mtd);
	1255	+
1111	1256	*retlen = 0;
1112		- if (!mtd->_panic_write)
	1257	+ if (!master->_panic_write)
1113	1258	return -EOPNOTSUPP;
1114	1259	if (to < 0 \|\| to >= mtd->size \|\| len > mtd->size - to)
1115	1260	return -EINVAL;
..	..	@@ -1117,7 +1262,11 @@
1117	1262	return -EROFS;
1118	1263	if (!len)
1119	1264	return 0;
1120		- return mtd->_panic_write(mtd, to, len, retlen, buf);
	1265	+ if (!master->oops_panic_write)
	1266	+ master->oops_panic_write = true;
	1267	+
	1268	+ return master->_panic_write(master, mtd_get_master_ofs(mtd, to), len,
	1269	+ retlen, buf);
1121	1270	}
1122	1271	EXPORT_SYMBOL_GPL(mtd_panic_write);
1123	1272
..	..	@@ -1139,13 +1288,13 @@
1139	1288	return -EINVAL;
1140	1289
1141	1290	if (ops->ooblen) {
1142		- u64 maxooblen;
	1291	+ size_t maxooblen;
1143	1292
1144	1293	if (ops->ooboffs >= mtd_oobavail(mtd, ops))
1145	1294	return -EINVAL;
1146	1295
1147		- maxooblen = ((mtd_div_by_ws(mtd->size, mtd) -
1148		- mtd_div_by_ws(offs, mtd)) *
	1296	+ maxooblen = ((size_t)(mtd_div_by_ws(mtd->size, mtd) -
	1297	+ mtd_div_by_ws(offs, mtd)) *
1149	1298	mtd_oobavail(mtd, ops)) - ops->ooboffs;
1150	1299	if (ops->ooblen > maxooblen)
1151	1300	return -EINVAL;
..	..	@@ -1154,9 +1303,107 @@
1154	1303	return 0;
1155	1304	}
1156	1305
	1306	+static int mtd_read_oob_std(struct mtd_info *mtd, loff_t from,
	1307	+ struct mtd_oob_ops *ops)
	1308	+{
	1309	+ struct mtd_info *master = mtd_get_master(mtd);
	1310	+ int ret;
	1311	+
	1312	+ from = mtd_get_master_ofs(mtd, from);
	1313	+ if (master->_read_oob)
	1314	+ ret = master->_read_oob(master, from, ops);
	1315	+ else
	1316	+ ret = master->_read(master, from, ops->len, &ops->retlen,
	1317	+ ops->datbuf);
	1318	+
	1319	+ return ret;
	1320	+}
	1321	+
	1322	+static int mtd_write_oob_std(struct mtd_info *mtd, loff_t to,
	1323	+ struct mtd_oob_ops *ops)
	1324	+{
	1325	+ struct mtd_info *master = mtd_get_master(mtd);
	1326	+ int ret;
	1327	+
	1328	+ to = mtd_get_master_ofs(mtd, to);
	1329	+ if (master->_write_oob)
	1330	+ ret = master->_write_oob(master, to, ops);
	1331	+ else
	1332	+ ret = master->_write(master, to, ops->len, &ops->retlen,
	1333	+ ops->datbuf);
	1334	+
	1335	+ return ret;
	1336	+}
	1337	+
	1338	+static int mtd_io_emulated_slc(struct mtd_info *mtd, loff_t start, bool read,
	1339	+ struct mtd_oob_ops *ops)
	1340	+{
	1341	+ struct mtd_info *master = mtd_get_master(mtd);
	1342	+ int ngroups = mtd_pairing_groups(master);
	1343	+ int npairs = mtd_wunit_per_eb(master) / ngroups;
	1344	+ struct mtd_oob_ops adjops = *ops;
	1345	+ unsigned int wunit, oobavail;
	1346	+ struct mtd_pairing_info info;
	1347	+ int max_bitflips = 0;
	1348	+ u32 ebofs, pageofs;
	1349	+ loff_t base, pos;
	1350	+
	1351	+ ebofs = mtd_mod_by_eb(start, mtd);
	1352	+ base = (loff_t)mtd_div_by_eb(start, mtd) * master->erasesize;
	1353	+ info.group = 0;
	1354	+ info.pair = mtd_div_by_ws(ebofs, mtd);
	1355	+ pageofs = mtd_mod_by_ws(ebofs, mtd);
	1356	+ oobavail = mtd_oobavail(mtd, ops);
	1357	+
	1358	+ while (ops->retlen < ops->len \|\| ops->oobretlen < ops->ooblen) {
	1359	+ int ret;
	1360	+
	1361	+ if (info.pair >= npairs) {
	1362	+ info.pair = 0;
	1363	+ base += master->erasesize;
	1364	+ }
	1365	+
	1366	+ wunit = mtd_pairing_info_to_wunit(master, &info);
	1367	+ pos = mtd_wunit_to_offset(mtd, base, wunit);
	1368	+
	1369	+ adjops.len = ops->len - ops->retlen;
	1370	+ if (adjops.len > mtd->writesize - pageofs)
	1371	+ adjops.len = mtd->writesize - pageofs;
	1372	+
	1373	+ adjops.ooblen = ops->ooblen - ops->oobretlen;
	1374	+ if (adjops.ooblen > oobavail - adjops.ooboffs)
	1375	+ adjops.ooblen = oobavail - adjops.ooboffs;
	1376	+
	1377	+ if (read) {
	1378	+ ret = mtd_read_oob_std(mtd, pos + pageofs, &adjops);
	1379	+ if (ret > 0)
	1380	+ max_bitflips = max(max_bitflips, ret);
	1381	+ } else {
	1382	+ ret = mtd_write_oob_std(mtd, pos + pageofs, &adjops);
	1383	+ }
	1384	+
	1385	+ if (ret < 0)
	1386	+ return ret;
	1387	+
	1388	+ max_bitflips = max(max_bitflips, ret);
	1389	+ ops->retlen += adjops.retlen;
	1390	+ ops->oobretlen += adjops.oobretlen;
	1391	+ adjops.datbuf += adjops.retlen;
	1392	+ adjops.oobbuf += adjops.oobretlen;
	1393	+ adjops.ooboffs = 0;
	1394	+ pageofs = 0;
	1395	+ info.pair++;
	1396	+ }
	1397	+
	1398	+ return max_bitflips;
	1399	+}
	1400	+
1157	1401	int mtd_read_oob(struct mtd_info mtd, loff_t from, struct mtd_oob_ops ops)
1158	1402	{
	1403	+ struct mtd_info *master = mtd_get_master(mtd);
	1404	+ struct mtd_ecc_stats old_stats = master->ecc_stats;
1159	1405	int ret_code;
	1406	+
1160	1407	ops->retlen = ops->oobretlen = 0;
1161	1408
1162	1409	ret_code = mtd_check_oob_ops(mtd, from, ops);
..	..	@@ -1166,14 +1413,15 @@
1166	1413	ledtrig_mtd_activity();
1167	1414
1168	1415	/* Check the validity of a potential fallback on mtd->_read */
1169		- if (!mtd->_read_oob && (!mtd->_read \|\| ops->oobbuf))
	1416	+ if (!master->_read_oob && (!master->_read \|\| ops->oobbuf))
1170	1417	return -EOPNOTSUPP;
1171	1418
1172		- if (mtd->_read_oob)
1173		- ret_code = mtd->_read_oob(mtd, from, ops);
	1419	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
	1420	+ ret_code = mtd_io_emulated_slc(mtd, from, true, ops);
1174	1421	else
1175		- ret_code = mtd->_read(mtd, from, ops->len, &ops->retlen,
1176		- ops->datbuf);
	1422	+ ret_code = mtd_read_oob_std(mtd, from, ops);
	1423	+
	1424	+ mtd_update_ecc_stats(mtd, master, &old_stats);
1177	1425
1178	1426	/*
1179	1427	* In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics
..	..	@@ -1192,6 +1440,7 @@
1192	1440	int mtd_write_oob(struct mtd_info *mtd, loff_t to,
1193	1441	struct mtd_oob_ops *ops)
1194	1442	{
	1443	+ struct mtd_info *master = mtd_get_master(mtd);
1195	1444	int ret;
1196	1445
1197	1446	ops->retlen = ops->oobretlen = 0;
..	..	@@ -1206,14 +1455,13 @@
1206	1455	ledtrig_mtd_activity();
1207	1456
1208	1457	/* Check the validity of a potential fallback on mtd->_write */
1209		- if (!mtd->_write_oob && (!mtd->_write \|\| ops->oobbuf))
	1458	+ if (!master->_write_oob && (!master->_write \|\| ops->oobbuf))
1210	1459	return -EOPNOTSUPP;
1211	1460
1212		- if (mtd->_write_oob)
1213		- return mtd->_write_oob(mtd, to, ops);
1214		- else
1215		- return mtd->_write(mtd, to, ops->len, &ops->retlen,
1216		- ops->datbuf);
	1461	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
	1462	+ return mtd_io_emulated_slc(mtd, to, false, ops);
	1463	+
	1464	+ return mtd_write_oob_std(mtd, to, ops);
1217	1465	}
1218	1466	EXPORT_SYMBOL_GPL(mtd_write_oob);
1219	1467
..	..	@@ -1236,15 +1484,17 @@
1236	1484	int mtd_ooblayout_ecc(struct mtd_info *mtd, int section,
1237	1485	struct mtd_oob_region *oobecc)
1238	1486	{
	1487	+ struct mtd_info *master = mtd_get_master(mtd);
	1488	+
1239	1489	memset(oobecc, 0, sizeof(*oobecc));
1240	1490
1241		- if (!mtd \|\| section < 0)
	1491	+ if (!master \|\| section < 0)
1242	1492	return -EINVAL;
1243	1493
1244		- if (!mtd->ooblayout \|\| !mtd->ooblayout->ecc)
	1494	+ if (!master->ooblayout \|\| !master->ooblayout->ecc)
1245	1495	return -ENOTSUPP;
1246	1496
1247		- return mtd->ooblayout->ecc(mtd, section, oobecc);
	1497	+ return master->ooblayout->ecc(master, section, oobecc);
1248	1498	}
1249	1499	EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc);
1250	1500
..	..	@@ -1268,15 +1518,17 @@
1268	1518	int mtd_ooblayout_free(struct mtd_info *mtd, int section,
1269	1519	struct mtd_oob_region *oobfree)
1270	1520	{
	1521	+ struct mtd_info *master = mtd_get_master(mtd);
	1522	+
1271	1523	memset(oobfree, 0, sizeof(*oobfree));
1272	1524
1273		- if (!mtd \|\| section < 0)
	1525	+ if (!master \|\| section < 0)
1274	1526	return -EINVAL;
1275	1527
1276		- if (!mtd->ooblayout \|\| !mtd->ooblayout->free)
	1528	+ if (!master->ooblayout \|\| !master->ooblayout->free)
1277	1529	return -ENOTSUPP;
1278	1530
1279		- return mtd->ooblayout->free(mtd, section, oobfree);
	1531	+ return master->ooblayout->free(master, section, oobfree);
1280	1532	}
1281	1533	EXPORT_SYMBOL_GPL(mtd_ooblayout_free);
1282	1534
..	..	@@ -1537,7 +1789,7 @@
1537	1789	* @start: first ECC byte to set
1538	1790	* @nbytes: number of ECC bytes to set
1539	1791	*
1540		- * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
	1792	+ * Works like mtd_ooblayout_set_bytes(), except it acts on free bytes.
1541	1793	*
1542	1794	* Returns zero on success, a negative error code otherwise.
1543	1795	*/
..	..	@@ -1585,60 +1837,69 @@
1585	1837	int mtd_get_fact_prot_info(struct mtd_info mtd, size_t len, size_t retlen,
1586	1838	struct otp_info *buf)
1587	1839	{
1588		- if (!mtd->_get_fact_prot_info)
	1840	+ struct mtd_info *master = mtd_get_master(mtd);
	1841	+
	1842	+ if (!master->_get_fact_prot_info)
1589	1843	return -EOPNOTSUPP;
1590	1844	if (!len)
1591	1845	return 0;
1592		- return mtd->_get_fact_prot_info(mtd, len, retlen, buf);
	1846	+ return master->_get_fact_prot_info(master, len, retlen, buf);
1593	1847	}
1594	1848	EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info);
1595	1849
1596	1850	int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
1597	1851	size_t retlen, u_char buf)
1598	1852	{
	1853	+ struct mtd_info *master = mtd_get_master(mtd);
	1854	+
1599	1855	*retlen = 0;
1600		- if (!mtd->_read_fact_prot_reg)
	1856	+ if (!master->_read_fact_prot_reg)
1601	1857	return -EOPNOTSUPP;
1602	1858	if (!len)
1603	1859	return 0;
1604		- return mtd->_read_fact_prot_reg(mtd, from, len, retlen, buf);
	1860	+ return master->_read_fact_prot_reg(master, from, len, retlen, buf);
1605	1861	}
1606	1862	EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg);
1607	1863
1608	1864	int mtd_get_user_prot_info(struct mtd_info mtd, size_t len, size_t retlen,
1609	1865	struct otp_info *buf)
1610	1866	{
1611		- if (!mtd->_get_user_prot_info)
	1867	+ struct mtd_info *master = mtd_get_master(mtd);
	1868	+
	1869	+ if (!master->_get_user_prot_info)
1612	1870	return -EOPNOTSUPP;
1613	1871	if (!len)
1614	1872	return 0;
1615		- return mtd->_get_user_prot_info(mtd, len, retlen, buf);
	1873	+ return master->_get_user_prot_info(master, len, retlen, buf);
1616	1874	}
1617	1875	EXPORT_SYMBOL_GPL(mtd_get_user_prot_info);
1618	1876
1619	1877	int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
1620	1878	size_t retlen, u_char buf)
1621	1879	{
	1880	+ struct mtd_info *master = mtd_get_master(mtd);
	1881	+
1622	1882	*retlen = 0;
1623		- if (!mtd->_read_user_prot_reg)
	1883	+ if (!master->_read_user_prot_reg)
1624	1884	return -EOPNOTSUPP;
1625	1885	if (!len)
1626	1886	return 0;
1627		- return mtd->_read_user_prot_reg(mtd, from, len, retlen, buf);
	1887	+ return master->_read_user_prot_reg(master, from, len, retlen, buf);
1628	1888	}
1629	1889	EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg);
1630	1890
1631	1891	int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len,
1632	1892	size_t retlen, u_char buf)
1633	1893	{
	1894	+ struct mtd_info *master = mtd_get_master(mtd);
1634	1895	int ret;
1635	1896
1636	1897	*retlen = 0;
1637		- if (!mtd->_write_user_prot_reg)
	1898	+ if (!master->_write_user_prot_reg)
1638	1899	return -EOPNOTSUPP;
1639	1900	if (!len)
1640	1901	return 0;
1641		- ret = mtd->_write_user_prot_reg(mtd, to, len, retlen, buf);
	1902	+ ret = master->_write_user_prot_reg(master, to, len, retlen, buf);
1642	1903	if (ret)
1643	1904	return ret;
1644	1905
..	..	@@ -1652,80 +1913,134 @@
1652	1913
1653	1914	int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len)
1654	1915	{
1655		- if (!mtd->_lock_user_prot_reg)
	1916	+ struct mtd_info *master = mtd_get_master(mtd);
	1917	+
	1918	+ if (!master->_lock_user_prot_reg)
1656	1919	return -EOPNOTSUPP;
1657	1920	if (!len)
1658	1921	return 0;
1659		- return mtd->_lock_user_prot_reg(mtd, from, len);
	1922	+ return master->_lock_user_prot_reg(master, from, len);
1660	1923	}
1661	1924	EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg);
1662	1925
1663	1926	/* Chip-supported device locking */
1664	1927	int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1665	1928	{
1666		- if (!mtd->_lock)
	1929	+ struct mtd_info *master = mtd_get_master(mtd);
	1930	+
	1931	+ if (!master->_lock)
1667	1932	return -EOPNOTSUPP;
1668	1933	if (ofs < 0 \|\| ofs >= mtd->size \|\| len > mtd->size - ofs)
1669	1934	return -EINVAL;
1670	1935	if (!len)
1671	1936	return 0;
1672		- return mtd->_lock(mtd, ofs, len);
	1937	+
	1938	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
	1939	+ ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
	1940	+ len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
	1941	+ }
	1942	+
	1943	+ return master->_lock(master, mtd_get_master_ofs(mtd, ofs), len);
1673	1944	}
1674	1945	EXPORT_SYMBOL_GPL(mtd_lock);
1675	1946
1676	1947	int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1677	1948	{
1678		- if (!mtd->_unlock)
	1949	+ struct mtd_info *master = mtd_get_master(mtd);
	1950	+
	1951	+ if (!master->_unlock)
1679	1952	return -EOPNOTSUPP;
1680	1953	if (ofs < 0 \|\| ofs >= mtd->size \|\| len > mtd->size - ofs)
1681	1954	return -EINVAL;
1682	1955	if (!len)
1683	1956	return 0;
1684		- return mtd->_unlock(mtd, ofs, len);
	1957	+
	1958	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
	1959	+ ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
	1960	+ len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
	1961	+ }
	1962	+
	1963	+ return master->_unlock(master, mtd_get_master_ofs(mtd, ofs), len);
1685	1964	}
1686	1965	EXPORT_SYMBOL_GPL(mtd_unlock);
1687	1966
1688	1967	int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1689	1968	{
1690		- if (!mtd->_is_locked)
	1969	+ struct mtd_info *master = mtd_get_master(mtd);
	1970	+
	1971	+ if (!master->_is_locked)
1691	1972	return -EOPNOTSUPP;
1692	1973	if (ofs < 0 \|\| ofs >= mtd->size \|\| len > mtd->size - ofs)
1693	1974	return -EINVAL;
1694	1975	if (!len)
1695	1976	return 0;
1696		- return mtd->_is_locked(mtd, ofs, len);
	1977	+
	1978	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
	1979	+ ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
	1980	+ len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
	1981	+ }
	1982	+
	1983	+ return master->_is_locked(master, mtd_get_master_ofs(mtd, ofs), len);
1697	1984	}
1698	1985	EXPORT_SYMBOL_GPL(mtd_is_locked);
1699	1986
1700	1987	int mtd_block_isreserved(struct mtd_info *mtd, loff_t ofs)
1701	1988	{
	1989	+ struct mtd_info *master = mtd_get_master(mtd);
	1990	+
1702	1991	if (ofs < 0 \|\| ofs >= mtd->size)
1703	1992	return -EINVAL;
1704		- if (!mtd->_block_isreserved)
	1993	+ if (!master->_block_isreserved)
1705	1994	return 0;
1706		- return mtd->_block_isreserved(mtd, ofs);
	1995	+
	1996	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
	1997	+ ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
	1998	+
	1999	+ return master->_block_isreserved(master, mtd_get_master_ofs(mtd, ofs));
1707	2000	}
1708	2001	EXPORT_SYMBOL_GPL(mtd_block_isreserved);
1709	2002
1710	2003	int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs)
1711	2004	{
	2005	+ struct mtd_info *master = mtd_get_master(mtd);
	2006	+
1712	2007	if (ofs < 0 \|\| ofs >= mtd->size)
1713	2008	return -EINVAL;
1714		- if (!mtd->_block_isbad)
	2009	+ if (!master->_block_isbad)
1715	2010	return 0;
1716		- return mtd->_block_isbad(mtd, ofs);
	2011	+
	2012	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
	2013	+ ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
	2014	+
	2015	+ return master->_block_isbad(master, mtd_get_master_ofs(mtd, ofs));
1717	2016	}
1718	2017	EXPORT_SYMBOL_GPL(mtd_block_isbad);
1719	2018
1720	2019	int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs)
1721	2020	{
1722		- if (!mtd->_block_markbad)
	2021	+ struct mtd_info *master = mtd_get_master(mtd);
	2022	+ int ret;
	2023	+
	2024	+ if (!master->_block_markbad)
1723	2025	return -EOPNOTSUPP;
1724	2026	if (ofs < 0 \|\| ofs >= mtd->size)
1725	2027	return -EINVAL;
1726	2028	if (!(mtd->flags & MTD_WRITEABLE))
1727	2029	return -EROFS;
1728		- return mtd->_block_markbad(mtd, ofs);
	2030	+
	2031	+ if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
	2032	+ ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
	2033	+
	2034	+ ret = master->_block_markbad(master, mtd_get_master_ofs(mtd, ofs));
	2035	+ if (ret)
	2036	+ return ret;
	2037	+
	2038	+ while (mtd->parent) {
	2039	+ mtd->ecc_stats.badblocks++;
	2040	+ mtd = mtd->parent;
	2041	+ }
	2042	+
	2043	+ return 0;
1729	2044	}
1730	2045	EXPORT_SYMBOL_GPL(mtd_block_markbad);
1731	2046
..	..	@@ -1775,12 +2090,17 @@
1775	2090	int mtd_writev(struct mtd_info mtd, const struct kvec vecs,
1776	2091	unsigned long count, loff_t to, size_t *retlen)
1777	2092	{
	2093	+ struct mtd_info *master = mtd_get_master(mtd);
	2094	+
1778	2095	*retlen = 0;
1779	2096	if (!(mtd->flags & MTD_WRITEABLE))
1780	2097	return -EROFS;
1781		- if (!mtd->_writev)
	2098	+
	2099	+ if (!master->_writev)
1782	2100	return default_mtd_writev(mtd, vecs, count, to, retlen);
1783		- return mtd->_writev(mtd, vecs, count, to, retlen);
	2101	+
	2102	+ return master->_writev(master, vecs, count,
	2103	+ mtd_get_master_ofs(mtd, to), retlen);
1784	2104	}
1785	2105	EXPORT_SYMBOL_GPL(mtd_writev);
1786	2106
..	..	@@ -1862,11 +2182,12 @@
1862	2182	struct backing_dev_info *bdi;
1863	2183	int ret;
1864	2184
1865		- bdi = bdi_alloc(GFP_KERNEL);
	2185	+ bdi = bdi_alloc(NUMA_NO_NODE);
1866	2186	if (!bdi)
1867	2187	return ERR_PTR(-ENOMEM);
	2188	+ bdi->ra_pages = 0;
	2189	+ bdi->io_pages = 0;
1868	2190
1869		- bdi->name = name;
1870	2191	/*
1871	2192	* We put '-0' suffix to the name to get the same name format as we
1872	2193	* used to get. Since this is called only once, we get a unique name.