]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
70f10482 | 2 | * linux/drivers/mmc/card/queue.c |
1da177e4 LT |
3 | * |
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> |
45711f1a | 16 | #include <linux/scatterlist.h> |
1da177e4 LT |
17 | |
18 | #include <linux/mmc/card.h> | |
19 | #include <linux/mmc/host.h> | |
98ac2162 | 20 | #include "queue.h" |
1da177e4 | 21 | |
98ccf149 PO |
22 | #define MMC_QUEUE_BOUNCESZ 65536 |
23 | ||
87598a2b | 24 | #define MMC_QUEUE_SUSPENDED (1 << 0) |
1da177e4 LT |
25 | |
26 | /* | |
9c9f2d63 | 27 | * Prepare a MMC request. This just filters out odd stuff. |
1da177e4 LT |
28 | */ |
29 | static int mmc_prep_request(struct request_queue *q, struct request *req) | |
30 | { | |
9c9f2d63 PO |
31 | /* |
32 | * We only like normal block requests. | |
33 | */ | |
34 | if (!blk_fs_request(req) && !blk_pc_request(req)) { | |
1da177e4 | 35 | blk_dump_rq_flags(req, "MMC bad request"); |
9c9f2d63 | 36 | return BLKPREP_KILL; |
1da177e4 LT |
37 | } |
38 | ||
9c9f2d63 | 39 | req->cmd_flags |= REQ_DONTPREP; |
1da177e4 | 40 | |
9c9f2d63 | 41 | return BLKPREP_OK; |
1da177e4 LT |
42 | } |
43 | ||
44 | static int mmc_queue_thread(void *d) | |
45 | { | |
46 | struct mmc_queue *mq = d; | |
47 | struct request_queue *q = mq->queue; | |
1da177e4 | 48 | |
83144186 | 49 | current->flags |= PF_MEMALLOC; |
1da177e4 | 50 | |
1da177e4 | 51 | down(&mq->thread_sem); |
1da177e4 LT |
52 | 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)) | |
c723e08a JY |
58 | req = elv_next_request(q); |
59 | mq->req = req; | |
1da177e4 LT |
60 | spin_unlock_irq(q->queue_lock); |
61 | ||
62 | if (!req) { | |
7b30d281 VW |
63 | if (kthread_should_stop()) { |
64 | set_current_state(TASK_RUNNING); | |
1da177e4 | 65 | break; |
7b30d281 | 66 | } |
1da177e4 LT |
67 | 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); | |
1da177e4 LT |
76 | up(&mq->thread_sem); |
77 | ||
1da177e4 LT |
78 | 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 | */ | |
165125e1 | 87 | static void mmc_request(struct request_queue *q) |
1da177e4 LT |
88 | { |
89 | struct mmc_queue *mq = q->queuedata; | |
89b4e133 PO |
90 | 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 { | |
fd539832 KU |
97 | ret = __blk_end_request(req, -EIO, |
98 | blk_rq_cur_bytes(req)); | |
89b4e133 PO |
99 | } while (ret); |
100 | } | |
101 | return; | |
102 | } | |
1da177e4 LT |
103 | |
104 | if (!mq->req) | |
87598a2b | 105 | wake_up_process(mq->thread); |
1da177e4 LT |
106 | } |
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 | */ | |
116 | int 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 | ||
fcaf71fd GKH |
122 | if (mmc_dev(host)->dma_mask && *mmc_dev(host)->dma_mask) |
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) { | |
aafabfab PO |
137 | unsigned int bouncesz; |
138 | ||
98ccf149 PO |
139 | 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 { | |
2ff1fa67 | 151 | blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_ANY); |
98ccf149 PO |
152 | 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 | ||
45711f1a | 157 | mq->sg = kmalloc(sizeof(struct scatterlist), |
98ccf149 PO |
158 | GFP_KERNEL); |
159 | if (!mq->sg) { | |
160 | ret = -ENOMEM; | |
aafabfab | 161 | goto cleanup_queue; |
98ccf149 | 162 | } |
45711f1a | 163 | sg_init_table(mq->sg, 1); |
98ccf149 | 164 | |
45711f1a | 165 | mq->bounce_sg = kmalloc(sizeof(struct scatterlist) * |
98ccf149 PO |
166 | bouncesz / 512, GFP_KERNEL); |
167 | if (!mq->bounce_sg) { | |
168 | ret = -ENOMEM; | |
aafabfab | 169 | goto cleanup_queue; |
98ccf149 | 170 | } |
45711f1a | 171 | sg_init_table(mq->bounce_sg, bouncesz / 512); |
98ccf149 PO |
172 | } |
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 | ||
05e5b136 | 183 | mq->sg = kmalloc(sizeof(struct scatterlist) * |
98ccf149 PO |
184 | host->max_phys_segs, GFP_KERNEL); |
185 | if (!mq->sg) { | |
186 | ret = -ENOMEM; | |
187 | goto cleanup_queue; | |
188 | } | |
05e5b136 | 189 | sg_init_table(mq->sg, host->max_phys_segs); |
1da177e4 LT |
190 | } |
191 | ||
1da177e4 LT |
192 | init_MUTEX(&mq->thread_sem); |
193 | ||
87598a2b CH |
194 | mq->thread = kthread_run(mmc_queue_thread, mq, "mmcqd"); |
195 | if (IS_ERR(mq->thread)) { | |
196 | ret = PTR_ERR(mq->thread); | |
98ccf149 | 197 | goto free_bounce_sg; |
1da177e4 LT |
198 | } |
199 | ||
87598a2b | 200 | return 0; |
98ccf149 PO |
201 | free_bounce_sg: |
202 | if (mq->bounce_sg) | |
203 | kfree(mq->bounce_sg); | |
204 | mq->bounce_sg = NULL; | |
aafabfab PO |
205 | cleanup_queue: |
206 | if (mq->sg) | |
207 | kfree(mq->sg); | |
1da177e4 | 208 | mq->sg = NULL; |
98ccf149 PO |
209 | if (mq->bounce_buf) |
210 | kfree(mq->bounce_buf); | |
211 | mq->bounce_buf = NULL; | |
1da177e4 | 212 | blk_cleanup_queue(mq->queue); |
1da177e4 LT |
213 | return ret; |
214 | } | |
1da177e4 LT |
215 | |
216 | void mmc_cleanup_queue(struct mmc_queue *mq) | |
217 | { | |
165125e1 | 218 | struct request_queue *q = mq->queue; |
89b4e133 PO |
219 | 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 | ||
d2b46f66 PO |
226 | /* Make sure the queue isn't suspended, as that will deadlock */ |
227 | mmc_queue_resume(mq); | |
228 | ||
89b4e133 | 229 | /* Then terminate our worker thread */ |
87598a2b | 230 | kthread_stop(mq->thread); |
1da177e4 | 231 | |
98ccf149 PO |
232 | if (mq->bounce_sg) |
233 | kfree(mq->bounce_sg); | |
234 | mq->bounce_sg = NULL; | |
235 | ||
1da177e4 LT |
236 | kfree(mq->sg); |
237 | mq->sg = NULL; | |
238 | ||
98ccf149 PO |
239 | if (mq->bounce_buf) |
240 | kfree(mq->bounce_buf); | |
241 | mq->bounce_buf = NULL; | |
242 | ||
1da177e4 LT |
243 | blk_cleanup_queue(mq->queue); |
244 | ||
245 | mq->card = NULL; | |
246 | } | |
247 | EXPORT_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 | */ | |
257 | void mmc_queue_suspend(struct mmc_queue *mq) | |
258 | { | |
165125e1 | 259 | struct request_queue *q = mq->queue; |
1da177e4 LT |
260 | 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 | } | |
1da177e4 LT |
272 | |
273 | /** | |
274 | * mmc_queue_resume - resume a previously suspended MMC request queue | |
275 | * @mq: MMC queue to resume | |
276 | */ | |
277 | void mmc_queue_resume(struct mmc_queue *mq) | |
278 | { | |
165125e1 | 279 | struct request_queue *q = mq->queue; |
1da177e4 LT |
280 | 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 | } | |
98ac2162 | 292 | |
2ff1fa67 PO |
293 | /* |
294 | * Prepare the sg list(s) to be handed of to the host driver | |
295 | */ | |
98ccf149 PO |
296 | unsigned int mmc_queue_map_sg(struct mmc_queue *mq) |
297 | { | |
298 | unsigned int sg_len; | |
2ff1fa67 PO |
299 | size_t buflen; |
300 | struct scatterlist *sg; | |
301 | int i; | |
98ccf149 PO |
302 | |
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 | ||
2ff1fa67 PO |
312 | buflen = 0; |
313 | for_each_sg(mq->bounce_sg, sg, sg_len, i) | |
314 | buflen += sg->length; | |
98ccf149 | 315 | |
2ff1fa67 | 316 | sg_init_one(mq->sg, mq->bounce_buf, buflen); |
98ccf149 PO |
317 | |
318 | return 1; | |
319 | } | |
320 | ||
2ff1fa67 PO |
321 | /* |
322 | * If writing, bounce the data to the buffer before the request | |
323 | * is sent to the host driver | |
324 | */ | |
98ccf149 PO |
325 | void mmc_queue_bounce_pre(struct mmc_queue *mq) |
326 | { | |
2ff1fa67 PO |
327 | unsigned long flags; |
328 | ||
98ccf149 PO |
329 | if (!mq->bounce_buf) |
330 | return; | |
331 | ||
98ccf149 PO |
332 | if (rq_data_dir(mq->req) != WRITE) |
333 | return; | |
334 | ||
2ff1fa67 PO |
335 | 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); | |
98ccf149 PO |
339 | } |
340 | ||
2ff1fa67 PO |
341 | /* |
342 | * If reading, bounce the data from the buffer after the request | |
343 | * has been handled by the host driver | |
344 | */ | |
98ccf149 PO |
345 | void mmc_queue_bounce_post(struct mmc_queue *mq) |
346 | { | |
2ff1fa67 PO |
347 | unsigned long flags; |
348 | ||
98ccf149 PO |
349 | if (!mq->bounce_buf) |
350 | return; | |
351 | ||
98ccf149 PO |
352 | if (rq_data_dir(mq->req) != READ) |
353 | return; | |
354 | ||
2ff1fa67 PO |
355 | 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); | |
98ccf149 PO |
359 | } |
360 |