[mirror_ubuntu-artful-kernel.git] / drivers / mmc / card / queue.c

/*
 *  linux/drivers/mmc/queue.c
 *
 *  Copyright (C) 2003 Russell King, All Rights Reserved.
 *  Copyright 2006-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 version 2 as
 * published by the Free Software Foundation.
 *
 */
#include <linux/module.h>
#include <linux/blkdev.h>
#include <linux/freezer.h>
#include <linux/kthread.h>

#include <linux/mmc/card.h>
#include <linux/mmc/host.h>
#include "queue.h"

#define MMC_QUEUE_BOUNCESZ	65536

#define MMC_QUEUE_SUSPENDED	(1 << 0)

/*
 * Prepare a MMC request. This just filters out odd stuff.
 */
static int mmc_prep_request(struct request_queue *q, struct request *req)
{
	/*
	 * We only like normal block requests.
	 */
	if (!blk_fs_request(req) && !blk_pc_request(req)) {
		blk_dump_rq_flags(req, "MMC bad request");
		return BLKPREP_KILL;
	}

	req->cmd_flags |= REQ_DONTPREP;

	return BLKPREP_OK;
}

static int mmc_queue_thread(void *d)
{
	struct mmc_queue *mq = d;
	struct request_queue *q = mq->queue;

	current->flags |= PF_MEMALLOC;

	down(&mq->thread_sem);
	do {
		struct request *req = NULL;

		spin_lock_irq(q->queue_lock);
		set_current_state(TASK_INTERRUPTIBLE);
		if (!blk_queue_plugged(q))
			req = elv_next_request(q);
		mq->req = req;
		spin_unlock_irq(q->queue_lock);

		if (!req) {
			if (kthread_should_stop()) {
				set_current_state(TASK_RUNNING);
				break;
			}
			up(&mq->thread_sem);
			schedule();
			down(&mq->thread_sem);
			continue;
		}
		set_current_state(TASK_RUNNING);

		mq->issue_fn(mq, req);
	} while (1);
	up(&mq->thread_sem);

	return 0;
}

/*
 * Generic MMC request handler.  This is called for any queue on a
 * particular host.  When the host is not busy, we look for a request
 * on any queue on this host, and attempt to issue it.  This may
 * not be the queue we were asked to process.
 */
static void mmc_request(request_queue_t *q)
{
	struct mmc_queue *mq = q->queuedata;
	struct request *req;
	int ret;

	if (!mq) {
		printk(KERN_ERR "MMC: killing requests for dead queue\n");
		while ((req = elv_next_request(q)) != NULL) {
			do {
				ret = end_that_request_chunk(req, 0,
					req->current_nr_sectors << 9);
			} while (ret);
		}
		return;
	}

	if (!mq->req)
		wake_up_process(mq->thread);
}

/**
 * mmc_init_queue - initialise a queue structure.
 * @mq: mmc queue
 * @card: mmc card to attach this queue
 * @lock: queue lock
 *
 * Initialise a MMC card request queue.
 */
int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock)
{
	struct mmc_host *host = card->host;
	u64 limit = BLK_BOUNCE_HIGH;
	int ret;
	unsigned int bouncesz;

	if (mmc_dev(host)->dma_mask && *mmc_dev(host)->dma_mask)
		limit = *mmc_dev(host)->dma_mask;

	mq->card = card;
	mq->queue = blk_init_queue(mmc_request, lock);
	if (!mq->queue)
		return -ENOMEM;

	mq->queue->queuedata = mq;
	mq->req = NULL;

	blk_queue_prep_rq(mq->queue, mmc_prep_request);

#ifdef CONFIG_MMC_BLOCK_BOUNCE
	if (host->max_hw_segs == 1) {
		bouncesz = MMC_QUEUE_BOUNCESZ;

		if (bouncesz > host->max_req_size)
			bouncesz = host->max_req_size;
		if (bouncesz > host->max_seg_size)
			bouncesz = host->max_seg_size;

		mq->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
		if (!mq->bounce_buf) {
			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_max_sectors(mq->queue, bouncesz / 512);
			blk_queue_max_phys_segments(mq->queue, bouncesz / 512);
			blk_queue_max_hw_segments(mq->queue, bouncesz / 512);
			blk_queue_max_segment_size(mq->queue, bouncesz);

			mq->sg = kmalloc(sizeof(struct scatterlist),
				GFP_KERNEL);
			if (!mq->sg) {
				ret = -ENOMEM;
				goto free_bounce_buf;
			}

			mq->bounce_sg = kmalloc(sizeof(struct scatterlist) *
				bouncesz / 512, GFP_KERNEL);
			if (!mq->bounce_sg) {
				ret = -ENOMEM;
				goto free_sg;
			}
		}
	}
#endif

	if (!mq->bounce_buf) {
		blk_queue_bounce_limit(mq->queue, limit);
		blk_queue_max_sectors(mq->queue, host->max_req_size / 512);
		blk_queue_max_phys_segments(mq->queue, host->max_phys_segs);
		blk_queue_max_hw_segments(mq->queue, host->max_hw_segs);
		blk_queue_max_segment_size(mq->queue, host->max_seg_size);

		mq->sg = kmalloc(sizeof(struct scatterlist) *
			host->max_phys_segs, GFP_KERNEL);
		if (!mq->sg) {
			ret = -ENOMEM;
			goto cleanup_queue;
		}
	}

	init_MUTEX(&mq->thread_sem);

	mq->thread = kthread_run(mmc_queue_thread, mq, "mmcqd");
	if (IS_ERR(mq->thread)) {
		ret = PTR_ERR(mq->thread);
		goto free_bounce_sg;
	}

	return 0;
 free_bounce_sg:
 	if (mq->bounce_sg)
 		kfree(mq->bounce_sg);
 	mq->bounce_sg = NULL;
 free_sg:
	kfree(mq->sg);
	mq->sg = NULL;
 free_bounce_buf:
	if (mq->bounce_buf)
		kfree(mq->bounce_buf);
	mq->bounce_buf = NULL;
 cleanup_queue:
	blk_cleanup_queue(mq->queue);
	return ret;
}

void mmc_cleanup_queue(struct mmc_queue *mq)
{
	request_queue_t *q = mq->queue;
	unsigned long flags;

	/* Mark that we should start throwing out stragglers */
	spin_lock_irqsave(q->queue_lock, flags);
	q->queuedata = NULL;
	spin_unlock_irqrestore(q->queue_lock, flags);

	/* Make sure the queue isn't suspended, as that will deadlock */
	mmc_queue_resume(mq);

	/* Then terminate our worker thread */
	kthread_stop(mq->thread);

 	if (mq->bounce_sg)
 		kfree(mq->bounce_sg);
 	mq->bounce_sg = NULL;

	kfree(mq->sg);
	mq->sg = NULL;

	if (mq->bounce_buf)
		kfree(mq->bounce_buf);
	mq->bounce_buf = NULL;

	blk_cleanup_queue(mq->queue);

	mq->card = NULL;
}
EXPORT_SYMBOL(mmc_cleanup_queue);

/**
 * mmc_queue_suspend - suspend a MMC request queue
 * @mq: MMC queue to suspend
 *
 * Stop the block request queue, and wait for our thread to
 * complete any outstanding requests.  This ensures that we
 * won't suspend while a request is being processed.
 */
void mmc_queue_suspend(struct mmc_queue *mq)
{
	request_queue_t *q = mq->queue;
	unsigned long flags;

	if (!(mq->flags & MMC_QUEUE_SUSPENDED)) {
		mq->flags |= MMC_QUEUE_SUSPENDED;

		spin_lock_irqsave(q->queue_lock, flags);
		blk_stop_queue(q);
		spin_unlock_irqrestore(q->queue_lock, flags);

		down(&mq->thread_sem);
	}
}

/**
 * mmc_queue_resume - resume a previously suspended MMC request queue
 * @mq: MMC queue to resume
 */
void mmc_queue_resume(struct mmc_queue *mq)
{
	request_queue_t *q = mq->queue;
	unsigned long flags;

	if (mq->flags & MMC_QUEUE_SUSPENDED) {
		mq->flags &= ~MMC_QUEUE_SUSPENDED;

		up(&mq->thread_sem);

		spin_lock_irqsave(q->queue_lock, flags);
		blk_start_queue(q);
		spin_unlock_irqrestore(q->queue_lock, flags);
	}
}

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 = page_address(dst->page) + dst->offset;
			dst_size = dst->length;
		}

		if (src_size == 0) {
			src_buf = page_address(src->page) + src->offset;
			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--;
		}
	}
}

unsigned int mmc_queue_map_sg(struct mmc_queue *mq)
{
	unsigned int sg_len;

	if (!mq->bounce_buf)
		return blk_rq_map_sg(mq->queue, mq->req, mq->sg);

	BUG_ON(!mq->bounce_sg);

	sg_len = blk_rq_map_sg(mq->queue, mq->req, mq->bounce_sg);

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

	mq->sg[0].page = virt_to_page(mq->bounce_buf);
	mq->sg[0].offset = offset_in_page(mq->bounce_buf);
	mq->sg[0].length = 0;

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

	return 1;
}

void mmc_queue_bounce_pre(struct mmc_queue *mq)
{
	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);
}

void mmc_queue_bounce_post(struct mmc_queue *mq)
{
	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);
}
Commit	Line	Data
1da177e4	1	/*
98ac2162	2	* linux/drivers/mmc/queue.c
1da177e4 LT	3	*
1da177e4 LT	4	* Copyright (C) 2003 Russell King, All Rights Reserved.
98ac2162	5	* Copyright 2006-2007 Pierre Ossman
1da177e4 LT	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	*/
	12	#include <linux/module.h>
	13	#include <linux/blkdev.h>
83144186	14	#include <linux/freezer.h>
87598a2b	15	#include <linux/kthread.h>
1da177e4 LT	16
	17	#include <linux/mmc/card.h>
	18	#include <linux/mmc/host.h>
98ac2162	19	#include "queue.h"
1da177e4	20
98ccf149 PO	21	#define MMC_QUEUE_BOUNCESZ 65536
98ccf149 PO	22
87598a2b	23	#define MMC_QUEUE_SUSPENDED (1 << 0)
1da177e4 LT	24
1da177e4 LT	25	/*
9c9f2d63	26	* Prepare a MMC request. This just filters out odd stuff.
1da177e4 LT	27	*/
	28	static int mmc_prep_request(struct request_queue q, struct request req)
	29	{
9c9f2d63 PO	30	/*
	31	* We only like normal block requests.
	32	*/
	33	if (!blk_fs_request(req) && !blk_pc_request(req)) {
1da177e4	34	blk_dump_rq_flags(req, "MMC bad request");
9c9f2d63	35	return BLKPREP_KILL;
1da177e4 LT	36	}
1da177e4 LT	37
9c9f2d63	38	req->cmd_flags \|= REQ_DONTPREP;
1da177e4	39
9c9f2d63	40	return BLKPREP_OK;
1da177e4 LT	41	}
	42
	43	static int mmc_queue_thread(void *d)
	44	{
	45	struct mmc_queue *mq = d;
	46	struct request_queue *q = mq->queue;
1da177e4	47
83144186	48	current->flags \|= PF_MEMALLOC;
1da177e4	49
1da177e4	50	down(&mq->thread_sem);
1da177e4 LT	51	do {
	52	struct request *req = NULL;
	53
	54	spin_lock_irq(q->queue_lock);
	55	set_current_state(TASK_INTERRUPTIBLE);
	56	if (!blk_queue_plugged(q))
c723e08a JY	57	req = elv_next_request(q);
c723e08a JY	58	mq->req = req;
1da177e4 LT	59	spin_unlock_irq(q->queue_lock);
	60
	61	if (!req) {
7b30d281 VW	62	if (kthread_should_stop()) {
7b30d281 VW	63	set_current_state(TASK_RUNNING);
1da177e4	64	break;
7b30d281	65	}
1da177e4 LT	66	up(&mq->thread_sem);
	67	schedule();
	68	down(&mq->thread_sem);
	69	continue;
	70	}
	71	set_current_state(TASK_RUNNING);
	72
	73	mq->issue_fn(mq, req);
	74	} while (1);
1da177e4 LT	75	up(&mq->thread_sem);
1da177e4 LT	76
1da177e4 LT	77	return 0;
	78	}
	79
	80	/*
	81	* Generic MMC request handler. This is called for any queue on a
	82	* particular host. When the host is not busy, we look for a request
	83	* on any queue on this host, and attempt to issue it. This may
	84	* not be the queue we were asked to process.
	85	*/
	86	static void mmc_request(request_queue_t *q)
	87	{
	88	struct mmc_queue *mq = q->queuedata;
89b4e133 PO	89	struct request *req;
	90	int ret;
	91
	92	if (!mq) {
	93	printk(KERN_ERR "MMC: killing requests for dead queue\n");
	94	while ((req = elv_next_request(q)) != NULL) {
	95	do {
	96	ret = end_that_request_chunk(req, 0,
	97	req->current_nr_sectors << 9);
	98	} while (ret);
	99	}
	100	return;
	101	}
1da177e4 LT	102
1da177e4 LT	103	if (!mq->req)
87598a2b	104	wake_up_process(mq->thread);
1da177e4 LT	105	}
	106
	107	/**
	108	* mmc_init_queue - initialise a queue structure.
	109	* @mq: mmc queue
	110	* @card: mmc card to attach this queue
	111	* @lock: queue lock
	112	*
	113	* Initialise a MMC card request queue.
	114	*/
	115	int mmc_init_queue(struct mmc_queue mq, struct mmc_card card, spinlock_t *lock)
	116	{
	117	struct mmc_host *host = card->host;
	118	u64 limit = BLK_BOUNCE_HIGH;
	119	int ret;
98ccf149	120	unsigned int bouncesz;
1da177e4	121
fcaf71fd GKH	122	if (mmc_dev(host)->dma_mask && *mmc_dev(host)->dma_mask)
fcaf71fd GKH	123	limit = *mmc_dev(host)->dma_mask;
1da177e4 LT	124
	125	mq->card = card;
	126	mq->queue = blk_init_queue(mmc_request, lock);
	127	if (!mq->queue)
	128	return -ENOMEM;
	129
1da177e4 LT	130	mq->queue->queuedata = mq;
	131	mq->req = NULL;
	132
98ccf149 PO	133	blk_queue_prep_rq(mq->queue, mmc_prep_request);
	134
	135	#ifdef CONFIG_MMC_BLOCK_BOUNCE
	136	if (host->max_hw_segs == 1) {
	137	bouncesz = MMC_QUEUE_BOUNCESZ;
	138
	139	if (bouncesz > host->max_req_size)
	140	bouncesz = host->max_req_size;
	141	if (bouncesz > host->max_seg_size)
	142	bouncesz = host->max_seg_size;
	143
	144	mq->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
	145	if (!mq->bounce_buf) {
	146	printk(KERN_WARNING "%s: unable to allocate "
	147	"bounce buffer\n", mmc_card_name(card));
	148	} else {
	149	blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_HIGH);
	150	blk_queue_max_sectors(mq->queue, bouncesz / 512);
	151	blk_queue_max_phys_segments(mq->queue, bouncesz / 512);
	152	blk_queue_max_hw_segments(mq->queue, bouncesz / 512);
	153	blk_queue_max_segment_size(mq->queue, bouncesz);
	154
	155	mq->sg = kmalloc(sizeof(struct scatterlist),
	156	GFP_KERNEL);
	157	if (!mq->sg) {
	158	ret = -ENOMEM;
	159	goto free_bounce_buf;
	160	}
	161
	162	mq->bounce_sg = kmalloc(sizeof(struct scatterlist) *
	163	bouncesz / 512, GFP_KERNEL);
	164	if (!mq->bounce_sg) {
	165	ret = -ENOMEM;
	166	goto free_sg;
	167	}
	168	}
	169	}
	170	#endif
	171
	172	if (!mq->bounce_buf) {
	173	blk_queue_bounce_limit(mq->queue, limit);
	174	blk_queue_max_sectors(mq->queue, host->max_req_size / 512);
	175	blk_queue_max_phys_segments(mq->queue, host->max_phys_segs);
	176	blk_queue_max_hw_segments(mq->queue, host->max_hw_segs);
	177	blk_queue_max_segment_size(mq->queue, host->max_seg_size);
	178
	179	mq->sg = kmalloc(sizeof(struct scatterlist) *
	180	host->max_phys_segs, GFP_KERNEL);
	181	if (!mq->sg) {
	182	ret = -ENOMEM;
	183	goto cleanup_queue;
	184	}
1da177e4 LT	185	}
1da177e4 LT	186
1da177e4 LT	187	init_MUTEX(&mq->thread_sem);
1da177e4 LT	188
87598a2b CH	189	mq->thread = kthread_run(mmc_queue_thread, mq, "mmcqd");
	190	if (IS_ERR(mq->thread)) {
	191	ret = PTR_ERR(mq->thread);
98ccf149	192	goto free_bounce_sg;
1da177e4 LT	193	}
1da177e4 LT	194
87598a2b	195	return 0;
98ccf149 PO	196	free_bounce_sg:
	197	if (mq->bounce_sg)
	198	kfree(mq->bounce_sg);
	199	mq->bounce_sg = NULL;
87598a2b	200	free_sg:
1da177e4 LT	201	kfree(mq->sg);
1da177e4 LT	202	mq->sg = NULL;
98ccf149 PO	203	free_bounce_buf:
	204	if (mq->bounce_buf)
	205	kfree(mq->bounce_buf);
	206	mq->bounce_buf = NULL;
87598a2b	207	cleanup_queue:
1da177e4	208	blk_cleanup_queue(mq->queue);
1da177e4 LT	209	return ret;
1da177e4 LT	210	}
1da177e4 LT	211
	212	void mmc_cleanup_queue(struct mmc_queue *mq)
	213	{
89b4e133 PO	214	request_queue_t *q = mq->queue;
	215	unsigned long flags;
	216
	217	/* Mark that we should start throwing out stragglers */
	218	spin_lock_irqsave(q->queue_lock, flags);
	219	q->queuedata = NULL;
	220	spin_unlock_irqrestore(q->queue_lock, flags);
	221
d2b46f66 PO	222	/* Make sure the queue isn't suspended, as that will deadlock */
	223	mmc_queue_resume(mq);
	224
89b4e133	225	/* Then terminate our worker thread */
87598a2b	226	kthread_stop(mq->thread);
1da177e4	227
98ccf149 PO	228	if (mq->bounce_sg)
	229	kfree(mq->bounce_sg);
	230	mq->bounce_sg = NULL;
	231
1da177e4 LT	232	kfree(mq->sg);
	233	mq->sg = NULL;
	234
98ccf149 PO	235	if (mq->bounce_buf)
	236	kfree(mq->bounce_buf);
	237	mq->bounce_buf = NULL;
	238
1da177e4 LT	239	blk_cleanup_queue(mq->queue);
	240
	241	mq->card = NULL;
	242	}
	243	EXPORT_SYMBOL(mmc_cleanup_queue);
	244
	245	/**
	246	* mmc_queue_suspend - suspend a MMC request queue
	247	* @mq: MMC queue to suspend
	248	*
	249	* Stop the block request queue, and wait for our thread to
	250	* complete any outstanding requests. This ensures that we
	251	* won't suspend while a request is being processed.
	252	*/
	253	void mmc_queue_suspend(struct mmc_queue *mq)
	254	{
	255	request_queue_t *q = mq->queue;
	256	unsigned long flags;
	257
	258	if (!(mq->flags & MMC_QUEUE_SUSPENDED)) {
	259	mq->flags \|= MMC_QUEUE_SUSPENDED;
	260
	261	spin_lock_irqsave(q->queue_lock, flags);
	262	blk_stop_queue(q);
	263	spin_unlock_irqrestore(q->queue_lock, flags);
	264
	265	down(&mq->thread_sem);
	266	}
	267	}
1da177e4 LT	268
	269	/**
	270	* mmc_queue_resume - resume a previously suspended MMC request queue
	271	* @mq: MMC queue to resume
	272	*/
	273	void mmc_queue_resume(struct mmc_queue *mq)
	274	{
	275	request_queue_t *q = mq->queue;
	276	unsigned long flags;
	277
	278	if (mq->flags & MMC_QUEUE_SUSPENDED) {
	279	mq->flags &= ~MMC_QUEUE_SUSPENDED;
	280
	281	up(&mq->thread_sem);
	282
	283	spin_lock_irqsave(q->queue_lock, flags);
	284	blk_start_queue(q);
	285	spin_unlock_irqrestore(q->queue_lock, flags);
	286	}
	287	}
98ac2162	288
98ccf149 PO	289	static void copy_sg(struct scatterlist *dst, unsigned int dst_len,
	290	struct scatterlist *src, unsigned int src_len)
	291	{
	292	unsigned int chunk;
	293	char dst_buf, src_buf;
	294	unsigned int dst_size, src_size;
	295
	296	dst_buf = NULL;
	297	src_buf = NULL;
	298	dst_size = 0;
	299	src_size = 0;
	300
	301	while (src_len) {
	302	BUG_ON(dst_len == 0);
	303
	304	if (dst_size == 0) {
	305	dst_buf = page_address(dst->page) + dst->offset;
	306	dst_size = dst->length;
	307	}
	308
	309	if (src_size == 0) {
	310	src_buf = page_address(src->page) + src->offset;
	311	src_size = src->length;
	312	}
	313
	314	chunk = min(dst_size, src_size);
	315
	316	memcpy(dst_buf, src_buf, chunk);
	317
	318	dst_buf += chunk;
	319	src_buf += chunk;
	320	dst_size -= chunk;
	321	src_size -= chunk;
	322
	323	if (dst_size == 0) {
	324	dst++;
	325	dst_len--;
	326	}
	327
	328	if (src_size == 0) {
	329	src++;
	330	src_len--;
	331	}
	332	}
	333	}
	334
	335	unsigned int mmc_queue_map_sg(struct mmc_queue *mq)
	336	{
	337	unsigned int sg_len;
	338
	339	if (!mq->bounce_buf)
	340	return blk_rq_map_sg(mq->queue, mq->req, mq->sg);
	341
	342	BUG_ON(!mq->bounce_sg);
	343
	344	sg_len = blk_rq_map_sg(mq->queue, mq->req, mq->bounce_sg);
	345
	346	mq->bounce_sg_len = sg_len;
	347
	348	/*
	349	* Shortcut in the event we only get a single entry.
	350	*/
	351	if (sg_len == 1) {
	352	memcpy(mq->sg, mq->bounce_sg, sizeof(struct scatterlist));
353	return 1;
354	}
355
356	mq->sg[0].page = virt_to_page(mq->bounce_buf);
357	mq->sg[0].offset = offset_in_page(mq->bounce_buf);
358	mq->sg[0].length = 0;
359
360	while (sg_len) {
361	mq->sg[0].length += mq->bounce_sg[sg_len - 1].length;
362	sg_len--;
363	}
364
365	return 1;
366	}
367
368	void mmc_queue_bounce_pre(struct mmc_queue *mq)
369	{
370	if (!mq->bounce_buf)
371	return;
372
373	if (mq->bounce_sg_len == 1)
374	return;
375	if (rq_data_dir(mq->req) != WRITE)
376	return;
377
378	copy_sg(mq->sg, 1, mq->bounce_sg, mq->bounce_sg_len);
379	}
380
381	void mmc_queue_bounce_post(struct mmc_queue *mq)
382	{
383	if (!mq->bounce_buf)
384	return;
385
386	if (mq->bounce_sg_len == 1)
387	return;
388	if (rq_data_dir(mq->req) != READ)
389	return;
390
391	copy_sg(mq->bounce_sg, mq->bounce_sg_len, mq->sg, 1);
392	}
393