Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/drzeus/mmc (20b7997e) · Commits · 戴 / test

MAINTAINERS

+1 −4

Original line number	Diff line number	Diff line
		@@ -441,10 +441,7 @@ M: spyro@f2s.com
		S: Maintained

		ARM PRIMECELL MMCI PL180/1 DRIVER
		P: Russell King
		M: rmk@arm.linux.org.uk
		L: linux-arm-kernel@lists.arm.linux.org.uk (subscribers-only)
		S: Maintained
		S: Orphan

		ARM/ADI ROADRUNNER MACHINE SUPPORT
		P: Lennert Buytenhek

drivers/mmc/card/mmc_test.c

+221 −4

Original line number	Diff line number	Diff line
		@@ -21,13 +21,17 @@
		#define RESULT_UNSUP_HOST 2
		#define RESULT_UNSUP_CARD 3

		#define BUFFER_SIZE (PAGE_SIZE * 4)
		#define BUFFER_ORDER 2
		#define BUFFER_SIZE (PAGE_SIZE << BUFFER_ORDER)

		struct mmc_test_card {
		struct mmc_card *card;

		u8 scratch[BUFFER_SIZE];
		u8 *buffer;
		#ifdef CONFIG_HIGHMEM
		struct page *highmem;
		#endif
		};

		/*******************************************************************/
		@@ -384,14 +388,16 @@ static int mmc_test_transfer(struct mmc_test_card *test,
		int ret, i;
		unsigned long flags;

		BUG_ON(blocks * blksz > BUFFER_SIZE);

		if (write) {
		for (i = 0;i < blocks * blksz;i++)
		test->scratch[i] = i;
		} else {
		memset(test->scratch, 0, BUFFER_SIZE);
		memset(test->scratch, 0, blocks * blksz);
		}
		local_irq_save(flags);
		sg_copy_from_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
		sg_copy_from_buffer(sg, sg_len, test->scratch, blocks * blksz);
		local_irq_restore(flags);

		ret = mmc_test_set_blksize(test, blksz);
		@@ -438,7 +444,7 @@ static int mmc_test_transfer(struct mmc_test_card *test,
		}
		} else {
		local_irq_save(flags);
		sg_copy_to_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
		sg_copy_to_buffer(sg, sg_len, test->scratch, blocks * blksz);
		local_irq_restore(flags);
		for (i = 0;i < blocks * blksz;i++) {
		if (test->scratch[i] != (u8)i)
		@@ -799,6 +805,157 @@ static int mmc_test_multi_xfersize_read(struct mmc_test_card *test)
		return 0;
		}

		static int mmc_test_bigsg_write(struct mmc_test_card *test)
		{
		int ret;
		unsigned int size;
		struct scatterlist sg;

		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);

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

		if (size < 1024)
		return RESULT_UNSUP_HOST;

		sg_init_table(&sg, 1);
		sg_init_one(&sg, test->buffer, BUFFER_SIZE);

		ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
		if (ret)
		return ret;

		return 0;
		}

		static int mmc_test_bigsg_read(struct mmc_test_card *test)
		{
		int ret, i;
		unsigned int size;
		struct scatterlist sg;

		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;

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

		sg_init_table(&sg, 1);
		sg_init_one(&sg, test->buffer, BUFFER_SIZE);
		ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
		if (ret)
		return ret;

		/* mmc_test_transfer() doesn't check for read overflows */
		for (i = size;i < BUFFER_SIZE;i++) {
		if (test->buffer[i] != 0xCD)
		return RESULT_FAIL;
		}

		return 0;
		}

		#ifdef CONFIG_HIGHMEM

		static int mmc_test_write_high(struct mmc_test_card *test)
		{
		int ret;
		struct scatterlist sg;

		sg_init_table(&sg, 1);
		sg_set_page(&sg, test->highmem, 512, 0);

		ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
		if (ret)
		return ret;

		return 0;
		}

		static int mmc_test_read_high(struct mmc_test_card *test)
		{
		int ret;
		struct scatterlist sg;

		sg_init_table(&sg, 1);
		sg_set_page(&sg, test->highmem, 512, 0);

		ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
		if (ret)
		return ret;

		return 0;
		}

		static int mmc_test_multi_write_high(struct mmc_test_card *test)
		{
		int ret;
		unsigned int size;
		struct scatterlist sg;

		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;

		sg_init_table(&sg, 1);
		sg_set_page(&sg, test->highmem, size, 0);

		ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
		if (ret)
		return ret;

		return 0;
		}

		static int mmc_test_multi_read_high(struct mmc_test_card *test)
		{
		int ret;
		unsigned int size;
		struct scatterlist sg;

		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;

		sg_init_table(&sg, 1);
		sg_set_page(&sg, test->highmem, size, 0);

		ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
		if (ret)
		return ret;

		return 0;
		}

		#endif /* CONFIG_HIGHMEM */

		static const struct mmc_test_case mmc_test_cases[] = {
		{
		.name = "Basic write (no data verification)",
		@@ -913,6 +1070,53 @@ static const struct mmc_test_case mmc_test_cases[] = {
		.name = "Correct xfer_size at read (midway failure)",
		.run = mmc_test_multi_xfersize_read,
		},

		{
		.name = "Over-sized SG list write",
		.prepare = mmc_test_prepare_write,
		.run = mmc_test_bigsg_write,
		.cleanup = mmc_test_cleanup,
		},

		{
		.name = "Over-sized SG list read",
		.prepare = mmc_test_prepare_read,
		.run = mmc_test_bigsg_read,
		.cleanup = mmc_test_cleanup,
		},

		#ifdef CONFIG_HIGHMEM

		{
		.name = "Highmem write",
		.prepare = mmc_test_prepare_write,
		.run = mmc_test_write_high,
		.cleanup = mmc_test_cleanup,
		},

		{
		.name = "Highmem read",
		.prepare = mmc_test_prepare_read,
		.run = mmc_test_read_high,
		.cleanup = mmc_test_cleanup,
		},

		{
		.name = "Multi-block highmem write",
		.prepare = mmc_test_prepare_write,
		.run = mmc_test_multi_write_high,
		.cleanup = mmc_test_cleanup,
		},

		{
		.name = "Multi-block highmem read",
		.prepare = mmc_test_prepare_read,
		.run = mmc_test_multi_read_high,
		.cleanup = mmc_test_cleanup,
		},

		#endif /* CONFIG_HIGHMEM */

		};

		static struct mutex mmc_test_lock;
		@@ -1014,12 +1218,23 @@ static ssize_t mmc_test_store(struct device *dev,
		test->card = card;

		test->buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL);
		#ifdef CONFIG_HIGHMEM
		test->highmem = alloc_pages(GFP_KERNEL \| __GFP_HIGHMEM, BUFFER_ORDER);
		#endif

		#ifdef CONFIG_HIGHMEM
		if (test->buffer && test->highmem) {
		#else
		if (test->buffer) {
		#endif
		mutex_lock(&mmc_test_lock);
		mmc_test_run(test, testcase);
		mutex_unlock(&mmc_test_lock);
		}

		#ifdef CONFIG_HIGHMEM
		__free_pages(test->highmem, BUFFER_ORDER);
		#endif
		kfree(test->buffer);
		kfree(test);

		@@ -1041,6 +1256,8 @@ static int mmc_test_probe(struct mmc_card *card)
		if (ret)
		return ret;

		dev_info(&card->dev, "Card claimed for testing.\n");

		return 0;
		}

drivers/mmc/card/queue.c

+31 −66

Original line number	Diff line number	Diff line
		@@ -148,7 +148,7 @@ int mmc_init_queue(struct mmc_queue mq, struct mmc_card card, spinlock_t *lock
		printk(KERN_WARNING "%s: unable to allocate "
		"bounce buffer\n", mmc_card_name(card));
		} else {
		blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_HIGH);
		blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_ANY);
		blk_queue_max_sectors(mq->queue, bouncesz / 512);
		blk_queue_max_phys_segments(mq->queue, bouncesz / 512);
		blk_queue_max_hw_segments(mq->queue, bouncesz / 512);
		@@ -290,55 +290,15 @@ void mmc_queue_resume(struct mmc_queue *mq)
		}
		}

		static void copy_sg(struct scatterlist *dst, unsigned int dst_len,
		struct scatterlist *src, unsigned int src_len)
		{
		unsigned int chunk;
		char dst_buf, src_buf;
		unsigned int dst_size, src_size;

		dst_buf = NULL;
		src_buf = NULL;
		dst_size = 0;
		src_size = 0;

		while (src_len) {
		BUG_ON(dst_len == 0);

		if (dst_size == 0) {
		dst_buf = sg_virt(dst);
		dst_size = dst->length;
		}

		if (src_size == 0) {
		src_buf = sg_virt(src);
		src_size = src->length;
		}

		chunk = min(dst_size, src_size);

		memcpy(dst_buf, src_buf, chunk);

		dst_buf += chunk;
		src_buf += chunk;
		dst_size -= chunk;
		src_size -= chunk;

		if (dst_size == 0) {
		dst++;
		dst_len--;
		}

		if (src_size == 0) {
		src++;
		src_len--;
		}
		}
		}

		/*
		* Prepare the sg list(s) to be handed of to the host driver
		*/
		unsigned int mmc_queue_map_sg(struct mmc_queue *mq)
		{
		unsigned int sg_len;
		size_t buflen;
		struct scatterlist *sg;
		int i;

		if (!mq->bounce_buf)
		return blk_rq_map_sg(mq->queue, mq->req, mq->sg);
		@@ -349,47 +309,52 @@ unsigned int mmc_queue_map_sg(struct mmc_queue *mq)

		mq->bounce_sg_len = sg_len;

		/*
		* Shortcut in the event we only get a single entry.
		*/
		if (sg_len == 1) {
		memcpy(mq->sg, mq->bounce_sg, sizeof(struct scatterlist));
		return 1;
		}
		buflen = 0;
		for_each_sg(mq->bounce_sg, sg, sg_len, i)
		buflen += sg->length;

		sg_init_one(mq->sg, mq->bounce_buf, 0);

		while (sg_len) {
		mq->sg[0].length += mq->bounce_sg[sg_len - 1].length;
		sg_len--;
		}
		sg_init_one(mq->sg, mq->bounce_buf, buflen);

		return 1;
		}

		/*
		* If writing, bounce the data to the buffer before the request
		* is sent to the host driver
		*/
		void mmc_queue_bounce_pre(struct mmc_queue *mq)
		{
		unsigned long flags;

		if (!mq->bounce_buf)
		return;

		if (mq->bounce_sg_len == 1)
		return;
		if (rq_data_dir(mq->req) != WRITE)
		return;

		copy_sg(mq->sg, 1, mq->bounce_sg, mq->bounce_sg_len);
		local_irq_save(flags);
		sg_copy_to_buffer(mq->bounce_sg, mq->bounce_sg_len,
		mq->bounce_buf, mq->sg[0].length);
		local_irq_restore(flags);
		}

		/*
		* If reading, bounce the data from the buffer after the request
		* has been handled by the host driver
		*/
		void mmc_queue_bounce_post(struct mmc_queue *mq)
		{
		unsigned long flags;

		if (!mq->bounce_buf)
		return;

		if (mq->bounce_sg_len == 1)
		return;
		if (rq_data_dir(mq->req) != READ)
		return;

		copy_sg(mq->bounce_sg, mq->bounce_sg_len, mq->sg, 1);
		local_irq_save(flags);
		sg_copy_from_buffer(mq->bounce_sg, mq->bounce_sg_len,
		mq->bounce_buf, mq->sg[0].length);
		local_irq_restore(flags);
		}

drivers/mmc/host/au1xmmc.c

+42 −12

Original line number	Diff line number	Diff line
		@@ -1043,7 +1043,7 @@ static int __devinit au1xmmc_probe(struct platform_device *pdev)
		goto out6;
		}

		platform_set_drvdata(pdev, mmc);
		platform_set_drvdata(pdev, host);

		printk(KERN_INFO DRIVER_NAME ": MMC Controller %d set up at %8.8X"
		" (mode=%s)\n", pdev->id, host->iobase,
		@@ -1087,13 +1087,10 @@ out0:

		static int __devexit au1xmmc_remove(struct platform_device *pdev)
		{
		struct mmc_host *mmc = platform_get_drvdata(pdev);
		struct au1xmmc_host *host;

		if (mmc) {
		host = mmc_priv(mmc);
		struct au1xmmc_host *host = platform_get_drvdata(pdev);

		mmc_remove_host(mmc);
		if (host) {
		mmc_remove_host(host->mmc);

		#ifdef CONFIG_LEDS_CLASS
		if (host->platdata && host->platdata->led)
		@@ -1101,8 +1098,8 @@ static int __devexit au1xmmc_remove(struct platform_device *pdev)
		#endif

		if (host->platdata && host->platdata->cd_setup &&
		!(mmc->caps & MMC_CAP_NEEDS_POLL))
		host->platdata->cd_setup(mmc, 0);
		!(host->mmc->caps & MMC_CAP_NEEDS_POLL))
		host->platdata->cd_setup(host->mmc, 0);

		au_writel(0, HOST_ENABLE(host));
		au_writel(0, HOST_CONFIG(host));
		@@ -1122,16 +1119,49 @@ static int __devexit au1xmmc_remove(struct platform_device *pdev)
		release_resource(host->ioarea);
		kfree(host->ioarea);

		mmc_free_host(mmc);
		mmc_free_host(host->mmc);
		platform_set_drvdata(pdev, NULL);
		}
		return 0;
		}

		#ifdef CONFIG_PM
		static int au1xmmc_suspend(struct platform_device *pdev, pm_message_t state)
		{
		struct au1xmmc_host *host = platform_get_drvdata(pdev);
		int ret;

		ret = mmc_suspend_host(host->mmc, state);
		if (ret)
		return ret;

		au_writel(0, HOST_CONFIG2(host));
		au_writel(0, HOST_CONFIG(host));
		au_writel(0xffffffff, HOST_STATUS(host));
		au_writel(0, HOST_ENABLE(host));
		au_sync();

		return 0;
		}

		static int au1xmmc_resume(struct platform_device *pdev)
		{
		struct au1xmmc_host *host = platform_get_drvdata(pdev);

		au1xmmc_reset_controller(host);

		return mmc_resume_host(host->mmc);
		}
		#else
		#define au1xmmc_suspend NULL
		#define au1xmmc_resume NULL
		#endif

		static struct platform_driver au1xmmc_driver = {
		.probe = au1xmmc_probe,
		.remove = au1xmmc_remove,
		.suspend = NULL,
		.resume = NULL,
		.suspend = au1xmmc_suspend,
		.resume = au1xmmc_resume,
		.driver = {
		.name = DRIVER_NAME,
		.owner = THIS_MODULE,

drivers/mmc/host/pxamci.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -177,7 +177,7 @@ static void pxamci_setup_data(struct pxamci_host host, struct mmc_data data)
		if (dalgn)
		DALGN \|= (1 << host->dma);
		else
		DALGN &= (1 << host->dma);
		DALGN &= ~(1 << host->dma);
		DDADR(host->dma) = host->sg_dma;
		DCSR(host->dma) = DCSR_RUN;
		}

Admin message