Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8033c6e9 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/drzeus/mmc 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/drzeus/mmc:
  at91_mci: minor cleanup
  mmc: mmc host test driver
  mmc: Fix omap compile by replacing dev_name with dma_dev_name
parents 2d3cf588 e5c0ef90

drivers/mmc/card/Kconfig

+12 −0
Original line number Diff line number Diff line
@@ -39,3 +39,15 @@ config SDIO_UART 
	  SDIO function driver for SDIO cards that implements the UART

	  class, as well as the GPS class which appears like a UART.



config MMC_TEST

	tristate "MMC host test driver"

	default n

	help

	  Development driver that performs a series of reads and writes

	  to a memory card in order to expose certain well known bugs

	  in host controllers. The tests are executed by writing to the

	  "test" file in sysfs under each card. Note that whatever is

	  on your card will be overwritten by these tests.



	  This driver is only of interest to those developing or

	  testing a host driver. Most people should say N here.

drivers/mmc/card/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ endif 


obj-$(CONFIG_MMC_BLOCK)		+= mmc_block.o

mmc_block-objs			:= block.o queue.o

obj-$(CONFIG_MMC_TEST)		+= mmc_test.o



obj-$(CONFIG_SDIO_UART)		+= sdio_uart.o

drivers/mmc/card/mmc_test.c

0 → 100644
+892 −0
Original line number Diff line number Diff line 
/*

 *  linux/drivers/mmc/card/mmc_test.c

 *

 *  Copyright 2007 Pierre Ossman

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or (at

 * your option) any later version.

 */



#include <linux/mmc/core.h>

#include <linux/mmc/card.h>

#include <linux/mmc/host.h>

#include <linux/mmc/mmc.h>



#include <linux/scatterlist.h>



#define RESULT_OK		0

#define RESULT_FAIL		1

#define RESULT_UNSUP_HOST	2

#define RESULT_UNSUP_CARD	3



#define BUFFER_SIZE	(PAGE_SIZE * 4)



struct mmc_test_card {

	struct mmc_card	*card;



	u8		*buffer;

};



/*******************************************************************/

/*  Helper functions                                               */

/*******************************************************************/



static int mmc_test_set_blksize(struct mmc_test_card *test, unsigned size)

{

	struct mmc_command cmd;

	int ret;



	cmd.opcode = MMC_SET_BLOCKLEN;

	cmd.arg = size;

	cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;

	ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);

	if (ret)

		return ret;



	return 0;

}



static int __mmc_test_transfer(struct mmc_test_card *test, int write,

	unsigned broken_xfer, u8 *buffer, unsigned addr,

	unsigned blocks, unsigned blksz)

{

	int ret, busy;



	struct mmc_request mrq;

	struct mmc_command cmd;

	struct mmc_command stop;

	struct mmc_data data;



	struct scatterlist sg;



	memset(&mrq, 0, sizeof(struct mmc_request));



	mrq.cmd = &cmd;

	mrq.data = &data;



	memset(&cmd, 0, sizeof(struct mmc_command));



	if (broken_xfer) {

		if (blocks > 1) {

			cmd.opcode = write ?

				MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;

		} else {

			cmd.opcode = MMC_SEND_STATUS;

		}

	} else {

		if (blocks > 1) {

			cmd.opcode = write ?

				MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK;

		} else {

			cmd.opcode = write ?

				MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;

		}

	}



	if (broken_xfer && blocks == 1)

		cmd.arg = test->card->rca << 16;

	else

		cmd.arg = addr;

	cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;



	memset(&stop, 0, sizeof(struct mmc_command));



	if (!broken_xfer && (blocks > 1)) {

		stop.opcode = MMC_STOP_TRANSMISSION;

		stop.arg = 0;

		stop.flags = MMC_RSP_R1B | MMC_CMD_AC;



		mrq.stop = &stop;

	}



	memset(&data, 0, sizeof(struct mmc_data));



	data.blksz = blksz;

	data.blocks = blocks;

	data.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;

	data.sg = &sg;

	data.sg_len = 1;



	sg_init_one(&sg, buffer, blocks * blksz);



	mmc_set_data_timeout(&data, test->card);



	mmc_wait_for_req(test->card->host, &mrq);



	ret = 0;



	if (broken_xfer) {

		if (!ret && cmd.error)

			ret = cmd.error;

		if (!ret && data.error == 0)

			ret = RESULT_FAIL;

		if (!ret && data.error != -ETIMEDOUT)

			ret = data.error;

		if (!ret && stop.error)

			ret = stop.error;

		if (blocks > 1) {

			if (!ret && data.bytes_xfered > blksz)

				ret = RESULT_FAIL;

		} else {

			if (!ret && data.bytes_xfered > 0)

				ret = RESULT_FAIL;

		}

	} else {

		if (!ret && cmd.error)

			ret = cmd.error;

		if (!ret && data.error)

			ret = data.error;

		if (!ret && stop.error)

			ret = stop.error;

		if (!ret && data.bytes_xfered != blocks * blksz)

			ret = RESULT_FAIL;

	}



	if (ret == -EINVAL)

		ret = RESULT_UNSUP_HOST;



	busy = 0;

	do {

		int ret2;



		memset(&cmd, 0, sizeof(struct mmc_command));



		cmd.opcode = MMC_SEND_STATUS;

		cmd.arg = test->card->rca << 16;

		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;



		ret2 = mmc_wait_for_cmd(test->card->host, &cmd, 0);

		if (ret2)

			break;



		if (!busy && !(cmd.resp[0] & R1_READY_FOR_DATA)) {

			busy = 1;

			printk(KERN_INFO "%s: Warning: Host did not "

				"wait for busy state to end.\n",

				mmc_hostname(test->card->host));

		}

	} while (!(cmd.resp[0] & R1_READY_FOR_DATA));



	return ret;

}



static int mmc_test_transfer(struct mmc_test_card *test, int write,

	u8 *buffer, unsigned addr, unsigned blocks, unsigned blksz)

{

	return __mmc_test_transfer(test, write, 0, buffer,

			addr, blocks, blksz);

}



static int mmc_test_prepare_verify(struct mmc_test_card *test, int write)

{

	int ret, i;



	ret = mmc_test_set_blksize(test, 512);

	if (ret)

		return ret;



	if (write)

		memset(test->buffer, 0xDF, BUFFER_SIZE);

	else {

		for (i = 0;i < BUFFER_SIZE;i++)

			test->buffer[i] = i;

	}



	for (i = 0;i < BUFFER_SIZE / 512;i++) {

		ret = mmc_test_transfer(test, 1, test->buffer + i * 512,

			i * 512, 1, 512);

		if (ret)

			return ret;

	}



	return 0;

}



static int mmc_test_prepare_verify_write(struct mmc_test_card *test)

{

	return mmc_test_prepare_verify(test, 1);

}



static int mmc_test_prepare_verify_read(struct mmc_test_card *test)

{

	return mmc_test_prepare_verify(test, 0);

}



static int mmc_test_verified_transfer(struct mmc_test_card *test, int write,

	u8 *buffer, unsigned addr, unsigned blocks, unsigned blksz)

{

	int ret, i, sectors;



	/*

	 * It is assumed that the above preparation has been done.

	 */



	memset(test->buffer, 0, BUFFER_SIZE);



	if (write) {

		for (i = 0;i < blocks * blksz;i++)

			buffer[i] = i;

	}



	ret = mmc_test_set_blksize(test, blksz);

	if (ret)

		return ret;



	ret = mmc_test_transfer(test, write, buffer, addr, blocks, blksz);

	if (ret)

		return ret;



	if (write) {

		ret = mmc_test_set_blksize(test, 512);

		if (ret)

			return ret;



		sectors = (blocks * blksz + 511) / 512;

		if ((sectors * 512) == (blocks * blksz))

			sectors++;



		if ((sectors * 512) > BUFFER_SIZE)

			return -EINVAL;



		memset(test->buffer, 0, sectors * 512);



		for (i = 0;i < sectors;i++) {

			ret = mmc_test_transfer(test, 0,

				test->buffer + i * 512,

				addr + i * 512, 1, 512);

			if (ret)

				return ret;

		}



		for (i = 0;i < blocks * blksz;i++) {

			if (test->buffer[i] != (u8)i)

				return RESULT_FAIL;

		}



		for (;i < sectors * 512;i++) {

			if (test->buffer[i] != 0xDF)

				return RESULT_FAIL;

		}

	} else {

		for (i = 0;i < blocks * blksz;i++) {

			if (buffer[i] != (u8)i)

				return RESULT_FAIL;

		}

	}



	return 0;

}



static int mmc_test_cleanup_verify(struct mmc_test_card *test)

{

	int ret, i;



	ret = mmc_test_set_blksize(test, 512);

	if (ret)

		return ret;



	memset(test->buffer, 0, BUFFER_SIZE);



	for (i = 0;i < BUFFER_SIZE / 512;i++) {

		ret = mmc_test_transfer(test, 1, test->buffer + i * 512,

			i * 512, 1, 512);

		if (ret)

			return ret;

	}



	return 0;

}



/*******************************************************************/

/*  Tests                                                          */

/*******************************************************************/



struct mmc_test_case {

	const char *name;



	int (*prepare)(struct mmc_test_card *);

	int (*run)(struct mmc_test_card *);

	int (*cleanup)(struct mmc_test_card *);

};



static int mmc_test_basic_write(struct mmc_test_card *test)

{

	int ret;



	ret = mmc_test_set_blksize(test, 512);

	if (ret)

		return ret;



	ret = mmc_test_transfer(test, 1, test->buffer, 0, 1, 512);

	if (ret)

		return ret;



	return 0;

}



static int mmc_test_basic_read(struct mmc_test_card *test)

{

	int ret;



	ret = mmc_test_set_blksize(test, 512);

	if (ret)

		return ret;



	ret = mmc_test_transfer(test, 0, test->buffer, 0, 1, 512);

	if (ret)

		return ret;



	return 0;

}



static int mmc_test_verify_write(struct mmc_test_card *test)

{

	int ret;



	ret = mmc_test_verified_transfer(test, 1, test->buffer, 0, 1, 512);

	if (ret)

		return ret;



	return 0;

}



static int mmc_test_verify_read(struct mmc_test_card *test)

{

	int ret;



	ret = mmc_test_verified_transfer(test, 0, test->buffer, 0, 1, 512);

	if (ret)

		return ret;



	return 0;

}



static int mmc_test_multi_write(struct mmc_test_card *test)

{

	int ret;

	unsigned int size;



	if (test->card->host->max_blk_count == 1)

		return RESULT_UNSUP_HOST;



	size = PAGE_SIZE * 2;

	size = min(size, test->card->host->max_req_size);

	size = min(size, test->card->host->max_seg_size);

	size = min(size, test->card->host->max_blk_count * 512);



	if (size < 1024)

		return RESULT_UNSUP_HOST;



	ret = mmc_test_verified_transfer(test, 1, test->buffer, 0,

		size / 512, 512);

	if (ret)

		return ret;



	return 0;

}



static int mmc_test_multi_read(struct mmc_test_card *test)

{

	int ret;

	unsigned int size;



	if (test->card->host->max_blk_count == 1)

		return RESULT_UNSUP_HOST;



	size = PAGE_SIZE * 2;

	size = min(size, test->card->host->max_req_size);

	size = min(size, test->card->host->max_seg_size);

	size = min(size, test->card->host->max_blk_count * 512);



	if (size < 1024)

		return RESULT_UNSUP_HOST;



	ret = mmc_test_verified_transfer(test, 0, test->buffer, 0,

		size / 512, 512);

	if (ret)

		return ret;



	return 0;

}



static int mmc_test_pow2_write(struct mmc_test_card *test)

{

	int ret, i;



	if (!test->card->csd.write_partial)

		return RESULT_UNSUP_CARD;



	for (i = 1; i < 512;i <<= 1) {

		ret = mmc_test_verified_transfer(test, 1,

			test->buffer, 0, 1, i);

		if (ret)

			return ret;

	}



	return 0;

}



static int mmc_test_pow2_read(struct mmc_test_card *test)

{

	int ret, i;



	if (!test->card->csd.read_partial)

		return RESULT_UNSUP_CARD;



	for (i = 1; i < 512;i <<= 1) {

		ret = mmc_test_verified_transfer(test, 0,

			test->buffer, 0, 1, i);

		if (ret)

			return ret;

	}



	return 0;

}



static int mmc_test_weird_write(struct mmc_test_card *test)

{

	int ret, i;



	if (!test->card->csd.write_partial)

		return RESULT_UNSUP_CARD;



	for (i = 3; i < 512;i += 7) {

		ret = mmc_test_verified_transfer(test, 1,

			test->buffer, 0, 1, i);

		if (ret)

			return ret;

	}



	return 0;

}



static int mmc_test_weird_read(struct mmc_test_card *test)

{

	int ret, i;



	if (!test->card->csd.read_partial)

		return RESULT_UNSUP_CARD;



	for (i = 3; i < 512;i += 7) {

		ret = mmc_test_verified_transfer(test, 0,

			test->buffer, 0, 1, i);

		if (ret)

			return ret;

	}



	return 0;

}



static int mmc_test_align_write(struct mmc_test_card *test)

{

	int ret, i;



	for (i = 1;i < 4;i++) {

		ret = mmc_test_verified_transfer(test, 1, test->buffer + i,

			0, 1, 512);

		if (ret)

			return ret;

	}



	return 0;

}



static int mmc_test_align_read(struct mmc_test_card *test)

{

	int ret, i;



	for (i = 1;i < 4;i++) {

		ret = mmc_test_verified_transfer(test, 0, test->buffer + i,

			0, 1, 512);

		if (ret)

			return ret;

	}



	return 0;

}



static int mmc_test_align_multi_write(struct mmc_test_card *test)

{

	int ret, i;

	unsigned int size;



	if (test->card->host->max_blk_count == 1)

		return RESULT_UNSUP_HOST;



	size = PAGE_SIZE * 2;

	size = min(size, test->card->host->max_req_size);

	size = min(size, test->card->host->max_seg_size);

	size = min(size, test->card->host->max_blk_count * 512);



	if (size < 1024)

		return RESULT_UNSUP_HOST;



	for (i = 1;i < 4;i++) {

		ret = mmc_test_verified_transfer(test, 1, test->buffer + i,

			0, size / 512, 512);

		if (ret)

			return ret;

	}



	return 0;

}



static int mmc_test_align_multi_read(struct mmc_test_card *test)

{

	int ret, i;

	unsigned int size;



	if (test->card->host->max_blk_count == 1)

		return RESULT_UNSUP_HOST;



	size = PAGE_SIZE * 2;

	size = min(size, test->card->host->max_req_size);

	size = min(size, test->card->host->max_seg_size);

	size = min(size, test->card->host->max_blk_count * 512);



	if (size < 1024)

		return RESULT_UNSUP_HOST;



	for (i = 1;i < 4;i++) {

		ret = mmc_test_verified_transfer(test, 0, test->buffer + i,

			0, size / 512, 512);

		if (ret)

			return ret;

	}



	return 0;

}



static int mmc_test_xfersize_write(struct mmc_test_card *test)

{

	int ret;



	ret = mmc_test_set_blksize(test, 512);

	if (ret)

		return ret;



	ret = __mmc_test_transfer(test, 1, 1, test->buffer, 0, 1, 512);

	if (ret)

		return ret;



	return 0;

}



static int mmc_test_xfersize_read(struct mmc_test_card *test)

{

	int ret;



	ret = mmc_test_set_blksize(test, 512);

	if (ret)

		return ret;



	ret = __mmc_test_transfer(test, 0, 1, test->buffer, 0, 1, 512);

	if (ret)

		return ret;



	return 0;

}



static int mmc_test_multi_xfersize_write(struct mmc_test_card *test)

{

	int ret;



	if (test->card->host->max_blk_count == 1)

		return RESULT_UNSUP_HOST;



	ret = mmc_test_set_blksize(test, 512);

	if (ret)

		return ret;



	ret = __mmc_test_transfer(test, 1, 1, test->buffer, 0, 2, 512);

	if (ret)

		return ret;



	return 0;

}



static int mmc_test_multi_xfersize_read(struct mmc_test_card *test)

{

	int ret;



	if (test->card->host->max_blk_count == 1)

		return RESULT_UNSUP_HOST;



	ret = mmc_test_set_blksize(test, 512);

	if (ret)

		return ret;



	ret = __mmc_test_transfer(test, 0, 1, test->buffer, 0, 2, 512);

	if (ret)

		return ret;



	return 0;

}



static const struct mmc_test_case mmc_test_cases[] = {

	{

		.name = "Basic write (no data verification)",

		.run = mmc_test_basic_write,

	},



	{

		.name = "Basic read (no data verification)",

		.run = mmc_test_basic_read,

	},



	{

		.name = "Basic write (with data verification)",

		.prepare = mmc_test_prepare_verify_write,

		.run = mmc_test_verify_write,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Basic read (with data verification)",

		.prepare = mmc_test_prepare_verify_read,

		.run = mmc_test_verify_read,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Multi-block write",

		.prepare = mmc_test_prepare_verify_write,

		.run = mmc_test_multi_write,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Multi-block read",

		.prepare = mmc_test_prepare_verify_read,

		.run = mmc_test_multi_read,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Power of two block writes",

		.prepare = mmc_test_prepare_verify_write,

		.run = mmc_test_pow2_write,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Power of two block reads",

		.prepare = mmc_test_prepare_verify_read,

		.run = mmc_test_pow2_read,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Weird sized block writes",

		.prepare = mmc_test_prepare_verify_write,

		.run = mmc_test_weird_write,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Weird sized block reads",

		.prepare = mmc_test_prepare_verify_read,

		.run = mmc_test_weird_read,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Badly aligned write",

		.prepare = mmc_test_prepare_verify_write,

		.run = mmc_test_align_write,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Badly aligned read",

		.prepare = mmc_test_prepare_verify_read,

		.run = mmc_test_align_read,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Badly aligned multi-block write",

		.prepare = mmc_test_prepare_verify_write,

		.run = mmc_test_align_multi_write,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Badly aligned multi-block read",

		.prepare = mmc_test_prepare_verify_read,

		.run = mmc_test_align_multi_read,

		.cleanup = mmc_test_cleanup_verify,

	},



	{

		.name = "Correct xfer_size at write (start failure)",

		.run = mmc_test_xfersize_write,

	},



	{

		.name = "Correct xfer_size at read (start failure)",

		.run = mmc_test_xfersize_read,

	},



	{

		.name = "Correct xfer_size at write (midway failure)",

		.run = mmc_test_multi_xfersize_write,

	},



	{

		.name = "Correct xfer_size at read (midway failure)",

		.run = mmc_test_multi_xfersize_read,

	},

};



static struct mutex mmc_test_lock;



static void mmc_test_run(struct mmc_test_card *test)

{

	int i, ret;



	printk(KERN_INFO "%s: Starting tests of card %s...\n",

		mmc_hostname(test->card->host), mmc_card_id(test->card));



	mmc_claim_host(test->card->host);



	for (i = 0;i < ARRAY_SIZE(mmc_test_cases);i++) {

		printk(KERN_INFO "%s: Test case %d. %s...\n",

			mmc_hostname(test->card->host), i + 1,

			mmc_test_cases[i].name);



		if (mmc_test_cases[i].prepare) {

			ret = mmc_test_cases[i].prepare(test);

			if (ret) {

				printk(KERN_INFO "%s: Result: Prepare "

					"stage failed! (%d)\n",

					mmc_hostname(test->card->host),

					ret);

				continue;

			}

		}



		ret = mmc_test_cases[i].run(test);

		switch (ret) {

		case RESULT_OK:

			printk(KERN_INFO "%s: Result: OK\n",

				mmc_hostname(test->card->host));

			break;

		case RESULT_FAIL:

			printk(KERN_INFO "%s: Result: FAILED\n",

				mmc_hostname(test->card->host));

			break;

		case RESULT_UNSUP_HOST:

			printk(KERN_INFO "%s: Result: UNSUPPORTED "

				"(by host)\n",

				mmc_hostname(test->card->host));

			break;

		case RESULT_UNSUP_CARD:

			printk(KERN_INFO "%s: Result: UNSUPPORTED "

				"(by card)\n",

				mmc_hostname(test->card->host));

			break;

		default:

			printk(KERN_INFO "%s: Result: ERROR (%d)\n",

				mmc_hostname(test->card->host), ret);

		}



		if (mmc_test_cases[i].cleanup) {

			ret = mmc_test_cases[i].cleanup(test);

			if (ret) {

				printk(KERN_INFO "%s: Warning: Cleanup "

					"stage failed! (%d)\n",

					mmc_hostname(test->card->host),

					ret);

			}

		}

	}



	mmc_release_host(test->card->host);



	printk(KERN_INFO "%s: Tests completed.\n",

		mmc_hostname(test->card->host));

}



static ssize_t mmc_test_show(struct device *dev,

	struct device_attribute *attr, char *buf)

{

	mutex_lock(&mmc_test_lock);

	mutex_unlock(&mmc_test_lock);



	return 0;

}



static ssize_t mmc_test_store(struct device *dev,

	struct device_attribute *attr, const char *buf, size_t count)

{

	struct mmc_card *card;

	struct mmc_test_card *test;



	card = container_of(dev, struct mmc_card, dev);



	test = kzalloc(sizeof(struct mmc_test_card), GFP_KERNEL);

	if (!test)

		return -ENOMEM;



	test->card = card;



	test->buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL);

	if (test->buffer) {

		mutex_lock(&mmc_test_lock);

		mmc_test_run(test);

		mutex_unlock(&mmc_test_lock);

	}



	kfree(test->buffer);

	kfree(test);



	return count;

}



static DEVICE_ATTR(test, S_IWUSR | S_IRUGO, mmc_test_show, mmc_test_store);



static int mmc_test_probe(struct mmc_card *card)

{

	int ret;



	mutex_init(&mmc_test_lock);



	ret = device_create_file(&card->dev, &dev_attr_test);

	if (ret)

		return ret;



	return 0;

}



static void mmc_test_remove(struct mmc_card *card)

{

	device_remove_file(&card->dev, &dev_attr_test);

}



static struct mmc_driver mmc_driver = {

	.drv		= {

		.name	= "mmc_test",

	},

	.probe		= mmc_test_probe,

	.remove		= mmc_test_remove,

};



static int __init mmc_test_init(void)

{

	return mmc_register_driver(&mmc_driver);

}



static void __exit mmc_test_exit(void)

{

	mmc_unregister_driver(&mmc_driver);

}



module_init(mmc_test_init);

module_exit(mmc_test_exit);



MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Multimedia Card (MMC) host test driver");

MODULE_AUTHOR("Pierre Ossman");

drivers/mmc/host/at91_mci.c

+4 −1
Original line number Diff line number Diff line
@@ -663,9 +663,12 @@ static void at91_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) 
				gpio_set_value(host->board->vcc_pin, 0);

				break;

			case MMC_POWER_UP:

			case MMC_POWER_ON:

				gpio_set_value(host->board->vcc_pin, 1);

				break;

			case MMC_POWER_ON:

				break;

			default:

				WARN_ON(1);

		}

	}

}

drivers/mmc/host/omap.c

+6 −6
Original line number Diff line number Diff line
@@ -1003,7 +1003,7 @@ static void mmc_omap_dma_cb(int lch, u16 ch_status, void *data) 


static int mmc_omap_get_dma_channel(struct mmc_omap_host *host, struct mmc_data *data)

{

	const char *dev_name;

	const char *dma_dev_name;

	int sync_dev, dma_ch, is_read, r;



	is_read = !(data->flags & MMC_DATA_WRITE);
@@ -1018,21 +1018,21 @@ static int mmc_omap_get_dma_channel(struct mmc_omap_host *host, struct mmc_data 
	if (is_read) {

		if (host->id == 1) {

			sync_dev = OMAP_DMA_MMC_RX;

			dev_name = "MMC1 read";

			dma_dev_name = "MMC1 read";

		} else {

			sync_dev = OMAP_DMA_MMC2_RX;

			dev_name = "MMC2 read";

			dma_dev_name = "MMC2 read";

		}

	} else {

		if (host->id == 1) {

			sync_dev = OMAP_DMA_MMC_TX;

			dev_name = "MMC1 write";

			dma_dev_name = "MMC1 write";

		} else {

			sync_dev = OMAP_DMA_MMC2_TX;

			dev_name = "MMC2 write";

			dma_dev_name = "MMC2 write";

		}

	}

	r = omap_request_dma(sync_dev, dev_name, mmc_omap_dma_cb,

	r = omap_request_dma(sync_dev, dma_dev_name, mmc_omap_dma_cb,

			     host, &dma_ch);

	if (r != 0) {

		dev_dbg(mmc_dev(host->mmc), "omap_request_dma() failed with %d\n", r);