Merge git://git.infradead.org/mtd-2.6 (ab5cfd2a) · Commits · 戴 / test

drivers/mtd/chips/cfi_cmdset_0001.c

+43 −44

Original line number	Diff line number	Diff line
		@@ -908,7 +908,7 @@ static void __xipram xip_enable(struct map_info map, struct flchip chip,

		static int __xipram xip_wait_for_operation(
		struct map_info map, struct flchip chip,
		unsigned long adr, int *chip_op_time )
		unsigned long adr, unsigned int chip_op_time )
		{
		struct cfi_private *cfi = map->fldrv_priv;
		struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
		@@ -917,7 +917,7 @@ static int __xipram xip_wait_for_operation(
		flstate_t oldstate, newstate;

		start = xip_currtime();
		usec = chip_op_time 8;
		usec = chip_op_time * 8;
		if (usec == 0)
		usec = 500000;
		done = 0;
		@@ -1027,8 +1027,8 @@ static int __xipram xip_wait_for_operation(
		#define XIP_INVAL_CACHED_RANGE(map, from, size) \
		INVALIDATE_CACHED_RANGE(map, from, size)

		#define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, p_usec) \
		xip_wait_for_operation(map, chip, cmd_adr, p_usec)
		#define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec) \
		xip_wait_for_operation(map, chip, cmd_adr, usec)

		#else

		@@ -1040,64 +1040,64 @@ static int __xipram xip_wait_for_operation(
		static int inval_cache_and_wait_for_operation(
		struct map_info map, struct flchip chip,
		unsigned long cmd_adr, unsigned long inval_adr, int inval_len,
		int *chip_op_time )
		unsigned int chip_op_time)
		{
		struct cfi_private *cfi = map->fldrv_priv;
		map_word status, status_OK = CMD(0x80);
		int z, chip_state = chip->state;
		unsigned long timeo;
		int chip_state = chip->state;
		unsigned int timeo, sleep_time;

		spin_unlock(chip->mutex);
		if (inval_len)
		INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
		if (*chip_op_time)
		cfi_udelay(*chip_op_time);
		spin_lock(chip->mutex);

		timeo = chip_op_time 8 * HZ / 1000000;
		if (timeo < HZ/2)
		timeo = HZ/2;
		timeo += jiffies;
		/* set our timeout to 8 times the expected delay */
		timeo = chip_op_time * 8;
		if (!timeo)
		timeo = 500000;
		sleep_time = chip_op_time / 2;

		z = 0;
		for (;;) {
		if (chip->state != chip_state) {
		/* Someone's suspended the operation: sleep */
		DECLARE_WAITQUEUE(wait, current);

		set_current_state(TASK_UNINTERRUPTIBLE);
		add_wait_queue(&chip->wq, &wait);
		spin_unlock(chip->mutex);
		schedule();
		remove_wait_queue(&chip->wq, &wait);
		timeo = jiffies + (HZ / 2); /* FIXME */
		spin_lock(chip->mutex);
		continue;
		}

		status = map_read(map, cmd_adr);
		if (map_word_andequal(map, status, status_OK, status_OK))
		break;

		/* OK Still waiting */
		if (time_after(jiffies, timeo)) {
		if (!timeo) {
		map_write(map, CMD(0x70), cmd_adr);
		chip->state = FL_STATUS;
		return -ETIME;
		}

		/* Latency issues. Drop the lock, wait a while and retry */
		z++;
		/* OK Still waiting. Drop the lock, wait a while and retry. */
		spin_unlock(chip->mutex);
		cfi_udelay(1);
		spin_lock(chip->mutex);
		if (sleep_time >= 1000000/HZ) {
		/*
		* Half of the normal delay still remaining
		* can be performed with a sleeping delay instead
		* of busy waiting.
		*/
		msleep(sleep_time/1000);
		timeo -= sleep_time;
		sleep_time = 1000000/HZ;
		} else {
		udelay(1);
		cond_resched();
		timeo--;
		}
		spin_lock(chip->mutex);

		if (!z) {
		if (!--(*chip_op_time))
		*chip_op_time = 1;
		} else if (z > 1)
		++(*chip_op_time);
		if (chip->state != chip_state) {
		/* Someone's suspended the operation: sleep */
		DECLARE_WAITQUEUE(wait, current);
		set_current_state(TASK_UNINTERRUPTIBLE);
		add_wait_queue(&chip->wq, &wait);
		spin_unlock(chip->mutex);
		schedule();
		remove_wait_queue(&chip->wq, &wait);
		spin_lock(chip->mutex);
		}
		}

		/* Done and happy. */
		chip->state = FL_STATUS;
		@@ -1107,8 +1107,7 @@ static int inval_cache_and_wait_for_operation(
		#endif

		#define WAIT_TIMEOUT(map, chip, adr, udelay) \
		({ int __udelay = (udelay); \
		INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, &__udelay); })
		INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay);


		static int do_point_onechip (struct map_info map, struct flchip chip, loff_t adr, size_t len)
		@@ -1332,7 +1331,7 @@ static int __xipram do_write_oneword(struct map_info map, struct flchip chip,

		ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
		adr, map_bankwidth(map),
		&chip->word_write_time);
		chip->word_write_time);
		if (ret) {
		xip_enable(map, chip, adr);
		printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
		@@ -1569,7 +1568,7 @@ static int __xipram do_write_buffer(struct map_info map, struct flchip chip,

		ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
		adr, len,
		&chip->buffer_write_time);
		chip->buffer_write_time);
		if (ret) {
		map_write(map, CMD(0x70), cmd_adr);
		chip->state = FL_STATUS;
		@@ -1704,7 +1703,7 @@ static int __xipram do_erase_oneblock(struct map_info map, struct flchip chip,

		ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
		adr, len,
		&chip->erase_time);
		chip->erase_time);
		if (ret) {
		map_write(map, CMD(0x70), adr);
		chip->state = FL_STATUS;

drivers/mtd/chips/cfi_cmdset_0002.c

+111 −0

Original line number	Diff line number	Diff line
		@@ -45,9 +45,11 @@
		#define MAX_WORD_RETRIES 3

		#define MANUFACTURER_AMD 0x0001
		#define MANUFACTURER_ATMEL 0x001F
		#define MANUFACTURER_SST 0x00BF
		#define SST49LF004B 0x0060
		#define SST49LF008A 0x005a
		#define AT49BV6416 0x00d6

		static int cfi_amdstd_read (struct mtd_info , loff_t, size_t, size_t , u_char *);
		static int cfi_amdstd_write_words(struct mtd_info , loff_t, size_t, size_t , const u_char *);
		@@ -68,6 +70,9 @@ static int get_chip(struct map_info map, struct flchip chip, unsigned long adr
		static void put_chip(struct map_info map, struct flchip chip, unsigned long adr);
		#include "fwh_lock.h"

		static int cfi_atmel_lock(struct mtd_info *mtd, loff_t ofs, size_t len);
		static int cfi_atmel_unlock(struct mtd_info *mtd, loff_t ofs, size_t len);

		static struct mtd_chip_driver cfi_amdstd_chipdrv = {
		.probe = NULL, /* Not usable directly */
		.destroy = cfi_amdstd_destroy,
		@@ -161,6 +166,26 @@ static void fixup_use_write_buffers(struct mtd_info mtd, void param)
		}
		}

		/* Atmel chips don't use the same PRI format as AMD chips */
		static void fixup_convert_atmel_pri(struct mtd_info mtd, void param)
		{
		struct map_info *map = mtd->priv;
		struct cfi_private *cfi = map->fldrv_priv;
		struct cfi_pri_amdstd *extp = cfi->cmdset_priv;
		struct cfi_pri_atmel atmel_pri;

		memcpy(&atmel_pri, extp, sizeof(atmel_pri));
		memset((char )extp + 5, 0, sizeof(extp) - 5);

		if (atmel_pri.Features & 0x02)
		extp->EraseSuspend = 2;

		if (atmel_pri.BottomBoot)
		extp->TopBottom = 2;
		else
		extp->TopBottom = 3;
		}

		static void fixup_use_secsi(struct mtd_info mtd, void param)
		{
		/* Setup for chips with a secsi area */
		@@ -179,6 +204,16 @@ static void fixup_use_erase_chip(struct mtd_info mtd, void param)

		}

		/*
		* Some Atmel chips (e.g. the AT49BV6416) power-up with all sectors
		* locked by default.
		*/
		static void fixup_use_atmel_lock(struct mtd_info mtd, void param)
		{
		mtd->lock = cfi_atmel_lock;
		mtd->unlock = cfi_atmel_unlock;
		}

		static struct cfi_fixup cfi_fixup_table[] = {
		#ifdef AMD_BOOTLOC_BUG
		{ CFI_MFR_AMD, CFI_ID_ANY, fixup_amd_bootblock, NULL },
		@@ -192,6 +227,7 @@ static struct cfi_fixup cfi_fixup_table[] = {
		#if !FORCE_WORD_WRITE
		{ CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers, NULL, },
		#endif
		{ CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri, NULL },
		{ 0, 0, NULL, NULL }
		};
		static struct cfi_fixup jedec_fixup_table[] = {
		@@ -207,6 +243,7 @@ static struct cfi_fixup fixup_table[] = {
		* we know that is the case.
		*/
		{ CFI_MFR_ANY, CFI_ID_ANY, fixup_use_erase_chip, NULL },
		{ CFI_MFR_ATMEL, AT49BV6416, fixup_use_atmel_lock, NULL },
		{ 0, 0, NULL, NULL }
		};

		@@ -1607,6 +1644,80 @@ static int cfi_amdstd_erase_chip(struct mtd_info mtd, struct erase_info instr)
		return 0;
		}

		static int do_atmel_lock(struct map_info map, struct flchip chip,
		unsigned long adr, int len, void *thunk)
		{
		struct cfi_private *cfi = map->fldrv_priv;
		int ret;

		spin_lock(chip->mutex);
		ret = get_chip(map, chip, adr + chip->start, FL_LOCKING);
		if (ret)
		goto out_unlock;
		chip->state = FL_LOCKING;

		DEBUG(MTD_DEBUG_LEVEL3, "MTD %s(): LOCK 0x%08lx len %d\n",
		__func__, adr, len);

		cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
		cfi->device_type, NULL);
		cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi,
		cfi->device_type, NULL);
		cfi_send_gen_cmd(0x80, cfi->addr_unlock1, chip->start, map, cfi,
		cfi->device_type, NULL);
		cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
		cfi->device_type, NULL);
		cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi,
		cfi->device_type, NULL);
		map_write(map, CMD(0x40), chip->start + adr);

		chip->state = FL_READY;
		put_chip(map, chip, adr + chip->start);
		ret = 0;

		out_unlock:
		spin_unlock(chip->mutex);
		return ret;
		}

		static int do_atmel_unlock(struct map_info map, struct flchip chip,
		unsigned long adr, int len, void *thunk)
		{
		struct cfi_private *cfi = map->fldrv_priv;
		int ret;

		spin_lock(chip->mutex);
		ret = get_chip(map, chip, adr + chip->start, FL_UNLOCKING);
		if (ret)
		goto out_unlock;
		chip->state = FL_UNLOCKING;

		DEBUG(MTD_DEBUG_LEVEL3, "MTD %s(): LOCK 0x%08lx len %d\n",
		__func__, adr, len);

		cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
		cfi->device_type, NULL);
		map_write(map, CMD(0x70), adr);

		chip->state = FL_READY;
		put_chip(map, chip, adr + chip->start);
		ret = 0;

		out_unlock:
		spin_unlock(chip->mutex);
		return ret;
		}

		static int cfi_atmel_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
		{
		return cfi_varsize_frob(mtd, do_atmel_lock, ofs, len, NULL);
		}

		static int cfi_atmel_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
		{
		return cfi_varsize_frob(mtd, do_atmel_unlock, ofs, len, NULL);
		}


		static void cfi_amdstd_sync (struct mtd_info *mtd)
		{

drivers/mtd/chips/jedec_probe.c

+14 −0

Original line number	Diff line number	Diff line
		@@ -111,6 +111,7 @@
		#define MX29LV040C 0x004F
		#define MX29LV160T 0x22C4
		#define MX29LV160B 0x2249
		#define MX29F040 0x00A4
		#define MX29F016 0x00AD
		#define MX29F002T 0x00B0
		#define MX29F004T 0x0045
		@@ -1170,6 +1171,19 @@ static const struct amd_flash_info jedec_table[] = {
		ERASEINFO(0x08000,1),
		ERASEINFO(0x10000,31)
		}
		}, {
		.mfr_id = MANUFACTURER_MACRONIX,
		.dev_id = MX29F040,
		.name = "Macronix MX29F040",
		.uaddr = {
		[0] = MTD_UADDR_0x0555_0x02AA /* x8 */
		},
		.DevSize = SIZE_512KiB,
		.CmdSet = P_ID_AMD_STD,
		.NumEraseRegions= 1,
		.regions = {
		ERASEINFO(0x10000,8),
		}
		}, {
		.mfr_id = MANUFACTURER_MACRONIX,
		.dev_id = MX29F016,

drivers/mtd/devices/block2mtd.c

+63 −30

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@
		#include <linux/mtd/mtd.h>
		#include <linux/buffer_head.h>
		#include <linux/mutex.h>
		#include <linux/mount.h>

		#define VERSION "$Revision: 1.30 $"

		@@ -236,6 +237,8 @@ static int _block2mtd_write(struct block2mtd_dev dev, const u_char buf,
		}
		return 0;
		}


		static int block2mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
		size_t retlen, const u_char buf)
		{
		@@ -299,6 +302,19 @@ static struct block2mtd_dev add_device(char devname, int erase_size)

		/* Get a handle on the device */
		bdev = open_bdev_excl(devname, O_RDWR, NULL);
		#ifndef MODULE
		if (IS_ERR(bdev)) {

		/* We might not have rootfs mounted at this point. Try
		to resolve the device name by other means. */

		dev_t dev = name_to_dev_t(devname);
		if (dev != 0) {
		bdev = open_by_devnum(dev, FMODE_WRITE \| FMODE_READ);
		}
		}
		#endif

		if (IS_ERR(bdev)) {
		ERROR("error: cannot open device %s", devname);
		goto devinit_err;
		@@ -393,26 +409,6 @@ static int parse_num(size_t num, const char token)
		}


		static int parse_name(char *pname, const char token, size_t limit)
		{
		size_t len;
		char *name;

		len = strlen(token) + 1;
		if (len > limit)
		return -ENOSPC;

		name = kmalloc(len, GFP_KERNEL);
		if (!name)
		return -ENOMEM;

		strcpy(name, token);

		*pname = name;
		return 0;
		}


		static inline void kill_final_newline(char *str)
		{
		char *newline = strrchr(str, '\n');
		@@ -426,7 +422,13 @@ static inline void kill_final_newline(char *str)
		return 0; \
		} while (0)

		static int block2mtd_setup(const char val, struct kernel_param kp)
		#ifndef MODULE
		static int block2mtd_init_called = 0;
		static __initdata char block2mtd_paramline[80 + 12]; /* 80 for device, 12 for erase size */
		#endif


		static int block2mtd_setup2(const char *val)
		{
		char buf[80 + 12]; /* 80 for device, 12 for erase size */
		char *str = buf;
		@@ -450,13 +452,9 @@ static int block2mtd_setup(const char val, struct kernel_param kp)
		if (!token[0])
		parse_err("no argument");

		ret = parse_name(&name, token[0], 80);
		if (ret == -ENOMEM)
		parse_err("out of memory");
		if (ret == -ENOSPC)
		parse_err("name too long");
		if (ret)
		return 0;
		name = token[0];
		if (strlen(name) + 1 > 80)
		parse_err("device name too long");

		if (token[1]) {
		ret = parse_num(&erase_size, token[1]);
		@@ -472,13 +470,48 @@ static int block2mtd_setup(const char val, struct kernel_param kp)
		}


		static int block2mtd_setup(const char val, struct kernel_param kp)
		{
		#ifdef MODULE
		return block2mtd_setup2(val);
		#else
		/* If more parameters are later passed in via
		/sys/module/block2mtd/parameters/block2mtd
		and block2mtd_init() has already been called,
		we can parse the argument now. */

		if (block2mtd_init_called)
		return block2mtd_setup2(val);

		/* During early boot stage, we only save the parameters
		here. We must parse them later: if the param passed
		from kernel boot command line, block2mtd_setup() is
		called so early that it is not possible to resolve
		the device (even kmalloc() fails). Deter that work to
		block2mtd_setup2(). */

		strlcpy(block2mtd_paramline, val, sizeof(block2mtd_paramline));

		return 0;
		#endif
		}


		module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
		MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>]\"");

		static int __init block2mtd_init(void)
		{
		int ret = 0;
		INFO("version " VERSION);
		return 0;

		#ifndef MODULE
		if (strlen(block2mtd_paramline))
		ret = block2mtd_setup2(block2mtd_paramline);
		block2mtd_init_called = 1;
		#endif

		return ret;
		}

drivers/mtd/devices/m25p80.c

+6 −6

Original line number	Diff line number	Diff line
		@@ -406,13 +406,13 @@ struct flash_info {

		static struct flash_info __devinitdata m25p_data [] = {
		/* REVISIT: fill in JEDEC ids, for parts that have them */
		{ "m25p05", 0x05, 0x0000, 32 * 1024, 2 },
		{ "m25p10", 0x10, 0x0000, 32 * 1024, 4 },
		{ "m25p20", 0x11, 0x0000, 64 * 1024, 4 },
		{ "m25p40", 0x12, 0x0000, 64 * 1024, 8 },
		{ "m25p05", 0x05, 0x2010, 32 * 1024, 2 },
		{ "m25p10", 0x10, 0x2011, 32 * 1024, 4 },
		{ "m25p20", 0x11, 0x2012, 64 * 1024, 4 },
		{ "m25p40", 0x12, 0x2013, 64 * 1024, 8 },
		{ "m25p80", 0x13, 0x0000, 64 * 1024, 16 },
		{ "m25p16", 0x14, 0x0000, 64 * 1024, 32 },
		{ "m25p32", 0x15, 0x0000, 64 * 1024, 64 },
		{ "m25p16", 0x14, 0x2015, 64 * 1024, 32 },
		{ "m25p32", 0x15, 0x2016, 64 * 1024, 64 },
		{ "m25p64", 0x16, 0x2017, 64 * 1024, 128 },
		};

Admin message