1/*
   2 * Core registration and callback routines for MTD
   3 * drivers and users.
   4 *
   5 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
   6 * 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 */
  23
  24#include <linux/module.h>
  25#include <linux/kernel.h>
  26#include <linux/ptrace.h>
  27#include <linux/seq_file.h>
  28#include <linux/string.h>
  29#include <linux/timer.h>
  30#include <linux/major.h>
  31#include <linux/fs.h>
  32#include <linux/err.h>
  33#include <linux/ioctl.h>
  34#include <linux/init.h>
  35#include <linux/of.h>
  36#include <linux/proc_fs.h>
  37#include <linux/idr.h>
  38#include <linux/backing-dev.h>
  39#include <linux/gfp.h>
  40#include <linux/slab.h>
  41#include <linux/reboot.h>
  42#include <linux/leds.h>
  43#include <linux/debugfs.h>
  44
  45#include <linux/mtd/mtd.h>
  46#include <linux/mtd/partitions.h>
  47
  48#include "mtdcore.h"
  49
  50struct backing_dev_info *mtd_bdi;
  51
  52#ifdef CONFIG_PM_SLEEP
  53
  54static int mtd_cls_suspend(struct device *dev)
  55{
  56	struct mtd_info *mtd = dev_get_drvdata(dev);
  57
  58	return mtd ? mtd_suspend(mtd) : 0;
  59}
  60
  61static int mtd_cls_resume(struct device *dev)
  62{
  63	struct mtd_info *mtd = dev_get_drvdata(dev);
 
 
 
 
 
 
  64
  65	if (mtd)
  66		mtd_resume(mtd);
  67	return 0;
  68}
 
 
 
 
 
 
  69
  70static SIMPLE_DEV_PM_OPS(mtd_cls_pm_ops, mtd_cls_suspend, mtd_cls_resume);
  71#define MTD_CLS_PM_OPS (&mtd_cls_pm_ops)
  72#else
  73#define MTD_CLS_PM_OPS NULL
  74#endif
  75
  76static struct class mtd_class = {
  77	.name = "mtd",
  78	.owner = THIS_MODULE,
  79	.pm = MTD_CLS_PM_OPS,
 
  80};
  81
  82static DEFINE_IDR(mtd_idr);
  83
  84/* These are exported solely for the purpose of mtd_blkdevs.c. You
  85   should not use them for _anything_ else */
  86DEFINE_MUTEX(mtd_table_mutex);
  87EXPORT_SYMBOL_GPL(mtd_table_mutex);
  88
  89struct mtd_info *__mtd_next_device(int i)
  90{
  91	return idr_get_next(&mtd_idr, &i);
  92}
  93EXPORT_SYMBOL_GPL(__mtd_next_device);
  94
  95static LIST_HEAD(mtd_notifiers);
  96
  97
  98#define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2)
  99
 100/* REVISIT once MTD uses the driver model better, whoever allocates
 101 * the mtd_info will probably want to use the release() hook...
 102 */
 103static void mtd_release(struct device *dev)
 104{
 105	struct mtd_info *mtd = dev_get_drvdata(dev);
 106	dev_t index = MTD_DEVT(mtd->index);
 107
 108	/* remove /dev/mtdXro node */
 109	device_destroy(&mtd_class, index + 1);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 110}
 111
 112static ssize_t mtd_type_show(struct device *dev,
 113		struct device_attribute *attr, char *buf)
 114{
 115	struct mtd_info *mtd = dev_get_drvdata(dev);
 116	char *type;
 117
 118	switch (mtd->type) {
 119	case MTD_ABSENT:
 120		type = "absent";
 121		break;
 122	case MTD_RAM:
 123		type = "ram";
 124		break;
 125	case MTD_ROM:
 126		type = "rom";
 127		break;
 128	case MTD_NORFLASH:
 129		type = "nor";
 130		break;
 131	case MTD_NANDFLASH:
 132		type = "nand";
 133		break;
 134	case MTD_DATAFLASH:
 135		type = "dataflash";
 136		break;
 137	case MTD_UBIVOLUME:
 138		type = "ubi";
 139		break;
 140	case MTD_MLCNANDFLASH:
 141		type = "mlc-nand";
 142		break;
 143	default:
 144		type = "unknown";
 145	}
 146
 147	return snprintf(buf, PAGE_SIZE, "%s\n", type);
 148}
 149static DEVICE_ATTR(type, S_IRUGO, mtd_type_show, NULL);
 150
 151static ssize_t mtd_flags_show(struct device *dev,
 152		struct device_attribute *attr, char *buf)
 153{
 154	struct mtd_info *mtd = dev_get_drvdata(dev);
 155
 156	return snprintf(buf, PAGE_SIZE, "0x%lx\n", (unsigned long)mtd->flags);
 157
 158}
 159static DEVICE_ATTR(flags, S_IRUGO, mtd_flags_show, NULL);
 160
 161static ssize_t mtd_size_show(struct device *dev,
 162		struct device_attribute *attr, char *buf)
 163{
 164	struct mtd_info *mtd = dev_get_drvdata(dev);
 165
 166	return snprintf(buf, PAGE_SIZE, "%llu\n",
 167		(unsigned long long)mtd->size);
 168
 169}
 170static DEVICE_ATTR(size, S_IRUGO, mtd_size_show, NULL);
 171
 172static ssize_t mtd_erasesize_show(struct device *dev,
 173		struct device_attribute *attr, char *buf)
 174{
 175	struct mtd_info *mtd = dev_get_drvdata(dev);
 176
 177	return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->erasesize);
 178
 179}
 180static DEVICE_ATTR(erasesize, S_IRUGO, mtd_erasesize_show, NULL);
 181
 182static ssize_t mtd_writesize_show(struct device *dev,
 183		struct device_attribute *attr, char *buf)
 184{
 185	struct mtd_info *mtd = dev_get_drvdata(dev);
 186
 187	return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->writesize);
 188
 189}
 190static DEVICE_ATTR(writesize, S_IRUGO, mtd_writesize_show, NULL);
 191
 192static ssize_t mtd_subpagesize_show(struct device *dev,
 193		struct device_attribute *attr, char *buf)
 194{
 195	struct mtd_info *mtd = dev_get_drvdata(dev);
 196	unsigned int subpagesize = mtd->writesize >> mtd->subpage_sft;
 197
 198	return snprintf(buf, PAGE_SIZE, "%u\n", subpagesize);
 199
 200}
 201static DEVICE_ATTR(subpagesize, S_IRUGO, mtd_subpagesize_show, NULL);
 202
 203static ssize_t mtd_oobsize_show(struct device *dev,
 204		struct device_attribute *attr, char *buf)
 205{
 206	struct mtd_info *mtd = dev_get_drvdata(dev);
 207
 208	return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->oobsize);
 209
 210}
 211static DEVICE_ATTR(oobsize, S_IRUGO, mtd_oobsize_show, NULL);
 212
 213static ssize_t mtd_numeraseregions_show(struct device *dev,
 214		struct device_attribute *attr, char *buf)
 215{
 216	struct mtd_info *mtd = dev_get_drvdata(dev);
 217
 218	return snprintf(buf, PAGE_SIZE, "%u\n", mtd->numeraseregions);
 219
 220}
 221static DEVICE_ATTR(numeraseregions, S_IRUGO, mtd_numeraseregions_show,
 222	NULL);
 223
 224static ssize_t mtd_name_show(struct device *dev,
 225		struct device_attribute *attr, char *buf)
 226{
 227	struct mtd_info *mtd = dev_get_drvdata(dev);
 228
 229	return snprintf(buf, PAGE_SIZE, "%s\n", mtd->name);
 230
 231}
 232static DEVICE_ATTR(name, S_IRUGO, mtd_name_show, NULL);
 233
 234static ssize_t mtd_ecc_strength_show(struct device *dev,
 235				     struct device_attribute *attr, char *buf)
 236{
 237	struct mtd_info *mtd = dev_get_drvdata(dev);
 238
 239	return snprintf(buf, PAGE_SIZE, "%u\n", mtd->ecc_strength);
 240}
 241static DEVICE_ATTR(ecc_strength, S_IRUGO, mtd_ecc_strength_show, NULL);
 242
 243static ssize_t mtd_bitflip_threshold_show(struct device *dev,
 244					  struct device_attribute *attr,
 245					  char *buf)
 246{
 247	struct mtd_info *mtd = dev_get_drvdata(dev);
 248
 249	return snprintf(buf, PAGE_SIZE, "%u\n", mtd->bitflip_threshold);
 250}
 251
 252static ssize_t mtd_bitflip_threshold_store(struct device *dev,
 253					   struct device_attribute *attr,
 254					   const char *buf, size_t count)
 255{
 256	struct mtd_info *mtd = dev_get_drvdata(dev);
 257	unsigned int bitflip_threshold;
 258	int retval;
 259
 260	retval = kstrtouint(buf, 0, &bitflip_threshold);
 261	if (retval)
 262		return retval;
 263
 264	mtd->bitflip_threshold = bitflip_threshold;
 265	return count;
 266}
 267static DEVICE_ATTR(bitflip_threshold, S_IRUGO | S_IWUSR,
 268		   mtd_bitflip_threshold_show,
 269		   mtd_bitflip_threshold_store);
 270
 271static ssize_t mtd_ecc_step_size_show(struct device *dev,
 272		struct device_attribute *attr, char *buf)
 273{
 274	struct mtd_info *mtd = dev_get_drvdata(dev);
 275
 276	return snprintf(buf, PAGE_SIZE, "%u\n", mtd->ecc_step_size);
 277
 278}
 279static DEVICE_ATTR(ecc_step_size, S_IRUGO, mtd_ecc_step_size_show, NULL);
 280
 281static ssize_t mtd_ecc_stats_corrected_show(struct device *dev,
 282		struct device_attribute *attr, char *buf)
 283{
 284	struct mtd_info *mtd = dev_get_drvdata(dev);
 285	struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
 286
 287	return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->corrected);
 288}
 289static DEVICE_ATTR(corrected_bits, S_IRUGO,
 290		   mtd_ecc_stats_corrected_show, NULL);
 291
 292static ssize_t mtd_ecc_stats_errors_show(struct device *dev,
 293		struct device_attribute *attr, char *buf)
 294{
 295	struct mtd_info *mtd = dev_get_drvdata(dev);
 296	struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
 297
 298	return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->failed);
 299}
 300static DEVICE_ATTR(ecc_failures, S_IRUGO, mtd_ecc_stats_errors_show, NULL);
 301
 302static ssize_t mtd_badblocks_show(struct device *dev,
 303		struct device_attribute *attr, char *buf)
 304{
 305	struct mtd_info *mtd = dev_get_drvdata(dev);
 306	struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
 307
 308	return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->badblocks);
 309}
 310static DEVICE_ATTR(bad_blocks, S_IRUGO, mtd_badblocks_show, NULL);
 311
 312static ssize_t mtd_bbtblocks_show(struct device *dev,
 313		struct device_attribute *attr, char *buf)
 314{
 315	struct mtd_info *mtd = dev_get_drvdata(dev);
 316	struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
 317
 318	return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->bbtblocks);
 319}
 320static DEVICE_ATTR(bbt_blocks, S_IRUGO, mtd_bbtblocks_show, NULL);
 321
 322static struct attribute *mtd_attrs[] = {
 323	&dev_attr_type.attr,
 324	&dev_attr_flags.attr,
 325	&dev_attr_size.attr,
 326	&dev_attr_erasesize.attr,
 327	&dev_attr_writesize.attr,
 328	&dev_attr_subpagesize.attr,
 329	&dev_attr_oobsize.attr,
 330	&dev_attr_numeraseregions.attr,
 331	&dev_attr_name.attr,
 332	&dev_attr_ecc_strength.attr,
 333	&dev_attr_ecc_step_size.attr,
 334	&dev_attr_corrected_bits.attr,
 335	&dev_attr_ecc_failures.attr,
 336	&dev_attr_bad_blocks.attr,
 337	&dev_attr_bbt_blocks.attr,
 338	&dev_attr_bitflip_threshold.attr,
 339	NULL,
 340};
 341ATTRIBUTE_GROUPS(mtd);
 342
 343static const struct device_type mtd_devtype = {
 344	.name		= "mtd",
 345	.groups		= mtd_groups,
 346	.release	= mtd_release,
 347};
 348
 349#ifndef CONFIG_MMU
 350unsigned mtd_mmap_capabilities(struct mtd_info *mtd)
 351{
 352	switch (mtd->type) {
 353	case MTD_RAM:
 354		return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | NOMMU_MAP_EXEC |
 355			NOMMU_MAP_READ | NOMMU_MAP_WRITE;
 356	case MTD_ROM:
 357		return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | NOMMU_MAP_EXEC |
 358			NOMMU_MAP_READ;
 359	default:
 360		return NOMMU_MAP_COPY;
 361	}
 362}
 363EXPORT_SYMBOL_GPL(mtd_mmap_capabilities);
 364#endif
 365
 366static int mtd_reboot_notifier(struct notifier_block *n, unsigned long state,
 367			       void *cmd)
 368{
 369	struct mtd_info *mtd;
 370
 371	mtd = container_of(n, struct mtd_info, reboot_notifier);
 372	mtd->_reboot(mtd);
 373
 374	return NOTIFY_DONE;
 375}
 376
 377/**
 378 * mtd_wunit_to_pairing_info - get pairing information of a wunit
 379 * @mtd: pointer to new MTD device info structure
 380 * @wunit: write unit we are interested in
 381 * @info: returned pairing information
 382 *
 383 * Retrieve pairing information associated to the wunit.
 384 * This is mainly useful when dealing with MLC/TLC NANDs where pages can be
 385 * paired together, and where programming a page may influence the page it is
 386 * paired with.
 387 * The notion of page is replaced by the term wunit (write-unit) to stay
 388 * consistent with the ->writesize field.
 389 *
 390 * The @wunit argument can be extracted from an absolute offset using
 391 * mtd_offset_to_wunit(). @info is filled with the pairing information attached
 392 * to @wunit.
 393 *
 394 * From the pairing info the MTD user can find all the wunits paired with
 395 * @wunit using the following loop:
 396 *
 397 * for (i = 0; i < mtd_pairing_groups(mtd); i++) {
 398 *	info.pair = i;
 399 *	mtd_pairing_info_to_wunit(mtd, &info);
 400 *	...
 401 * }
 402 */
 403int mtd_wunit_to_pairing_info(struct mtd_info *mtd, int wunit,
 404			      struct mtd_pairing_info *info)
 405{
 406	int npairs = mtd_wunit_per_eb(mtd) / mtd_pairing_groups(mtd);
 407
 408	if (wunit < 0 || wunit >= npairs)
 409		return -EINVAL;
 410
 411	if (mtd->pairing && mtd->pairing->get_info)
 412		return mtd->pairing->get_info(mtd, wunit, info);
 413
 414	info->group = 0;
 415	info->pair = wunit;
 416
 417	return 0;
 418}
 419EXPORT_SYMBOL_GPL(mtd_wunit_to_pairing_info);
 420
 421/**
 422 * mtd_pairing_info_to_wunit - get wunit from pairing information
 423 * @mtd: pointer to new MTD device info structure
 424 * @info: pairing information struct
 425 *
 426 * Returns a positive number representing the wunit associated to the info
 427 * struct, or a negative error code.
 428 *
 429 * This is the reverse of mtd_wunit_to_pairing_info(), and can help one to
 430 * iterate over all wunits of a given pair (see mtd_wunit_to_pairing_info()
 431 * doc).
 432 *
 433 * It can also be used to only program the first page of each pair (i.e.
 434 * page attached to group 0), which allows one to use an MLC NAND in
 435 * software-emulated SLC mode:
 436 *
 437 * info.group = 0;
 438 * npairs = mtd_wunit_per_eb(mtd) / mtd_pairing_groups(mtd);
 439 * for (info.pair = 0; info.pair < npairs; info.pair++) {
 440 *	wunit = mtd_pairing_info_to_wunit(mtd, &info);
 441 *	mtd_write(mtd, mtd_wunit_to_offset(mtd, blkoffs, wunit),
 442 *		  mtd->writesize, &retlen, buf + (i * mtd->writesize));
 443 * }
 444 */
 445int mtd_pairing_info_to_wunit(struct mtd_info *mtd,
 446			      const struct mtd_pairing_info *info)
 447{
 448	int ngroups = mtd_pairing_groups(mtd);
 449	int npairs = mtd_wunit_per_eb(mtd) / ngroups;
 450
 451	if (!info || info->pair < 0 || info->pair >= npairs ||
 452	    info->group < 0 || info->group >= ngroups)
 453		return -EINVAL;
 454
 455	if (mtd->pairing && mtd->pairing->get_wunit)
 456		return mtd->pairing->get_wunit(mtd, info);
 457
 458	return info->pair;
 459}
 460EXPORT_SYMBOL_GPL(mtd_pairing_info_to_wunit);
 461
 462/**
 463 * mtd_pairing_groups - get the number of pairing groups
 464 * @mtd: pointer to new MTD device info structure
 465 *
 466 * Returns the number of pairing groups.
 467 *
 468 * This number is usually equal to the number of bits exposed by a single
 469 * cell, and can be used in conjunction with mtd_pairing_info_to_wunit()
 470 * to iterate over all pages of a given pair.
 471 */
 472int mtd_pairing_groups(struct mtd_info *mtd)
 473{
 474	if (!mtd->pairing || !mtd->pairing->ngroups)
 475		return 1;
 476
 477	return mtd->pairing->ngroups;
 478}
 479EXPORT_SYMBOL_GPL(mtd_pairing_groups);
 480
 481static struct dentry *dfs_dir_mtd;
 482
 483/**
 484 *	add_mtd_device - register an MTD device
 485 *	@mtd: pointer to new MTD device info structure
 486 *
 487 *	Add a device to the list of MTD devices present in the system, and
 488 *	notify each currently active MTD 'user' of its arrival. Returns
 489 *	zero on success or non-zero on failure.
 
 490 */
 491
 492int add_mtd_device(struct mtd_info *mtd)
 493{
 494	struct mtd_notifier *not;
 495	int i, error;
 496
 497	/*
 498	 * May occur, for instance, on buggy drivers which call
 499	 * mtd_device_parse_register() multiple times on the same master MTD,
 500	 * especially with CONFIG_MTD_PARTITIONED_MASTER=y.
 501	 */
 502	if (WARN_ONCE(mtd->dev.type, "MTD already registered\n"))
 503		return -EEXIST;
 
 
 
 
 
 
 504
 505	BUG_ON(mtd->writesize == 0);
 506
 507	if (WARN_ON((!mtd->erasesize || !mtd->_erase) &&
 508		    !(mtd->flags & MTD_NO_ERASE)))
 509		return -EINVAL;
 510
 511	mutex_lock(&mtd_table_mutex);
 512
 513	i = idr_alloc(&mtd_idr, mtd, 0, 0, GFP_KERNEL);
 514	if (i < 0) {
 515		error = i;
 516		goto fail_locked;
 517	}
 518
 519	mtd->index = i;
 520	mtd->usecount = 0;
 521
 522	/* default value if not set by driver */
 523	if (mtd->bitflip_threshold == 0)
 524		mtd->bitflip_threshold = mtd->ecc_strength;
 525
 526	if (is_power_of_2(mtd->erasesize))
 527		mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
 528	else
 529		mtd->erasesize_shift = 0;
 530
 531	if (is_power_of_2(mtd->writesize))
 532		mtd->writesize_shift = ffs(mtd->writesize) - 1;
 533	else
 534		mtd->writesize_shift = 0;
 535
 536	mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1;
 537	mtd->writesize_mask = (1 << mtd->writesize_shift) - 1;
 538
 539	/* Some chips always power up locked. Unlock them now */
 540	if ((mtd->flags & MTD_WRITEABLE) && (mtd->flags & MTD_POWERUP_LOCK)) {
 541		error = mtd_unlock(mtd, 0, mtd->size);
 542		if (error && error != -EOPNOTSUPP)
 543			printk(KERN_WARNING
 544			       "%s: unlock failed, writes may not work\n",
 545			       mtd->name);
 546		/* Ignore unlock failures? */
 547		error = 0;
 548	}
 549
 550	/* Caller should have set dev.parent to match the
 551	 * physical device, if appropriate.
 552	 */
 553	mtd->dev.type = &mtd_devtype;
 554	mtd->dev.class = &mtd_class;
 555	mtd->dev.devt = MTD_DEVT(i);
 556	dev_set_name(&mtd->dev, "mtd%d", i);
 557	dev_set_drvdata(&mtd->dev, mtd);
 558	of_node_get(mtd_get_of_node(mtd));
 559	error = device_register(&mtd->dev);
 560	if (error)
 561		goto fail_added;
 562
 563	if (!IS_ERR_OR_NULL(dfs_dir_mtd)) {
 564		mtd->dbg.dfs_dir = debugfs_create_dir(dev_name(&mtd->dev), dfs_dir_mtd);
 565		if (IS_ERR_OR_NULL(mtd->dbg.dfs_dir)) {
 566			pr_debug("mtd device %s won't show data in debugfs\n",
 567				 dev_name(&mtd->dev));
 568		}
 569	}
 570
 571	device_create(&mtd_class, mtd->dev.parent, MTD_DEVT(i) + 1, NULL,
 572		      "mtd%dro", i);
 573
 574	pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name);
 575	/* No need to get a refcount on the module containing
 576	   the notifier, since we hold the mtd_table_mutex */
 577	list_for_each_entry(not, &mtd_notifiers, list)
 578		not->add(mtd);
 579
 580	mutex_unlock(&mtd_table_mutex);
 581	/* We _know_ we aren't being removed, because
 582	   our caller is still holding us here. So none
 583	   of this try_ nonsense, and no bitching about it
 584	   either. :) */
 585	__module_get(THIS_MODULE);
 586	return 0;
 587
 588fail_added:
 589	of_node_put(mtd_get_of_node(mtd));
 590	idr_remove(&mtd_idr, i);
 591fail_locked:
 592	mutex_unlock(&mtd_table_mutex);
 593	return error;
 594}
 595
 596/**
 597 *	del_mtd_device - unregister an MTD device
 598 *	@mtd: pointer to MTD device info structure
 599 *
 600 *	Remove a device from the list of MTD devices present in the system,
 601 *	and notify each currently active MTD 'user' of its departure.
 602 *	Returns zero on success or 1 on failure, which currently will happen
 603 *	if the requested device does not appear to be present in the list.
 604 */
 605
 606int del_mtd_device(struct mtd_info *mtd)
 607{
 608	int ret;
 609	struct mtd_notifier *not;
 610
 611	mutex_lock(&mtd_table_mutex);
 612
 613	debugfs_remove_recursive(mtd->dbg.dfs_dir);
 614
 615	if (idr_find(&mtd_idr, mtd->index) != mtd) {
 616		ret = -ENODEV;
 617		goto out_error;
 618	}
 619
 620	/* No need to get a refcount on the module containing
 621		the notifier, since we hold the mtd_table_mutex */
 622	list_for_each_entry(not, &mtd_notifiers, list)
 623		not->remove(mtd);
 624
 625	if (mtd->usecount) {
 626		printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n",
 627		       mtd->index, mtd->name, mtd->usecount);
 628		ret = -EBUSY;
 629	} else {
 630		device_unregister(&mtd->dev);
 631
 632		idr_remove(&mtd_idr, mtd->index);
 633		of_node_put(mtd_get_of_node(mtd));
 634
 635		module_put(THIS_MODULE);
 636		ret = 0;
 637	}
 638
 639out_error:
 640	mutex_unlock(&mtd_table_mutex);
 641	return ret;
 642}
 643
 644/*
 645 * Set a few defaults based on the parent devices, if not provided by the
 646 * driver
 647 */
 648static void mtd_set_dev_defaults(struct mtd_info *mtd)
 649{
 650	if (mtd->dev.parent) {
 651		if (!mtd->owner && mtd->dev.parent->driver)
 652			mtd->owner = mtd->dev.parent->driver->owner;
 653		if (!mtd->name)
 654			mtd->name = dev_name(mtd->dev.parent);
 655	} else {
 656		pr_debug("mtd device won't show a device symlink in sysfs\n");
 657	}
 658}
 659
 660/**
 661 * mtd_device_parse_register - parse partitions and register an MTD device.
 662 *
 663 * @mtd: the MTD device to register
 664 * @types: the list of MTD partition probes to try, see
 665 *         'parse_mtd_partitions()' for more information
 666 * @parser_data: MTD partition parser-specific data
 667 * @parts: fallback partition information to register, if parsing fails;
 668 *         only valid if %nr_parts > %0
 669 * @nr_parts: the number of partitions in parts, if zero then the full
 670 *            MTD device is registered if no partition info is found
 671 *
 672 * This function aggregates MTD partitions parsing (done by
 673 * 'parse_mtd_partitions()') and MTD device and partitions registering. It
 674 * basically follows the most common pattern found in many MTD drivers:
 675 *
 676 * * If the MTD_PARTITIONED_MASTER option is set, then the device as a whole is
 677 *   registered first.
 678 * * Then It tries to probe partitions on MTD device @mtd using parsers
 679 *   specified in @types (if @types is %NULL, then the default list of parsers
 680 *   is used, see 'parse_mtd_partitions()' for more information). If none are
 681 *   found this functions tries to fallback to information specified in
 682 *   @parts/@nr_parts.
 
 
 683 * * If no partitions were found this function just registers the MTD device
 684 *   @mtd and exits.
 685 *
 686 * Returns zero in case of success and a negative error code in case of failure.
 687 */
 688int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types,
 689			      struct mtd_part_parser_data *parser_data,
 690			      const struct mtd_partition *parts,
 691			      int nr_parts)
 692{
 693	struct mtd_partitions parsed = { };
 694	int ret;
 695
 696	mtd_set_dev_defaults(mtd);
 697
 698	if (IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER)) {
 699		ret = add_mtd_device(mtd);
 700		if (ret)
 701			return ret;
 702	}
 703
 704	/* Prefer parsed partitions over driver-provided fallback */
 705	ret = parse_mtd_partitions(mtd, types, &parsed, parser_data);
 706	if (!ret && parsed.nr_parts) {
 707		parts = parsed.parts;
 708		nr_parts = parsed.nr_parts;
 709	}
 710
 711	if (nr_parts)
 712		ret = add_mtd_partitions(mtd, parts, nr_parts);
 713	else if (!device_is_registered(&mtd->dev))
 714		ret = add_mtd_device(mtd);
 715	else
 716		ret = 0;
 717
 718	if (ret)
 719		goto out;
 720
 721	/*
 722	 * FIXME: some drivers unfortunately call this function more than once.
 723	 * So we have to check if we've already assigned the reboot notifier.
 724	 *
 725	 * Generally, we can make multiple calls work for most cases, but it
 726	 * does cause problems with parse_mtd_partitions() above (e.g.,
 727	 * cmdlineparts will register partitions more than once).
 728	 */
 729	WARN_ONCE(mtd->_reboot && mtd->reboot_notifier.notifier_call,
 730		  "MTD already registered\n");
 731	if (mtd->_reboot && !mtd->reboot_notifier.notifier_call) {
 732		mtd->reboot_notifier.notifier_call = mtd_reboot_notifier;
 733		register_reboot_notifier(&mtd->reboot_notifier);
 
 
 
 
 734	}
 735
 736out:
 737	/* Cleanup any parsed partitions */
 738	mtd_part_parser_cleanup(&parsed);
 739	if (ret && device_is_registered(&mtd->dev))
 740		del_mtd_device(mtd);
 741
 742	return ret;
 743}
 744EXPORT_SYMBOL_GPL(mtd_device_parse_register);
 745
 746/**
 747 * mtd_device_unregister - unregister an existing MTD device.
 748 *
 749 * @master: the MTD device to unregister.  This will unregister both the master
 750 *          and any partitions if registered.
 751 */
 752int mtd_device_unregister(struct mtd_info *master)
 753{
 754	int err;
 755
 756	if (master->_reboot)
 757		unregister_reboot_notifier(&master->reboot_notifier);
 758
 759	err = del_mtd_partitions(master);
 760	if (err)
 761		return err;
 762
 763	if (!device_is_registered(&master->dev))
 764		return 0;
 765
 766	return del_mtd_device(master);
 767}
 768EXPORT_SYMBOL_GPL(mtd_device_unregister);
 769
 770/**
 771 *	register_mtd_user - register a 'user' of MTD devices.
 772 *	@new: pointer to notifier info structure
 773 *
 774 *	Registers a pair of callbacks function to be called upon addition
 775 *	or removal of MTD devices. Causes the 'add' callback to be immediately
 776 *	invoked for each MTD device currently present in the system.
 777 */
 778void register_mtd_user (struct mtd_notifier *new)
 779{
 780	struct mtd_info *mtd;
 781
 782	mutex_lock(&mtd_table_mutex);
 783
 784	list_add(&new->list, &mtd_notifiers);
 785
 786	__module_get(THIS_MODULE);
 787
 788	mtd_for_each_device(mtd)
 789		new->add(mtd);
 790
 791	mutex_unlock(&mtd_table_mutex);
 792}
 793EXPORT_SYMBOL_GPL(register_mtd_user);
 794
 795/**
 796 *	unregister_mtd_user - unregister a 'user' of MTD devices.
 797 *	@old: pointer to notifier info structure
 798 *
 799 *	Removes a callback function pair from the list of 'users' to be
 800 *	notified upon addition or removal of MTD devices. Causes the
 801 *	'remove' callback to be immediately invoked for each MTD device
 802 *	currently present in the system.
 803 */
 804int unregister_mtd_user (struct mtd_notifier *old)
 805{
 806	struct mtd_info *mtd;
 807
 808	mutex_lock(&mtd_table_mutex);
 809
 810	module_put(THIS_MODULE);
 811
 812	mtd_for_each_device(mtd)
 813		old->remove(mtd);
 814
 815	list_del(&old->list);
 816	mutex_unlock(&mtd_table_mutex);
 817	return 0;
 818}
 819EXPORT_SYMBOL_GPL(unregister_mtd_user);
 820
 821/**
 822 *	get_mtd_device - obtain a validated handle for an MTD device
 823 *	@mtd: last known address of the required MTD device
 824 *	@num: internal device number of the required MTD device
 825 *
 826 *	Given a number and NULL address, return the num'th entry in the device
 827 *	table, if any.	Given an address and num == -1, search the device table
 828 *	for a device with that address and return if it's still present. Given
 829 *	both, return the num'th driver only if its address matches. Return
 830 *	error code if not.
 831 */
 832struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num)
 833{
 834	struct mtd_info *ret = NULL, *other;
 835	int err = -ENODEV;
 836
 837	mutex_lock(&mtd_table_mutex);
 838
 839	if (num == -1) {
 840		mtd_for_each_device(other) {
 841			if (other == mtd) {
 842				ret = mtd;
 843				break;
 844			}
 845		}
 846	} else if (num >= 0) {
 847		ret = idr_find(&mtd_idr, num);
 848		if (mtd && mtd != ret)
 849			ret = NULL;
 850	}
 851
 852	if (!ret) {
 853		ret = ERR_PTR(err);
 854		goto out;
 855	}
 856
 857	err = __get_mtd_device(ret);
 858	if (err)
 859		ret = ERR_PTR(err);
 860out:
 861	mutex_unlock(&mtd_table_mutex);
 862	return ret;
 863}
 864EXPORT_SYMBOL_GPL(get_mtd_device);
 865
 866
 867int __get_mtd_device(struct mtd_info *mtd)
 868{
 869	int err;
 870
 871	if (!try_module_get(mtd->owner))
 872		return -ENODEV;
 873
 874	if (mtd->_get_device) {
 875		err = mtd->_get_device(mtd);
 876
 877		if (err) {
 878			module_put(mtd->owner);
 879			return err;
 880		}
 881	}
 882	mtd->usecount++;
 883	return 0;
 884}
 885EXPORT_SYMBOL_GPL(__get_mtd_device);
 886
 887/**
 888 *	get_mtd_device_nm - obtain a validated handle for an MTD device by
 889 *	device name
 890 *	@name: MTD device name to open
 891 *
 892 * 	This function returns MTD device description structure in case of
 893 * 	success and an error code in case of failure.
 894 */
 895struct mtd_info *get_mtd_device_nm(const char *name)
 896{
 897	int err = -ENODEV;
 898	struct mtd_info *mtd = NULL, *other;
 899
 900	mutex_lock(&mtd_table_mutex);
 901
 902	mtd_for_each_device(other) {
 903		if (!strcmp(name, other->name)) {
 904			mtd = other;
 905			break;
 906		}
 907	}
 908
 909	if (!mtd)
 910		goto out_unlock;
 911
 912	err = __get_mtd_device(mtd);
 913	if (err)
 914		goto out_unlock;
 915
 916	mutex_unlock(&mtd_table_mutex);
 917	return mtd;
 918
 919out_unlock:
 920	mutex_unlock(&mtd_table_mutex);
 921	return ERR_PTR(err);
 922}
 923EXPORT_SYMBOL_GPL(get_mtd_device_nm);
 924
 925void put_mtd_device(struct mtd_info *mtd)
 926{
 927	mutex_lock(&mtd_table_mutex);
 928	__put_mtd_device(mtd);
 929	mutex_unlock(&mtd_table_mutex);
 930
 931}
 932EXPORT_SYMBOL_GPL(put_mtd_device);
 933
 934void __put_mtd_device(struct mtd_info *mtd)
 935{
 936	--mtd->usecount;
 937	BUG_ON(mtd->usecount < 0);
 938
 939	if (mtd->_put_device)
 940		mtd->_put_device(mtd);
 941
 942	module_put(mtd->owner);
 943}
 944EXPORT_SYMBOL_GPL(__put_mtd_device);
 945
 946/*
 947 * Erase is an synchronous operation. Device drivers are epected to return a
 948 * negative error code if the operation failed and update instr->fail_addr
 949 * to point the portion that was not properly erased.
 
 
 950 */
 951int mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
 952{
 953	instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
 954
 955	if (!mtd->erasesize || !mtd->_erase)
 956		return -ENOTSUPP;
 957
 958	if (instr->addr >= mtd->size || instr->len > mtd->size - instr->addr)
 959		return -EINVAL;
 960	if (!(mtd->flags & MTD_WRITEABLE))
 961		return -EROFS;
 962
 963	if (!instr->len)
 
 
 964		return 0;
 965
 966	ledtrig_mtd_activity();
 967	return mtd->_erase(mtd, instr);
 968}
 969EXPORT_SYMBOL_GPL(mtd_erase);
 970
 971/*
 972 * This stuff for eXecute-In-Place. phys is optional and may be set to NULL.
 973 */
 974int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
 975	      void **virt, resource_size_t *phys)
 976{
 977	*retlen = 0;
 978	*virt = NULL;
 979	if (phys)
 980		*phys = 0;
 981	if (!mtd->_point)
 982		return -EOPNOTSUPP;
 983	if (from < 0 || from >= mtd->size || len > mtd->size - from)
 984		return -EINVAL;
 985	if (!len)
 986		return 0;
 987	return mtd->_point(mtd, from, len, retlen, virt, phys);
 988}
 989EXPORT_SYMBOL_GPL(mtd_point);
 990
 991/* We probably shouldn't allow XIP if the unpoint isn't a NULL */
 992int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
 993{
 994	if (!mtd->_unpoint)
 995		return -EOPNOTSUPP;
 996	if (from < 0 || from >= mtd->size || len > mtd->size - from)
 997		return -EINVAL;
 998	if (!len)
 999		return 0;
1000	return mtd->_unpoint(mtd, from, len);
1001}
1002EXPORT_SYMBOL_GPL(mtd_unpoint);
1003
1004/*
1005 * Allow NOMMU mmap() to directly map the device (if not NULL)
1006 * - return the address to which the offset maps
1007 * - return -ENOSYS to indicate refusal to do the mapping
1008 */
1009unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len,
1010				    unsigned long offset, unsigned long flags)
1011{
1012	size_t retlen;
1013	void *virt;
1014	int ret;
1015
1016	ret = mtd_point(mtd, offset, len, &retlen, &virt, NULL);
1017	if (ret)
1018		return ret;
1019	if (retlen != len) {
1020		mtd_unpoint(mtd, offset, retlen);
1021		return -ENOSYS;
1022	}
1023	return (unsigned long)virt;
1024}
1025EXPORT_SYMBOL_GPL(mtd_get_unmapped_area);
1026
1027int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
1028	     u_char *buf)
1029{
1030	int ret_code;
1031	*retlen = 0;
1032	if (from < 0 || from >= mtd->size || len > mtd->size - from)
1033		return -EINVAL;
1034	if (!len)
1035		return 0;
1036
1037	ledtrig_mtd_activity();
1038	/*
1039	 * In the absence of an error, drivers return a non-negative integer
1040	 * representing the maximum number of bitflips that were corrected on
1041	 * any one ecc region (if applicable; zero otherwise).
1042	 */
1043	if (mtd->_read) {
1044		ret_code = mtd->_read(mtd, from, len, retlen, buf);
1045	} else if (mtd->_read_oob) {
1046		struct mtd_oob_ops ops = {
1047			.len = len,
1048			.datbuf = buf,
1049		};
1050
1051		ret_code = mtd->_read_oob(mtd, from, &ops);
1052		*retlen = ops.retlen;
1053	} else {
1054		return -ENOTSUPP;
1055	}
1056
1057	if (unlikely(ret_code < 0))
1058		return ret_code;
1059	if (mtd->ecc_strength == 0)
1060		return 0;	/* device lacks ecc */
1061	return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0;
1062}
1063EXPORT_SYMBOL_GPL(mtd_read);
1064
1065int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1066	      const u_char *buf)
1067{
1068	*retlen = 0;
1069	if (to < 0 || to >= mtd->size || len > mtd->size - to)
1070		return -EINVAL;
1071	if ((!mtd->_write && !mtd->_write_oob) ||
1072	    !(mtd->flags & MTD_WRITEABLE))
1073		return -EROFS;
1074	if (!len)
1075		return 0;
1076	ledtrig_mtd_activity();
1077
1078	if (!mtd->_write) {
1079		struct mtd_oob_ops ops = {
1080			.len = len,
1081			.datbuf = (u8 *)buf,
1082		};
1083		int ret;
1084
1085		ret = mtd->_write_oob(mtd, to, &ops);
1086		*retlen = ops.retlen;
1087		return ret;
1088	}
1089
1090	return mtd->_write(mtd, to, len, retlen, buf);
1091}
1092EXPORT_SYMBOL_GPL(mtd_write);
1093
1094/*
1095 * In blackbox flight recorder like scenarios we want to make successful writes
1096 * in interrupt context. panic_write() is only intended to be called when its
1097 * known the kernel is about to panic and we need the write to succeed. Since
1098 * the kernel is not going to be running for much longer, this function can
1099 * break locks and delay to ensure the write succeeds (but not sleep).
1100 */
1101int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1102		    const u_char *buf)
1103{
1104	*retlen = 0;
1105	if (!mtd->_panic_write)
1106		return -EOPNOTSUPP;
1107	if (to < 0 || to >= mtd->size || len > mtd->size - to)
1108		return -EINVAL;
1109	if (!(mtd->flags & MTD_WRITEABLE))
1110		return -EROFS;
1111	if (!len)
1112		return 0;
1113	return mtd->_panic_write(mtd, to, len, retlen, buf);
1114}
1115EXPORT_SYMBOL_GPL(mtd_panic_write);
1116
1117static int mtd_check_oob_ops(struct mtd_info *mtd, loff_t offs,
1118			     struct mtd_oob_ops *ops)
1119{
1120	/*
1121	 * Some users are setting ->datbuf or ->oobbuf to NULL, but are leaving
1122	 * ->len or ->ooblen uninitialized. Force ->len and ->ooblen to 0 in
1123	 *  this case.
1124	 */
1125	if (!ops->datbuf)
1126		ops->len = 0;
1127
1128	if (!ops->oobbuf)
1129		ops->ooblen = 0;
1130
1131	if (offs < 0 || offs + ops->len > mtd->size)
1132		return -EINVAL;
1133
1134	if (ops->ooblen) {
1135		u64 maxooblen;
1136
1137		if (ops->ooboffs >= mtd_oobavail(mtd, ops))
1138			return -EINVAL;
1139
1140		maxooblen = ((mtd_div_by_ws(mtd->size, mtd) -
1141			      mtd_div_by_ws(offs, mtd)) *
1142			     mtd_oobavail(mtd, ops)) - ops->ooboffs;
1143		if (ops->ooblen > maxooblen)
1144			return -EINVAL;
1145	}
1146
1147	return 0;
1148}
1149
1150int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
1151{
1152	int ret_code;
1153	ops->retlen = ops->oobretlen = 0;
1154	if (!mtd->_read_oob)
1155		return -EOPNOTSUPP;
1156
1157	ret_code = mtd_check_oob_ops(mtd, from, ops);
1158	if (ret_code)
1159		return ret_code;
1160
1161	ledtrig_mtd_activity();
1162	/*
1163	 * In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics
1164	 * similar to mtd->_read(), returning a non-negative integer
1165	 * representing max bitflips. In other cases, mtd->_read_oob() may
1166	 * return -EUCLEAN. In all cases, perform similar logic to mtd_read().
1167	 */
1168	ret_code = mtd->_read_oob(mtd, from, ops);
1169	if (unlikely(ret_code < 0))
1170		return ret_code;
1171	if (mtd->ecc_strength == 0)
1172		return 0;	/* device lacks ecc */
1173	return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0;
1174}
1175EXPORT_SYMBOL_GPL(mtd_read_oob);
1176
1177int mtd_write_oob(struct mtd_info *mtd, loff_t to,
1178				struct mtd_oob_ops *ops)
1179{
1180	int ret;
1181
1182	ops->retlen = ops->oobretlen = 0;
1183	if (!mtd->_write_oob)
1184		return -EOPNOTSUPP;
1185	if (!(mtd->flags & MTD_WRITEABLE))
1186		return -EROFS;
1187
1188	ret = mtd_check_oob_ops(mtd, to, ops);
1189	if (ret)
1190		return ret;
1191
1192	ledtrig_mtd_activity();
1193	return mtd->_write_oob(mtd, to, ops);
1194}
1195EXPORT_SYMBOL_GPL(mtd_write_oob);
1196
1197/**
1198 * mtd_ooblayout_ecc - Get the OOB region definition of a specific ECC section
1199 * @mtd: MTD device structure
1200 * @section: ECC section. Depending on the layout you may have all the ECC
1201 *	     bytes stored in a single contiguous section, or one section
1202 *	     per ECC chunk (and sometime several sections for a single ECC
1203 *	     ECC chunk)
1204 * @oobecc: OOB region struct filled with the appropriate ECC position
1205 *	    information
1206 *
1207 * This function returns ECC section information in the OOB area. If you want
1208 * to get all the ECC bytes information, then you should call
1209 * mtd_ooblayout_ecc(mtd, section++, oobecc) until it returns -ERANGE.
1210 *
1211 * Returns zero on success, a negative error code otherwise.
1212 */
1213int mtd_ooblayout_ecc(struct mtd_info *mtd, int section,
1214		      struct mtd_oob_region *oobecc)
1215{
1216	memset(oobecc, 0, sizeof(*oobecc));
1217
1218	if (!mtd || section < 0)
1219		return -EINVAL;
1220
1221	if (!mtd->ooblayout || !mtd->ooblayout->ecc)
1222		return -ENOTSUPP;
1223
1224	return mtd->ooblayout->ecc(mtd, section, oobecc);
1225}
1226EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc);
1227
1228/**
1229 * mtd_ooblayout_free - Get the OOB region definition of a specific free
1230 *			section
1231 * @mtd: MTD device structure
1232 * @section: Free section you are interested in. Depending on the layout
1233 *	     you may have all the free bytes stored in a single contiguous
1234 *	     section, or one section per ECC chunk plus an extra section
1235 *	     for the remaining bytes (or other funky layout).
1236 * @oobfree: OOB region struct filled with the appropriate free position
1237 *	     information
1238 *
1239 * This function returns free bytes position in the OOB area. If you want
1240 * to get all the free bytes information, then you should call
1241 * mtd_ooblayout_free(mtd, section++, oobfree) until it returns -ERANGE.
1242 *
1243 * Returns zero on success, a negative error code otherwise.
1244 */
1245int mtd_ooblayout_free(struct mtd_info *mtd, int section,
1246		       struct mtd_oob_region *oobfree)
1247{
1248	memset(oobfree, 0, sizeof(*oobfree));
1249
1250	if (!mtd || section < 0)
1251		return -EINVAL;
1252
1253	if (!mtd->ooblayout || !mtd->ooblayout->free)
1254		return -ENOTSUPP;
1255
1256	return mtd->ooblayout->free(mtd, section, oobfree);
1257}
1258EXPORT_SYMBOL_GPL(mtd_ooblayout_free);
1259
1260/**
1261 * mtd_ooblayout_find_region - Find the region attached to a specific byte
1262 * @mtd: mtd info structure
1263 * @byte: the byte we are searching for
1264 * @sectionp: pointer where the section id will be stored
1265 * @oobregion: used to retrieve the ECC position
1266 * @iter: iterator function. Should be either mtd_ooblayout_free or
1267 *	  mtd_ooblayout_ecc depending on the region type you're searching for
1268 *
1269 * This function returns the section id and oobregion information of a
1270 * specific byte. For example, say you want to know where the 4th ECC byte is
1271 * stored, you'll use:
1272 *
1273 * mtd_ooblayout_find_region(mtd, 3, &section, &oobregion, mtd_ooblayout_ecc);
1274 *
1275 * Returns zero on success, a negative error code otherwise.
1276 */
1277static int mtd_ooblayout_find_region(struct mtd_info *mtd, int byte,
1278				int *sectionp, struct mtd_oob_region *oobregion,
1279				int (*iter)(struct mtd_info *,
1280					    int section,
1281					    struct mtd_oob_region *oobregion))
1282{
1283	int pos = 0, ret, section = 0;
1284
1285	memset(oobregion, 0, sizeof(*oobregion));
1286
1287	while (1) {
1288		ret = iter(mtd, section, oobregion);
1289		if (ret)
1290			return ret;
1291
1292		if (pos + oobregion->length > byte)
1293			break;
1294
1295		pos += oobregion->length;
1296		section++;
1297	}
1298
1299	/*
1300	 * Adjust region info to make it start at the beginning at the
1301	 * 'start' ECC byte.
1302	 */
1303	oobregion->offset += byte - pos;
1304	oobregion->length -= byte - pos;
1305	*sectionp = section;
1306
1307	return 0;
1308}
1309
1310/**
1311 * mtd_ooblayout_find_eccregion - Find the ECC region attached to a specific
1312 *				  ECC byte
1313 * @mtd: mtd info structure
1314 * @eccbyte: the byte we are searching for
1315 * @sectionp: pointer where the section id will be stored
1316 * @oobregion: OOB region information
1317 *
1318 * Works like mtd_ooblayout_find_region() except it searches for a specific ECC
1319 * byte.
1320 *
1321 * Returns zero on success, a negative error code otherwise.
1322 */
1323int mtd_ooblayout_find_eccregion(struct mtd_info *mtd, int eccbyte,
1324				 int *section,
1325				 struct mtd_oob_region *oobregion)
1326{
1327	return mtd_ooblayout_find_region(mtd, eccbyte, section, oobregion,
1328					 mtd_ooblayout_ecc);
1329}
1330EXPORT_SYMBOL_GPL(mtd_ooblayout_find_eccregion);
1331
1332/**
1333 * mtd_ooblayout_get_bytes - Extract OOB bytes from the oob buffer
1334 * @mtd: mtd info structure
1335 * @buf: destination buffer to store OOB bytes
1336 * @oobbuf: OOB buffer
1337 * @start: first byte to retrieve
1338 * @nbytes: number of bytes to retrieve
1339 * @iter: section iterator
1340 *
1341 * Extract bytes attached to a specific category (ECC or free)
1342 * from the OOB buffer and copy them into buf.
1343 *
1344 * Returns zero on success, a negative error code otherwise.
1345 */
1346static int mtd_ooblayout_get_bytes(struct mtd_info *mtd, u8 *buf,
1347				const u8 *oobbuf, int start, int nbytes,
1348				int (*iter)(struct mtd_info *,
1349					    int section,
1350					    struct mtd_oob_region *oobregion))
1351{
1352	struct mtd_oob_region oobregion;
1353	int section, ret;
1354
1355	ret = mtd_ooblayout_find_region(mtd, start, &section,
1356					&oobregion, iter);
1357
1358	while (!ret) {
1359		int cnt;
1360
1361		cnt = min_t(int, nbytes, oobregion.length);
1362		memcpy(buf, oobbuf + oobregion.offset, cnt);
1363		buf += cnt;
1364		nbytes -= cnt;
1365
1366		if (!nbytes)
1367			break;
1368
1369		ret = iter(mtd, ++section, &oobregion);
1370	}
1371
1372	return ret;
1373}
1374
1375/**
1376 * mtd_ooblayout_set_bytes - put OOB bytes into the oob buffer
1377 * @mtd: mtd info structure
1378 * @buf: source buffer to get OOB bytes from
1379 * @oobbuf: OOB buffer
1380 * @start: first OOB byte to set
1381 * @nbytes: number of OOB bytes to set
1382 * @iter: section iterator
1383 *
1384 * Fill the OOB buffer with data provided in buf. The category (ECC or free)
1385 * is selected by passing the appropriate iterator.
1386 *
1387 * Returns zero on success, a negative error code otherwise.
1388 */
1389static int mtd_ooblayout_set_bytes(struct mtd_info *mtd, const u8 *buf,
1390				u8 *oobbuf, int start, int nbytes,
1391				int (*iter)(struct mtd_info *,
1392					    int section,
1393					    struct mtd_oob_region *oobregion))
1394{
1395	struct mtd_oob_region oobregion;
1396	int section, ret;
1397
1398	ret = mtd_ooblayout_find_region(mtd, start, &section,
1399					&oobregion, iter);
1400
1401	while (!ret) {
1402		int cnt;
1403
1404		cnt = min_t(int, nbytes, oobregion.length);
1405		memcpy(oobbuf + oobregion.offset, buf, cnt);
1406		buf += cnt;
1407		nbytes -= cnt;
1408
1409		if (!nbytes)
1410			break;
1411
1412		ret = iter(mtd, ++section, &oobregion);
1413	}
1414
1415	return ret;
1416}
1417
1418/**
1419 * mtd_ooblayout_count_bytes - count the number of bytes in a OOB category
1420 * @mtd: mtd info structure
1421 * @iter: category iterator
1422 *
1423 * Count the number of bytes in a given category.
1424 *
1425 * Returns a positive value on success, a negative error code otherwise.
1426 */
1427static int mtd_ooblayout_count_bytes(struct mtd_info *mtd,
1428				int (*iter)(struct mtd_info *,
1429					    int section,
1430					    struct mtd_oob_region *oobregion))
1431{
1432	struct mtd_oob_region oobregion;
1433	int section = 0, ret, nbytes = 0;
1434
1435	while (1) {
1436		ret = iter(mtd, section++, &oobregion);
1437		if (ret) {
1438			if (ret == -ERANGE)
1439				ret = nbytes;
1440			break;
1441		}
1442
1443		nbytes += oobregion.length;
1444	}
1445
1446	return ret;
1447}
1448
1449/**
1450 * mtd_ooblayout_get_eccbytes - extract ECC bytes from the oob buffer
1451 * @mtd: mtd info structure
1452 * @eccbuf: destination buffer to store ECC bytes
1453 * @oobbuf: OOB buffer
1454 * @start: first ECC byte to retrieve
1455 * @nbytes: number of ECC bytes to retrieve
1456 *
1457 * Works like mtd_ooblayout_get_bytes(), except it acts on ECC bytes.
1458 *
1459 * Returns zero on success, a negative error code otherwise.
1460 */
1461int mtd_ooblayout_get_eccbytes(struct mtd_info *mtd, u8 *eccbuf,
1462			       const u8 *oobbuf, int start, int nbytes)
1463{
1464	return mtd_ooblayout_get_bytes(mtd, eccbuf, oobbuf, start, nbytes,
1465				       mtd_ooblayout_ecc);
1466}
1467EXPORT_SYMBOL_GPL(mtd_ooblayout_get_eccbytes);
1468
1469/**
1470 * mtd_ooblayout_set_eccbytes - set ECC bytes into the oob buffer
1471 * @mtd: mtd info structure
1472 * @eccbuf: source buffer to get ECC bytes from
1473 * @oobbuf: OOB buffer
1474 * @start: first ECC byte to set
1475 * @nbytes: number of ECC bytes to set
1476 *
1477 * Works like mtd_ooblayout_set_bytes(), except it acts on ECC bytes.
1478 *
1479 * Returns zero on success, a negative error code otherwise.
1480 */
1481int mtd_ooblayout_set_eccbytes(struct mtd_info *mtd, const u8 *eccbuf,
1482			       u8 *oobbuf, int start, int nbytes)
1483{
1484	return mtd_ooblayout_set_bytes(mtd, eccbuf, oobbuf, start, nbytes,
1485				       mtd_ooblayout_ecc);
1486}
1487EXPORT_SYMBOL_GPL(mtd_ooblayout_set_eccbytes);
1488
1489/**
1490 * mtd_ooblayout_get_databytes - extract data bytes from the oob buffer
1491 * @mtd: mtd info structure
1492 * @databuf: destination buffer to store ECC bytes
1493 * @oobbuf: OOB buffer
1494 * @start: first ECC byte to retrieve
1495 * @nbytes: number of ECC bytes to retrieve
1496 *
1497 * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
1498 *
1499 * Returns zero on success, a negative error code otherwise.
1500 */
1501int mtd_ooblayout_get_databytes(struct mtd_info *mtd, u8 *databuf,
1502				const u8 *oobbuf, int start, int nbytes)
1503{
1504	return mtd_ooblayout_get_bytes(mtd, databuf, oobbuf, start, nbytes,
1505				       mtd_ooblayout_free);
1506}
1507EXPORT_SYMBOL_GPL(mtd_ooblayout_get_databytes);
1508
1509/**
1510 * mtd_ooblayout_set_databytes - set data bytes into the oob buffer
1511 * @mtd: mtd info structure
1512 * @databuf: source buffer to get data bytes from
1513 * @oobbuf: OOB buffer
1514 * @start: first ECC byte to set
1515 * @nbytes: number of ECC bytes to set
1516 *
1517 * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
1518 *
1519 * Returns zero on success, a negative error code otherwise.
1520 */
1521int mtd_ooblayout_set_databytes(struct mtd_info *mtd, const u8 *databuf,
1522				u8 *oobbuf, int start, int nbytes)
1523{
1524	return mtd_ooblayout_set_bytes(mtd, databuf, oobbuf, start, nbytes,
1525				       mtd_ooblayout_free);
1526}
1527EXPORT_SYMBOL_GPL(mtd_ooblayout_set_databytes);
1528
1529/**
1530 * mtd_ooblayout_count_freebytes - count the number of free bytes in OOB
1531 * @mtd: mtd info structure
1532 *
1533 * Works like mtd_ooblayout_count_bytes(), except it count free bytes.
1534 *
1535 * Returns zero on success, a negative error code otherwise.
1536 */
1537int mtd_ooblayout_count_freebytes(struct mtd_info *mtd)
1538{
1539	return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_free);
1540}
1541EXPORT_SYMBOL_GPL(mtd_ooblayout_count_freebytes);
1542
1543/**
1544 * mtd_ooblayout_count_eccbytes - count the number of ECC bytes in OOB
1545 * @mtd: mtd info structure
1546 *
1547 * Works like mtd_ooblayout_count_bytes(), except it count ECC bytes.
1548 *
1549 * Returns zero on success, a negative error code otherwise.
1550 */
1551int mtd_ooblayout_count_eccbytes(struct mtd_info *mtd)
1552{
1553	return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_ecc);
1554}
1555EXPORT_SYMBOL_GPL(mtd_ooblayout_count_eccbytes);
1556
1557/*
1558 * Method to access the protection register area, present in some flash
1559 * devices. The user data is one time programmable but the factory data is read
1560 * only.
1561 */
1562int mtd_get_fact_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
1563			   struct otp_info *buf)
1564{
1565	if (!mtd->_get_fact_prot_info)
1566		return -EOPNOTSUPP;
1567	if (!len)
1568		return 0;
1569	return mtd->_get_fact_prot_info(mtd, len, retlen, buf);
1570}
1571EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info);
1572
1573int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
1574			   size_t *retlen, u_char *buf)
1575{
1576	*retlen = 0;
1577	if (!mtd->_read_fact_prot_reg)
1578		return -EOPNOTSUPP;
1579	if (!len)
1580		return 0;
1581	return mtd->_read_fact_prot_reg(mtd, from, len, retlen, buf);
1582}
1583EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg);
1584
1585int mtd_get_user_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
1586			   struct otp_info *buf)
1587{
1588	if (!mtd->_get_user_prot_info)
1589		return -EOPNOTSUPP;
1590	if (!len)
1591		return 0;
1592	return mtd->_get_user_prot_info(mtd, len, retlen, buf);
1593}
1594EXPORT_SYMBOL_GPL(mtd_get_user_prot_info);
1595
1596int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
1597			   size_t *retlen, u_char *buf)
1598{
1599	*retlen = 0;
1600	if (!mtd->_read_user_prot_reg)
1601		return -EOPNOTSUPP;
1602	if (!len)
1603		return 0;
1604	return mtd->_read_user_prot_reg(mtd, from, len, retlen, buf);
1605}
1606EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg);
1607
1608int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len,
1609			    size_t *retlen, u_char *buf)
1610{
1611	int ret;
1612
1613	*retlen = 0;
1614	if (!mtd->_write_user_prot_reg)
1615		return -EOPNOTSUPP;
1616	if (!len)
1617		return 0;
1618	ret = mtd->_write_user_prot_reg(mtd, to, len, retlen, buf);
1619	if (ret)
1620		return ret;
1621
1622	/*
1623	 * If no data could be written at all, we are out of memory and
1624	 * must return -ENOSPC.
1625	 */
1626	return (*retlen) ? 0 : -ENOSPC;
1627}
1628EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg);
1629
1630int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len)
1631{
1632	if (!mtd->_lock_user_prot_reg)
1633		return -EOPNOTSUPP;
1634	if (!len)
1635		return 0;
1636	return mtd->_lock_user_prot_reg(mtd, from, len);
1637}
1638EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg);
1639
1640/* Chip-supported device locking */
1641int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1642{
1643	if (!mtd->_lock)
1644		return -EOPNOTSUPP;
1645	if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
1646		return -EINVAL;
1647	if (!len)
1648		return 0;
1649	return mtd->_lock(mtd, ofs, len);
1650}
1651EXPORT_SYMBOL_GPL(mtd_lock);
1652
1653int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1654{
1655	if (!mtd->_unlock)
1656		return -EOPNOTSUPP;
1657	if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
1658		return -EINVAL;
1659	if (!len)
1660		return 0;
1661	return mtd->_unlock(mtd, ofs, len);
1662}
1663EXPORT_SYMBOL_GPL(mtd_unlock);
1664
1665int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1666{
1667	if (!mtd->_is_locked)
1668		return -EOPNOTSUPP;
1669	if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
1670		return -EINVAL;
1671	if (!len)
1672		return 0;
1673	return mtd->_is_locked(mtd, ofs, len);
1674}
1675EXPORT_SYMBOL_GPL(mtd_is_locked);
1676
1677int mtd_block_isreserved(struct mtd_info *mtd, loff_t ofs)
1678{
1679	if (ofs < 0 || ofs >= mtd->size)
1680		return -EINVAL;
1681	if (!mtd->_block_isreserved)
1682		return 0;
1683	return mtd->_block_isreserved(mtd, ofs);
1684}
1685EXPORT_SYMBOL_GPL(mtd_block_isreserved);
1686
1687int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs)
1688{
1689	if (ofs < 0 || ofs >= mtd->size)
1690		return -EINVAL;
1691	if (!mtd->_block_isbad)
1692		return 0;
 
 
1693	return mtd->_block_isbad(mtd, ofs);
1694}
1695EXPORT_SYMBOL_GPL(mtd_block_isbad);
1696
1697int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs)
1698{
1699	if (!mtd->_block_markbad)
1700		return -EOPNOTSUPP;
1701	if (ofs < 0 || ofs >= mtd->size)
1702		return -EINVAL;
1703	if (!(mtd->flags & MTD_WRITEABLE))
1704		return -EROFS;
1705	return mtd->_block_markbad(mtd, ofs);
1706}
1707EXPORT_SYMBOL_GPL(mtd_block_markbad);
1708
1709/*
1710 * default_mtd_writev - the default writev method
1711 * @mtd: mtd device description object pointer
1712 * @vecs: the vectors to write
1713 * @count: count of vectors in @vecs
1714 * @to: the MTD device offset to write to
1715 * @retlen: on exit contains the count of bytes written to the MTD device.
1716 *
1717 * This function returns zero in case of success and a negative error code in
1718 * case of failure.
1719 */
1720static int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
1721			      unsigned long count, loff_t to, size_t *retlen)
1722{
1723	unsigned long i;
1724	size_t totlen = 0, thislen;
1725	int ret = 0;
1726
1727	for (i = 0; i < count; i++) {
1728		if (!vecs[i].iov_len)
1729			continue;
1730		ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen,
1731				vecs[i].iov_base);
1732		totlen += thislen;
1733		if (ret || thislen != vecs[i].iov_len)
1734			break;
1735		to += vecs[i].iov_len;
1736	}
1737	*retlen = totlen;
1738	return ret;
1739}
1740
1741/*
1742 * mtd_writev - the vector-based MTD write method
1743 * @mtd: mtd device description object pointer
1744 * @vecs: the vectors to write
1745 * @count: count of vectors in @vecs
1746 * @to: the MTD device offset to write to
1747 * @retlen: on exit contains the count of bytes written to the MTD device.
1748 *
1749 * This function returns zero in case of success and a negative error code in
1750 * case of failure.
1751 */
1752int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
1753	       unsigned long count, loff_t to, size_t *retlen)
1754{
1755	*retlen = 0;
1756	if (!(mtd->flags & MTD_WRITEABLE))
1757		return -EROFS;
1758	if (!mtd->_writev)
1759		return default_mtd_writev(mtd, vecs, count, to, retlen);
1760	return mtd->_writev(mtd, vecs, count, to, retlen);
1761}
1762EXPORT_SYMBOL_GPL(mtd_writev);
1763
1764/**
1765 * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size
1766 * @mtd: mtd device description object pointer
1767 * @size: a pointer to the ideal or maximum size of the allocation, points
1768 *        to the actual allocation size on success.
1769 *
1770 * This routine attempts to allocate a contiguous kernel buffer up to
1771 * the specified size, backing off the size of the request exponentially
1772 * until the request succeeds or until the allocation size falls below
1773 * the system page size. This attempts to make sure it does not adversely
1774 * impact system performance, so when allocating more than one page, we
1775 * ask the memory allocator to avoid re-trying, swapping, writing back
1776 * or performing I/O.
1777 *
1778 * Note, this function also makes sure that the allocated buffer is aligned to
1779 * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value.
1780 *
1781 * This is called, for example by mtd_{read,write} and jffs2_scan_medium,
1782 * to handle smaller (i.e. degraded) buffer allocations under low- or
1783 * fragmented-memory situations where such reduced allocations, from a
1784 * requested ideal, are allowed.
1785 *
1786 * Returns a pointer to the allocated buffer on success; otherwise, NULL.
1787 */
1788void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size)
1789{
1790	gfp_t flags = __GFP_NOWARN | __GFP_DIRECT_RECLAIM | __GFP_NORETRY;
 
1791	size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE);
1792	void *kbuf;
1793
1794	*size = min_t(size_t, *size, KMALLOC_MAX_SIZE);
1795
1796	while (*size > min_alloc) {
1797		kbuf = kmalloc(*size, flags);
1798		if (kbuf)
1799			return kbuf;
1800
1801		*size >>= 1;
1802		*size = ALIGN(*size, mtd->writesize);
1803	}
1804
1805	/*
1806	 * For the last resort allocation allow 'kmalloc()' to do all sorts of
1807	 * things (write-back, dropping caches, etc) by using GFP_KERNEL.
1808	 */
1809	return kmalloc(*size, GFP_KERNEL);
1810}
1811EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to);
1812
1813#ifdef CONFIG_PROC_FS
1814
1815/*====================================================================*/
1816/* Support for /proc/mtd */
1817
1818static int mtd_proc_show(struct seq_file *m, void *v)
1819{
1820	struct mtd_info *mtd;
1821
1822	seq_puts(m, "dev:    size   erasesize  name\n");
1823	mutex_lock(&mtd_table_mutex);
1824	mtd_for_each_device(mtd) {
1825		seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n",
1826			   mtd->index, (unsigned long long)mtd->size,
1827			   mtd->erasesize, mtd->name);
1828	}
1829	mutex_unlock(&mtd_table_mutex);
1830	return 0;
1831}
1832
1833static int mtd_proc_open(struct inode *inode, struct file *file)
1834{
1835	return single_open(file, mtd_proc_show, NULL);
1836}
1837
1838static const struct file_operations mtd_proc_ops = {
1839	.open		= mtd_proc_open,
1840	.read		= seq_read,
1841	.llseek		= seq_lseek,
1842	.release	= single_release,
1843};
1844#endif /* CONFIG_PROC_FS */
1845
1846/*====================================================================*/
1847/* Init code */
1848
1849static struct backing_dev_info * __init mtd_bdi_init(char *name)
1850{
1851	struct backing_dev_info *bdi;
1852	int ret;
1853
1854	bdi = bdi_alloc(GFP_KERNEL);
1855	if (!bdi)
1856		return ERR_PTR(-ENOMEM);
1857
1858	bdi->name = name;
1859	/*
1860	 * We put '-0' suffix to the name to get the same name format as we
1861	 * used to get. Since this is called only once, we get a unique name. 
1862	 */
1863	ret = bdi_register(bdi, "%.28s-0", name);
1864	if (ret)
1865		bdi_put(bdi);
1866
1867	return ret ? ERR_PTR(ret) : bdi;
1868}
1869
1870static struct proc_dir_entry *proc_mtd;
1871
1872static int __init init_mtd(void)
1873{
1874	int ret;
1875
1876	ret = class_register(&mtd_class);
1877	if (ret)
1878		goto err_reg;
1879
1880	mtd_bdi = mtd_bdi_init("mtd");
1881	if (IS_ERR(mtd_bdi)) {
1882		ret = PTR_ERR(mtd_bdi);
1883		goto err_bdi;
1884	}
 
 
 
 
 
 
1885
1886	proc_mtd = proc_create("mtd", 0, NULL, &mtd_proc_ops);
1887
1888	ret = init_mtdchar();
1889	if (ret)
1890		goto out_procfs;
1891
1892	dfs_dir_mtd = debugfs_create_dir("mtd", NULL);
1893
1894	return 0;
1895
1896out_procfs:
1897	if (proc_mtd)
1898		remove_proc_entry("mtd", NULL);
1899	bdi_put(mtd_bdi);
1900err_bdi:
 
 
 
1901	class_unregister(&mtd_class);
1902err_reg:
1903	pr_err("Error registering mtd class or bdi: %d\n", ret);
1904	return ret;
1905}
1906
1907static void __exit cleanup_mtd(void)
1908{
1909	debugfs_remove_recursive(dfs_dir_mtd);
1910	cleanup_mtdchar();
1911	if (proc_mtd)
1912		remove_proc_entry("mtd", NULL);
1913	class_unregister(&mtd_class);
1914	bdi_put(mtd_bdi);
1915	idr_destroy(&mtd_idr);
 
1916}
1917
1918module_init(init_mtd);
1919module_exit(cleanup_mtd);
1920
1921MODULE_LICENSE("GPL");
1922MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1923MODULE_DESCRIPTION("Core MTD registration and access routines");