blob: 3dee97e7d165f3e64f3898b1fb84c335cc4a1f08 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Pierre Ossman70f10482007-07-11 20:04:50 +02002 * linux/drivers/mmc/card/queue.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Copyright (C) 2003 Russell King, All Rights Reserved.
Pierre Ossman98ac2162006-12-23 20:03:02 +01005 * Copyright 2006-2007 Pierre Ossman
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
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>
Rafael J. Wysocki83144182007-07-17 04:03:35 -070014#include <linux/freezer.h>
Christoph Hellwig87598a22006-11-13 20:23:52 +010015#include <linux/kthread.h>
Jens Axboe45711f12007-10-22 21:19:53 +020016#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
18#include <linux/mmc/card.h>
19#include <linux/mmc/host.h>
Pierre Ossman98ac2162006-12-23 20:03:02 +010020#include "queue.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Pierre Ossman98ccf142007-05-12 00:26:16 +020022#define MMC_QUEUE_BOUNCESZ 65536
23
Christoph Hellwig87598a22006-11-13 20:23:52 +010024#define MMC_QUEUE_SUSPENDED (1 << 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26/*
Pierre Ossman9c9f2d62007-05-16 17:29:21 +020027 * Prepare a MMC request. This just filters out odd stuff.
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 */
29static int mmc_prep_request(struct request_queue *q, struct request *req)
30{
Pierre Ossman9c9f2d62007-05-16 17:29:21 +020031 /*
32 * We only like normal block requests.
33 */
34 if (!blk_fs_request(req) && !blk_pc_request(req)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 blk_dump_rq_flags(req, "MMC bad request");
Pierre Ossman9c9f2d62007-05-16 17:29:21 +020036 return BLKPREP_KILL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 }
38
Pierre Ossman9c9f2d62007-05-16 17:29:21 +020039 req->cmd_flags |= REQ_DONTPREP;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Pierre Ossman9c9f2d62007-05-16 17:29:21 +020041 return BLKPREP_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042}
43
44static int mmc_queue_thread(void *d)
45{
46 struct mmc_queue *mq = d;
47 struct request_queue *q = mq->queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Rafael J. Wysocki83144182007-07-17 04:03:35 -070049 current->flags |= PF_MEMALLOC;
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 down(&mq->thread_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 do {
53 struct request *req = NULL;
54
55 spin_lock_irq(q->queue_lock);
56 set_current_state(TASK_INTERRUPTIBLE);
57 if (!blk_queue_plugged(q))
Juha [êöläc723e08a2006-08-06 09:58:22 +010058 req = elv_next_request(q);
59 mq->req = req;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 spin_unlock_irq(q->queue_lock);
61
62 if (!req) {
Vitaly Wool7b30d282006-12-07 20:08:02 +010063 if (kthread_should_stop()) {
64 set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 break;
Vitaly Wool7b30d282006-12-07 20:08:02 +010066 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 up(&mq->thread_sem);
68 schedule();
69 down(&mq->thread_sem);
70 continue;
71 }
72 set_current_state(TASK_RUNNING);
73
74 mq->issue_fn(mq, req);
75 } while (1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 up(&mq->thread_sem);
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 return 0;
79}
80
81/*
82 * Generic MMC request handler. This is called for any queue on a
83 * particular host. When the host is not busy, we look for a request
84 * on any queue on this host, and attempt to issue it. This may
85 * not be the queue we were asked to process.
86 */
Jens Axboe165125e2007-07-24 09:28:11 +020087static void mmc_request(struct request_queue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -070088{
89 struct mmc_queue *mq = q->queuedata;
Pierre Ossman89b4e132006-11-14 22:08:16 +010090 struct request *req;
91 int ret;
92
93 if (!mq) {
94 printk(KERN_ERR "MMC: killing requests for dead queue\n");
95 while ((req = elv_next_request(q)) != NULL) {
96 do {
Kiyoshi Uedafd539832007-12-11 17:48:29 -050097 ret = __blk_end_request(req, -EIO,
98 blk_rq_cur_bytes(req));
Pierre Ossman89b4e132006-11-14 22:08:16 +010099 } while (ret);
100 }
101 return;
102 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
104 if (!mq->req)
Christoph Hellwig87598a22006-11-13 20:23:52 +0100105 wake_up_process(mq->thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106}
107
108/**
109 * mmc_init_queue - initialise a queue structure.
110 * @mq: mmc queue
111 * @card: mmc card to attach this queue
112 * @lock: queue lock
113 *
114 * Initialise a MMC card request queue.
115 */
116int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock)
117{
118 struct mmc_host *host = card->host;
119 u64 limit = BLK_BOUNCE_HIGH;
120 int ret;
121
Greg Kroah-Hartmanfcaf71f2006-09-12 17:00:10 +0200122 if (mmc_dev(host)->dma_mask && *mmc_dev(host)->dma_mask)
123 limit = *mmc_dev(host)->dma_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
125 mq->card = card;
126 mq->queue = blk_init_queue(mmc_request, lock);
127 if (!mq->queue)
128 return -ENOMEM;
129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 mq->queue->queuedata = mq;
131 mq->req = NULL;
132
Pierre Ossman98ccf142007-05-12 00:26:16 +0200133 blk_queue_prep_rq(mq->queue, mmc_prep_request);
134
135#ifdef CONFIG_MMC_BLOCK_BOUNCE
136 if (host->max_hw_segs == 1) {
Pierre Ossmanaafabfa2007-08-09 14:28:02 +0200137 unsigned int bouncesz;
138
Pierre Ossman98ccf142007-05-12 00:26:16 +0200139 bouncesz = MMC_QUEUE_BOUNCESZ;
140
141 if (bouncesz > host->max_req_size)
142 bouncesz = host->max_req_size;
143 if (bouncesz > host->max_seg_size)
144 bouncesz = host->max_seg_size;
145
146 mq->bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
147 if (!mq->bounce_buf) {
148 printk(KERN_WARNING "%s: unable to allocate "
149 "bounce buffer\n", mmc_card_name(card));
150 } else {
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200151 blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_ANY);
Pierre Ossman98ccf142007-05-12 00:26:16 +0200152 blk_queue_max_sectors(mq->queue, bouncesz / 512);
153 blk_queue_max_phys_segments(mq->queue, bouncesz / 512);
154 blk_queue_max_hw_segments(mq->queue, bouncesz / 512);
155 blk_queue_max_segment_size(mq->queue, bouncesz);
156
Jens Axboe45711f12007-10-22 21:19:53 +0200157 mq->sg = kmalloc(sizeof(struct scatterlist),
Pierre Ossman98ccf142007-05-12 00:26:16 +0200158 GFP_KERNEL);
159 if (!mq->sg) {
160 ret = -ENOMEM;
Pierre Ossmanaafabfa2007-08-09 14:28:02 +0200161 goto cleanup_queue;
Pierre Ossman98ccf142007-05-12 00:26:16 +0200162 }
Jens Axboe45711f12007-10-22 21:19:53 +0200163 sg_init_table(mq->sg, 1);
Pierre Ossman98ccf142007-05-12 00:26:16 +0200164
Jens Axboe45711f12007-10-22 21:19:53 +0200165 mq->bounce_sg = kmalloc(sizeof(struct scatterlist) *
Pierre Ossman98ccf142007-05-12 00:26:16 +0200166 bouncesz / 512, GFP_KERNEL);
167 if (!mq->bounce_sg) {
168 ret = -ENOMEM;
Pierre Ossmanaafabfa2007-08-09 14:28:02 +0200169 goto cleanup_queue;
Pierre Ossman98ccf142007-05-12 00:26:16 +0200170 }
Jens Axboe45711f12007-10-22 21:19:53 +0200171 sg_init_table(mq->bounce_sg, bouncesz / 512);
Pierre Ossman98ccf142007-05-12 00:26:16 +0200172 }
173 }
174#endif
175
176 if (!mq->bounce_buf) {
177 blk_queue_bounce_limit(mq->queue, limit);
178 blk_queue_max_sectors(mq->queue, host->max_req_size / 512);
179 blk_queue_max_phys_segments(mq->queue, host->max_phys_segs);
180 blk_queue_max_hw_segments(mq->queue, host->max_hw_segs);
181 blk_queue_max_segment_size(mq->queue, host->max_seg_size);
182
Haavard Skinnemoen05e5b132007-11-23 10:19:00 +0100183 mq->sg = kmalloc(sizeof(struct scatterlist) *
Pierre Ossman98ccf142007-05-12 00:26:16 +0200184 host->max_phys_segs, GFP_KERNEL);
185 if (!mq->sg) {
186 ret = -ENOMEM;
187 goto cleanup_queue;
188 }
Haavard Skinnemoen05e5b132007-11-23 10:19:00 +0100189 sg_init_table(mq->sg, host->max_phys_segs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 }
191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 init_MUTEX(&mq->thread_sem);
193
Christoph Hellwig87598a22006-11-13 20:23:52 +0100194 mq->thread = kthread_run(mmc_queue_thread, mq, "mmcqd");
195 if (IS_ERR(mq->thread)) {
196 ret = PTR_ERR(mq->thread);
Pierre Ossman98ccf142007-05-12 00:26:16 +0200197 goto free_bounce_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 }
199
Christoph Hellwig87598a22006-11-13 20:23:52 +0100200 return 0;
Pierre Ossman98ccf142007-05-12 00:26:16 +0200201 free_bounce_sg:
202 if (mq->bounce_sg)
203 kfree(mq->bounce_sg);
204 mq->bounce_sg = NULL;
Pierre Ossmanaafabfa2007-08-09 14:28:02 +0200205 cleanup_queue:
206 if (mq->sg)
207 kfree(mq->sg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 mq->sg = NULL;
Pierre Ossman98ccf142007-05-12 00:26:16 +0200209 if (mq->bounce_buf)
210 kfree(mq->bounce_buf);
211 mq->bounce_buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 blk_cleanup_queue(mq->queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 return ret;
214}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216void mmc_cleanup_queue(struct mmc_queue *mq)
217{
Jens Axboe165125e2007-07-24 09:28:11 +0200218 struct request_queue *q = mq->queue;
Pierre Ossman89b4e132006-11-14 22:08:16 +0100219 unsigned long flags;
220
221 /* Mark that we should start throwing out stragglers */
222 spin_lock_irqsave(q->queue_lock, flags);
223 q->queuedata = NULL;
224 spin_unlock_irqrestore(q->queue_lock, flags);
225
Pierre Ossmand2b46f62007-04-28 16:52:12 +0200226 /* Make sure the queue isn't suspended, as that will deadlock */
227 mmc_queue_resume(mq);
228
Pierre Ossman89b4e132006-11-14 22:08:16 +0100229 /* Then terminate our worker thread */
Christoph Hellwig87598a22006-11-13 20:23:52 +0100230 kthread_stop(mq->thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Pierre Ossman98ccf142007-05-12 00:26:16 +0200232 if (mq->bounce_sg)
233 kfree(mq->bounce_sg);
234 mq->bounce_sg = NULL;
235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 kfree(mq->sg);
237 mq->sg = NULL;
238
Pierre Ossman98ccf142007-05-12 00:26:16 +0200239 if (mq->bounce_buf)
240 kfree(mq->bounce_buf);
241 mq->bounce_buf = NULL;
242
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 blk_cleanup_queue(mq->queue);
244
245 mq->card = NULL;
246}
247EXPORT_SYMBOL(mmc_cleanup_queue);
248
249/**
250 * mmc_queue_suspend - suspend a MMC request queue
251 * @mq: MMC queue to suspend
252 *
253 * Stop the block request queue, and wait for our thread to
254 * complete any outstanding requests. This ensures that we
255 * won't suspend while a request is being processed.
256 */
257void mmc_queue_suspend(struct mmc_queue *mq)
258{
Jens Axboe165125e2007-07-24 09:28:11 +0200259 struct request_queue *q = mq->queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 unsigned long flags;
261
262 if (!(mq->flags & MMC_QUEUE_SUSPENDED)) {
263 mq->flags |= MMC_QUEUE_SUSPENDED;
264
265 spin_lock_irqsave(q->queue_lock, flags);
266 blk_stop_queue(q);
267 spin_unlock_irqrestore(q->queue_lock, flags);
268
269 down(&mq->thread_sem);
270 }
271}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
273/**
274 * mmc_queue_resume - resume a previously suspended MMC request queue
275 * @mq: MMC queue to resume
276 */
277void mmc_queue_resume(struct mmc_queue *mq)
278{
Jens Axboe165125e2007-07-24 09:28:11 +0200279 struct request_queue *q = mq->queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 unsigned long flags;
281
282 if (mq->flags & MMC_QUEUE_SUSPENDED) {
283 mq->flags &= ~MMC_QUEUE_SUSPENDED;
284
285 up(&mq->thread_sem);
286
287 spin_lock_irqsave(q->queue_lock, flags);
288 blk_start_queue(q);
289 spin_unlock_irqrestore(q->queue_lock, flags);
290 }
291}
Pierre Ossman98ac2162006-12-23 20:03:02 +0100292
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200293/*
294 * Prepare the sg list(s) to be handed of to the host driver
295 */
Pierre Ossman98ccf142007-05-12 00:26:16 +0200296unsigned int mmc_queue_map_sg(struct mmc_queue *mq)
297{
298 unsigned int sg_len;
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200299 size_t buflen;
300 struct scatterlist *sg;
301 int i;
Pierre Ossman98ccf142007-05-12 00:26:16 +0200302
303 if (!mq->bounce_buf)
304 return blk_rq_map_sg(mq->queue, mq->req, mq->sg);
305
306 BUG_ON(!mq->bounce_sg);
307
308 sg_len = blk_rq_map_sg(mq->queue, mq->req, mq->bounce_sg);
309
310 mq->bounce_sg_len = sg_len;
311
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200312 buflen = 0;
313 for_each_sg(mq->bounce_sg, sg, sg_len, i)
314 buflen += sg->length;
Pierre Ossman98ccf142007-05-12 00:26:16 +0200315
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200316 sg_init_one(mq->sg, mq->bounce_buf, buflen);
Pierre Ossman98ccf142007-05-12 00:26:16 +0200317
318 return 1;
319}
320
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200321/*
322 * If writing, bounce the data to the buffer before the request
323 * is sent to the host driver
324 */
Pierre Ossman98ccf142007-05-12 00:26:16 +0200325void mmc_queue_bounce_pre(struct mmc_queue *mq)
326{
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200327 unsigned long flags;
328
Pierre Ossman98ccf142007-05-12 00:26:16 +0200329 if (!mq->bounce_buf)
330 return;
331
Pierre Ossman98ccf142007-05-12 00:26:16 +0200332 if (rq_data_dir(mq->req) != WRITE)
333 return;
334
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200335 local_irq_save(flags);
336 sg_copy_to_buffer(mq->bounce_sg, mq->bounce_sg_len,
337 mq->bounce_buf, mq->sg[0].length);
338 local_irq_restore(flags);
Pierre Ossman98ccf142007-05-12 00:26:16 +0200339}
340
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200341/*
342 * If reading, bounce the data from the buffer after the request
343 * has been handled by the host driver
344 */
Pierre Ossman98ccf142007-05-12 00:26:16 +0200345void mmc_queue_bounce_post(struct mmc_queue *mq)
346{
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200347 unsigned long flags;
348
Pierre Ossman98ccf142007-05-12 00:26:16 +0200349 if (!mq->bounce_buf)
350 return;
351
Pierre Ossman98ccf142007-05-12 00:26:16 +0200352 if (rq_data_dir(mq->req) != READ)
353 return;
354
Pierre Ossman2ff1fa62008-07-22 14:35:42 +0200355 local_irq_save(flags);
356 sg_copy_from_buffer(mq->bounce_sg, mq->bounce_sg_len,
357 mq->bounce_buf, mq->sg[0].length);
358 local_irq_restore(flags);
Pierre Ossman98ccf142007-05-12 00:26:16 +0200359}
360