Eric Lee / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 5dee2477df5368368b7dba810a17a3c411a1d0f0

Authored by Martin K. Petersen
Committed by Jens Axboe
1 parent 80ddf247c8
Exists in master and in 39 other branches 8mp-imx_5.4.70_2.3.0, 8qm-imx_5.4.70_2.3.0, emb_imx_lf-5.15.y, emb_lf-6.1.y, imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, imx_4.1.15_1.0.0_ga, pitx_8mp_lf-5.10.y, rt-smarc-imx_4.1.15_1.0.0_ga, rt_linux_5.15.71, smarc-8m-android-11.0.0_2.0.0, smarc-imx6_4.14.98_2.0.0_ga, smarc-imx6_4.9.88_2.0.0_ga, smarc-imx7_4.14.98_2.0.0_ga, smarc-imx7_4.9.11_1.0.0_ga, smarc-imx7_4.9.88_2.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-imx_4.1.15_1.0.0_ga, smarc-imx_4.9.11_1.0.0_ga, smarc-imx_4.9.51_imx8m_ga, smarc-imx_4.9.88_2.0.0_ga, smarc-m6.0.1_2.1.0-ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_1.2.0_ga, smarc_8m_00d0_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.14.78_1.0.0_ga, smarc_8m_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.19.35_1.1.0, smarc_8mm_imx_4.14.78_1.0.0_ga, smarc_8mm_imx_4.14.98_2.0.0_ga, smarc_8mm_imx_4.19.35_1.1.0, smarc_8mm_imx_5.4.24_2.1.0, smarc_8mp_lf-5.10.y, smarc_8mq_imx_5.4.24_2.1.0, smarc_8mq_lf-5.10.y, smarc_imx_lf-5.15.y

block: Do not clamp max_hw_sectors for stacking devices 

Stacking devices do not have an inherent max_hw_sector limit.  Set the
default to INT_MAX so we are bounded only by capabilities of the
underlying storage.

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

Showing 1 changed file with 2 additions and 1 deletions Inline Diff

block/blk-settings.c
Diff comments   View file @ 5dee247
1 /* 1 /*
2 * Functions related to setting various queue properties from drivers 2 * Functions related to setting various queue properties from drivers
3 */ 3 */
4 #include <linux/kernel.h> 4 #include <linux/kernel.h>
5 #include <linux/module.h> 5 #include <linux/module.h>
6 #include <linux/init.h> 6 #include <linux/init.h>
7 #include <linux/bio.h> 7 #include <linux/bio.h>
8 #include <linux/blkdev.h> 8 #include <linux/blkdev.h>
9 #include <linux/bootmem.h> /* for max_pfn/max_low_pfn */ 9 #include <linux/bootmem.h> /* for max_pfn/max_low_pfn */
10 #include <linux/gcd.h> 10 #include <linux/gcd.h>
11 11
12 #include "blk.h" 12 #include "blk.h"
13 13
14 unsigned long blk_max_low_pfn; 14 unsigned long blk_max_low_pfn;
15 EXPORT_SYMBOL(blk_max_low_pfn); 15 EXPORT_SYMBOL(blk_max_low_pfn);
16 16
17 unsigned long blk_max_pfn; 17 unsigned long blk_max_pfn;
18 18
19 /** 19 /**
20 * blk_queue_prep_rq - set a prepare_request function for queue 20 * blk_queue_prep_rq - set a prepare_request function for queue
21 * @q: queue 21 * @q: queue
22 * @pfn: prepare_request function 22 * @pfn: prepare_request function
23 * 23 *
24 * It's possible for a queue to register a prepare_request callback which 24 * It's possible for a queue to register a prepare_request callback which
25 * is invoked before the request is handed to the request_fn. The goal of 25 * is invoked before the request is handed to the request_fn. The goal of
26 * the function is to prepare a request for I/O, it can be used to build a 26 * the function is to prepare a request for I/O, it can be used to build a
27 * cdb from the request data for instance. 27 * cdb from the request data for instance.
28 * 28 *
29 */ 29 */
30 void blk_queue_prep_rq(struct request_queue *q, prep_rq_fn *pfn) 30 void blk_queue_prep_rq(struct request_queue *q, prep_rq_fn *pfn)
31 { 31 {
32 q->prep_rq_fn = pfn; 32 q->prep_rq_fn = pfn;
33 } 33 }
34 EXPORT_SYMBOL(blk_queue_prep_rq); 34 EXPORT_SYMBOL(blk_queue_prep_rq);
35 35
36 /** 36 /**
37 * blk_queue_set_discard - set a discard_sectors function for queue 37 * blk_queue_set_discard - set a discard_sectors function for queue
38 * @q: queue 38 * @q: queue
39 * @dfn: prepare_discard function 39 * @dfn: prepare_discard function
40 * 40 *
41 * It's possible for a queue to register a discard callback which is used 41 * It's possible for a queue to register a discard callback which is used
42 * to transform a discard request into the appropriate type for the 42 * to transform a discard request into the appropriate type for the
43 * hardware. If none is registered, then discard requests are failed 43 * hardware. If none is registered, then discard requests are failed
44 * with %EOPNOTSUPP. 44 * with %EOPNOTSUPP.
45 * 45 *
46 */ 46 */
47 void blk_queue_set_discard(struct request_queue *q, prepare_discard_fn *dfn) 47 void blk_queue_set_discard(struct request_queue *q, prepare_discard_fn *dfn)
48 { 48 {
49 q->prepare_discard_fn = dfn; 49 q->prepare_discard_fn = dfn;
50 } 50 }
51 EXPORT_SYMBOL(blk_queue_set_discard); 51 EXPORT_SYMBOL(blk_queue_set_discard);
52 52
53 /** 53 /**
54 * blk_queue_merge_bvec - set a merge_bvec function for queue 54 * blk_queue_merge_bvec - set a merge_bvec function for queue
55 * @q: queue 55 * @q: queue
56 * @mbfn: merge_bvec_fn 56 * @mbfn: merge_bvec_fn
57 * 57 *
58 * Usually queues have static limitations on the max sectors or segments that 58 * Usually queues have static limitations on the max sectors or segments that
59 * we can put in a request. Stacking drivers may have some settings that 59 * we can put in a request. Stacking drivers may have some settings that
60 * are dynamic, and thus we have to query the queue whether it is ok to 60 * are dynamic, and thus we have to query the queue whether it is ok to
61 * add a new bio_vec to a bio at a given offset or not. If the block device 61 * add a new bio_vec to a bio at a given offset or not. If the block device
62 * has such limitations, it needs to register a merge_bvec_fn to control 62 * has such limitations, it needs to register a merge_bvec_fn to control
63 * the size of bio's sent to it. Note that a block device *must* allow a 63 * the size of bio's sent to it. Note that a block device *must* allow a
64 * single page to be added to an empty bio. The block device driver may want 64 * single page to be added to an empty bio. The block device driver may want
65 * to use the bio_split() function to deal with these bio's. By default 65 * to use the bio_split() function to deal with these bio's. By default
66 * no merge_bvec_fn is defined for a queue, and only the fixed limits are 66 * no merge_bvec_fn is defined for a queue, and only the fixed limits are
67 * honored. 67 * honored.
68 */ 68 */
69 void blk_queue_merge_bvec(struct request_queue *q, merge_bvec_fn *mbfn) 69 void blk_queue_merge_bvec(struct request_queue *q, merge_bvec_fn *mbfn)
70 { 70 {
71 q->merge_bvec_fn = mbfn; 71 q->merge_bvec_fn = mbfn;
72 } 72 }
73 EXPORT_SYMBOL(blk_queue_merge_bvec); 73 EXPORT_SYMBOL(blk_queue_merge_bvec);
74 74
75 void blk_queue_softirq_done(struct request_queue *q, softirq_done_fn *fn) 75 void blk_queue_softirq_done(struct request_queue *q, softirq_done_fn *fn)
76 { 76 {
77 q->softirq_done_fn = fn; 77 q->softirq_done_fn = fn;
78 } 78 }
79 EXPORT_SYMBOL(blk_queue_softirq_done); 79 EXPORT_SYMBOL(blk_queue_softirq_done);
80 80
81 void blk_queue_rq_timeout(struct request_queue *q, unsigned int timeout) 81 void blk_queue_rq_timeout(struct request_queue *q, unsigned int timeout)
82 { 82 {
83 q->rq_timeout = timeout; 83 q->rq_timeout = timeout;
84 } 84 }
85 EXPORT_SYMBOL_GPL(blk_queue_rq_timeout); 85 EXPORT_SYMBOL_GPL(blk_queue_rq_timeout);
86 86
87 void blk_queue_rq_timed_out(struct request_queue *q, rq_timed_out_fn *fn) 87 void blk_queue_rq_timed_out(struct request_queue *q, rq_timed_out_fn *fn)
88 { 88 {
89 q->rq_timed_out_fn = fn; 89 q->rq_timed_out_fn = fn;
90 } 90 }
91 EXPORT_SYMBOL_GPL(blk_queue_rq_timed_out); 91 EXPORT_SYMBOL_GPL(blk_queue_rq_timed_out);
92 92
93 void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn) 93 void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn)
94 { 94 {
95 q->lld_busy_fn = fn; 95 q->lld_busy_fn = fn;
96 } 96 }
97 EXPORT_SYMBOL_GPL(blk_queue_lld_busy); 97 EXPORT_SYMBOL_GPL(blk_queue_lld_busy);
98 98
99 /** 99 /**
100 * blk_set_default_limits - reset limits to default values 100 * blk_set_default_limits - reset limits to default values
101 * @lim: the queue_limits structure to reset 101 * @lim: the queue_limits structure to reset
102 * 102 *
103 * Description: 103 * Description:
104 * Returns a queue_limit struct to its default state. Can be used by 104 * Returns a queue_limit struct to its default state. Can be used by
105 * stacking drivers like DM that stage table swaps and reuse an 105 * stacking drivers like DM that stage table swaps and reuse an
106 * existing device queue. 106 * existing device queue.
107 */ 107 */
108 void blk_set_default_limits(struct queue_limits *lim) 108 void blk_set_default_limits(struct queue_limits *lim)
109 { 109 {
110 lim->max_phys_segments = MAX_PHYS_SEGMENTS; 110 lim->max_phys_segments = MAX_PHYS_SEGMENTS;
111 lim->max_hw_segments = MAX_HW_SEGMENTS; 111 lim->max_hw_segments = MAX_HW_SEGMENTS;
112 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK; 112 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
113 lim->max_segment_size = MAX_SEGMENT_SIZE; 113 lim->max_segment_size = MAX_SEGMENT_SIZE;
114 lim->max_sectors = lim->max_hw_sectors = BLK_DEF_MAX_SECTORS; 114 lim->max_sectors = BLK_DEF_MAX_SECTORS;
115 lim->max_hw_sectors = INT_MAX;
115 lim->logical_block_size = lim->physical_block_size = lim->io_min = 512; 116 lim->logical_block_size = lim->physical_block_size = lim->io_min = 512;
116 lim->bounce_pfn = (unsigned long)(BLK_BOUNCE_ANY >> PAGE_SHIFT); 117 lim->bounce_pfn = (unsigned long)(BLK_BOUNCE_ANY >> PAGE_SHIFT);
117 lim->alignment_offset = 0; 118 lim->alignment_offset = 0;
118 lim->io_opt = 0; 119 lim->io_opt = 0;
119 lim->misaligned = 0; 120 lim->misaligned = 0;
120 lim->no_cluster = 0; 121 lim->no_cluster = 0;
121 } 122 }
122 EXPORT_SYMBOL(blk_set_default_limits); 123 EXPORT_SYMBOL(blk_set_default_limits);
123 124
124 /** 125 /**
125 * blk_queue_make_request - define an alternate make_request function for a device 126 * blk_queue_make_request - define an alternate make_request function for a device
126 * @q: the request queue for the device to be affected 127 * @q: the request queue for the device to be affected
127 * @mfn: the alternate make_request function 128 * @mfn: the alternate make_request function
128 * 129 *
129 * Description: 130 * Description:
130 * The normal way for &struct bios to be passed to a device 131 * The normal way for &struct bios to be passed to a device
131 * driver is for them to be collected into requests on a request 132 * driver is for them to be collected into requests on a request
132 * queue, and then to allow the device driver to select requests 133 * queue, and then to allow the device driver to select requests
133 * off that queue when it is ready. This works well for many block 134 * off that queue when it is ready. This works well for many block
134 * devices. However some block devices (typically virtual devices 135 * devices. However some block devices (typically virtual devices
135 * such as md or lvm) do not benefit from the processing on the 136 * such as md or lvm) do not benefit from the processing on the
136 * request queue, and are served best by having the requests passed 137 * request queue, and are served best by having the requests passed
137 * directly to them. This can be achieved by providing a function 138 * directly to them. This can be achieved by providing a function
138 * to blk_queue_make_request(). 139 * to blk_queue_make_request().
139 * 140 *
140 * Caveat: 141 * Caveat:
141 * The driver that does this *must* be able to deal appropriately 142 * The driver that does this *must* be able to deal appropriately
142 * with buffers in "highmemory". This can be accomplished by either calling 143 * with buffers in "highmemory". This can be accomplished by either calling
143 * __bio_kmap_atomic() to get a temporary kernel mapping, or by calling 144 * __bio_kmap_atomic() to get a temporary kernel mapping, or by calling
144 * blk_queue_bounce() to create a buffer in normal memory. 145 * blk_queue_bounce() to create a buffer in normal memory.
145 **/ 146 **/
146 void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn) 147 void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
147 { 148 {
148 /* 149 /*
149 * set defaults 150 * set defaults
150 */ 151 */
151 q->nr_requests = BLKDEV_MAX_RQ; 152 q->nr_requests = BLKDEV_MAX_RQ;
152 153
153 q->make_request_fn = mfn; 154 q->make_request_fn = mfn;
154 blk_queue_dma_alignment(q, 511); 155 blk_queue_dma_alignment(q, 511);
155 blk_queue_congestion_threshold(q); 156 blk_queue_congestion_threshold(q);
156 q->nr_batching = BLK_BATCH_REQ; 157 q->nr_batching = BLK_BATCH_REQ;
157 158
158 q->unplug_thresh = 4; /* hmm */ 159 q->unplug_thresh = 4; /* hmm */
159 q->unplug_delay = (3 * HZ) / 1000; /* 3 milliseconds */ 160 q->unplug_delay = (3 * HZ) / 1000; /* 3 milliseconds */
160 if (q->unplug_delay == 0) 161 if (q->unplug_delay == 0)
161 q->unplug_delay = 1; 162 q->unplug_delay = 1;
162 163
163 q->unplug_timer.function = blk_unplug_timeout; 164 q->unplug_timer.function = blk_unplug_timeout;
164 q->unplug_timer.data = (unsigned long)q; 165 q->unplug_timer.data = (unsigned long)q;
165 166
166 blk_set_default_limits(&q->limits); 167 blk_set_default_limits(&q->limits);
167 blk_queue_max_sectors(q, SAFE_MAX_SECTORS); 168 blk_queue_max_sectors(q, SAFE_MAX_SECTORS);
168 169
169 /* 170 /*
170 * If the caller didn't supply a lock, fall back to our embedded 171 * If the caller didn't supply a lock, fall back to our embedded
171 * per-queue locks 172 * per-queue locks
172 */ 173 */
173 if (!q->queue_lock) 174 if (!q->queue_lock)
174 q->queue_lock = &q->__queue_lock; 175 q->queue_lock = &q->__queue_lock;
175 176
176 /* 177 /*
177 * by default assume old behaviour and bounce for any highmem page 178 * by default assume old behaviour and bounce for any highmem page
178 */ 179 */
179 blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH); 180 blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH);
180 } 181 }
181 EXPORT_SYMBOL(blk_queue_make_request); 182 EXPORT_SYMBOL(blk_queue_make_request);
182 183
183 /** 184 /**
184 * blk_queue_bounce_limit - set bounce buffer limit for queue 185 * blk_queue_bounce_limit - set bounce buffer limit for queue
185 * @q: the request queue for the device 186 * @q: the request queue for the device
186 * @dma_mask: the maximum address the device can handle 187 * @dma_mask: the maximum address the device can handle
187 * 188 *
188 * Description: 189 * Description:
189 * Different hardware can have different requirements as to what pages 190 * Different hardware can have different requirements as to what pages
190 * it can do I/O directly to. A low level driver can call 191 * it can do I/O directly to. A low level driver can call
191 * blk_queue_bounce_limit to have lower memory pages allocated as bounce 192 * blk_queue_bounce_limit to have lower memory pages allocated as bounce
192 * buffers for doing I/O to pages residing above @dma_mask. 193 * buffers for doing I/O to pages residing above @dma_mask.
193 **/ 194 **/
194 void blk_queue_bounce_limit(struct request_queue *q, u64 dma_mask) 195 void blk_queue_bounce_limit(struct request_queue *q, u64 dma_mask)
195 { 196 {
196 unsigned long b_pfn = dma_mask >> PAGE_SHIFT; 197 unsigned long b_pfn = dma_mask >> PAGE_SHIFT;
197 int dma = 0; 198 int dma = 0;
198 199
199 q->bounce_gfp = GFP_NOIO; 200 q->bounce_gfp = GFP_NOIO;
200 #if BITS_PER_LONG == 64 201 #if BITS_PER_LONG == 64
201 /* 202 /*
202 * Assume anything <= 4GB can be handled by IOMMU. Actually 203 * Assume anything <= 4GB can be handled by IOMMU. Actually
203 * some IOMMUs can handle everything, but I don't know of a 204 * some IOMMUs can handle everything, but I don't know of a
204 * way to test this here. 205 * way to test this here.
205 */ 206 */
206 if (b_pfn < (min_t(u64, 0xffffffffUL, BLK_BOUNCE_HIGH) >> PAGE_SHIFT)) 207 if (b_pfn < (min_t(u64, 0xffffffffUL, BLK_BOUNCE_HIGH) >> PAGE_SHIFT))
207 dma = 1; 208 dma = 1;
208 q->limits.bounce_pfn = max_low_pfn; 209 q->limits.bounce_pfn = max_low_pfn;
209 #else 210 #else
210 if (b_pfn < blk_max_low_pfn) 211 if (b_pfn < blk_max_low_pfn)
211 dma = 1; 212 dma = 1;
212 q->limits.bounce_pfn = b_pfn; 213 q->limits.bounce_pfn = b_pfn;
213 #endif 214 #endif
214 if (dma) { 215 if (dma) {
215 init_emergency_isa_pool(); 216 init_emergency_isa_pool();
216 q->bounce_gfp = GFP_NOIO | GFP_DMA; 217 q->bounce_gfp = GFP_NOIO | GFP_DMA;
217 q->limits.bounce_pfn = b_pfn; 218 q->limits.bounce_pfn = b_pfn;
218 } 219 }
219 } 220 }
220 EXPORT_SYMBOL(blk_queue_bounce_limit); 221 EXPORT_SYMBOL(blk_queue_bounce_limit);
221 222
222 /** 223 /**
223 * blk_queue_max_sectors - set max sectors for a request for this queue 224 * blk_queue_max_sectors - set max sectors for a request for this queue
224 * @q: the request queue for the device 225 * @q: the request queue for the device
225 * @max_sectors: max sectors in the usual 512b unit 226 * @max_sectors: max sectors in the usual 512b unit
226 * 227 *
227 * Description: 228 * Description:
228 * Enables a low level driver to set an upper limit on the size of 229 * Enables a low level driver to set an upper limit on the size of
229 * received requests. 230 * received requests.
230 **/ 231 **/
231 void blk_queue_max_sectors(struct request_queue *q, unsigned int max_sectors) 232 void blk_queue_max_sectors(struct request_queue *q, unsigned int max_sectors)
232 { 233 {
233 if ((max_sectors << 9) < PAGE_CACHE_SIZE) { 234 if ((max_sectors << 9) < PAGE_CACHE_SIZE) {
234 max_sectors = 1 << (PAGE_CACHE_SHIFT - 9); 235 max_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
235 printk(KERN_INFO "%s: set to minimum %d\n", 236 printk(KERN_INFO "%s: set to minimum %d\n",
236 __func__, max_sectors); 237 __func__, max_sectors);
237 } 238 }
238 239
239 if (BLK_DEF_MAX_SECTORS > max_sectors) 240 if (BLK_DEF_MAX_SECTORS > max_sectors)
240 q->limits.max_hw_sectors = q->limits.max_sectors = max_sectors; 241 q->limits.max_hw_sectors = q->limits.max_sectors = max_sectors;
241 else { 242 else {
242 q->limits.max_sectors = BLK_DEF_MAX_SECTORS; 243 q->limits.max_sectors = BLK_DEF_MAX_SECTORS;
243 q->limits.max_hw_sectors = max_sectors; 244 q->limits.max_hw_sectors = max_sectors;
244 } 245 }
245 } 246 }
246 EXPORT_SYMBOL(blk_queue_max_sectors); 247 EXPORT_SYMBOL(blk_queue_max_sectors);
247 248
248 void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_sectors) 249 void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_sectors)
249 { 250 {
250 if (BLK_DEF_MAX_SECTORS > max_sectors) 251 if (BLK_DEF_MAX_SECTORS > max_sectors)
251 q->limits.max_hw_sectors = BLK_DEF_MAX_SECTORS; 252 q->limits.max_hw_sectors = BLK_DEF_MAX_SECTORS;
252 else 253 else
253 q->limits.max_hw_sectors = max_sectors; 254 q->limits.max_hw_sectors = max_sectors;
254 } 255 }
255 EXPORT_SYMBOL(blk_queue_max_hw_sectors); 256 EXPORT_SYMBOL(blk_queue_max_hw_sectors);
256 257
257 /** 258 /**
258 * blk_queue_max_phys_segments - set max phys segments for a request for this queue 259 * blk_queue_max_phys_segments - set max phys segments for a request for this queue
259 * @q: the request queue for the device 260 * @q: the request queue for the device
260 * @max_segments: max number of segments 261 * @max_segments: max number of segments
261 * 262 *
262 * Description: 263 * Description:
263 * Enables a low level driver to set an upper limit on the number of 264 * Enables a low level driver to set an upper limit on the number of
264 * physical data segments in a request. This would be the largest sized 265 * physical data segments in a request. This would be the largest sized
265 * scatter list the driver could handle. 266 * scatter list the driver could handle.
266 **/ 267 **/
267 void blk_queue_max_phys_segments(struct request_queue *q, 268 void blk_queue_max_phys_segments(struct request_queue *q,
268 unsigned short max_segments) 269 unsigned short max_segments)
269 { 270 {
270 if (!max_segments) { 271 if (!max_segments) {
271 max_segments = 1; 272 max_segments = 1;
272 printk(KERN_INFO "%s: set to minimum %d\n", 273 printk(KERN_INFO "%s: set to minimum %d\n",
273 __func__, max_segments); 274 __func__, max_segments);
274 } 275 }
275 276
276 q->limits.max_phys_segments = max_segments; 277 q->limits.max_phys_segments = max_segments;
277 } 278 }
278 EXPORT_SYMBOL(blk_queue_max_phys_segments); 279 EXPORT_SYMBOL(blk_queue_max_phys_segments);
279 280
280 /** 281 /**
281 * blk_queue_max_hw_segments - set max hw segments for a request for this queue 282 * blk_queue_max_hw_segments - set max hw segments for a request for this queue
282 * @q: the request queue for the device 283 * @q: the request queue for the device
283 * @max_segments: max number of segments 284 * @max_segments: max number of segments
284 * 285 *
285 * Description: 286 * Description:
286 * Enables a low level driver to set an upper limit on the number of 287 * Enables a low level driver to set an upper limit on the number of
287 * hw data segments in a request. This would be the largest number of 288 * hw data segments in a request. This would be the largest number of
288 * address/length pairs the host adapter can actually give at once 289 * address/length pairs the host adapter can actually give at once
289 * to the device. 290 * to the device.
290 **/ 291 **/
291 void blk_queue_max_hw_segments(struct request_queue *q, 292 void blk_queue_max_hw_segments(struct request_queue *q,
292 unsigned short max_segments) 293 unsigned short max_segments)
293 { 294 {
294 if (!max_segments) { 295 if (!max_segments) {
295 max_segments = 1; 296 max_segments = 1;
296 printk(KERN_INFO "%s: set to minimum %d\n", 297 printk(KERN_INFO "%s: set to minimum %d\n",
297 __func__, max_segments); 298 __func__, max_segments);
298 } 299 }
299 300
300 q->limits.max_hw_segments = max_segments; 301 q->limits.max_hw_segments = max_segments;
301 } 302 }
302 EXPORT_SYMBOL(blk_queue_max_hw_segments); 303 EXPORT_SYMBOL(blk_queue_max_hw_segments);
303 304
304 /** 305 /**
305 * blk_queue_max_segment_size - set max segment size for blk_rq_map_sg 306 * blk_queue_max_segment_size - set max segment size for blk_rq_map_sg
306 * @q: the request queue for the device 307 * @q: the request queue for the device
307 * @max_size: max size of segment in bytes 308 * @max_size: max size of segment in bytes
308 * 309 *
309 * Description: 310 * Description:
310 * Enables a low level driver to set an upper limit on the size of a 311 * Enables a low level driver to set an upper limit on the size of a
311 * coalesced segment 312 * coalesced segment
312 **/ 313 **/
313 void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size) 314 void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
314 { 315 {
315 if (max_size < PAGE_CACHE_SIZE) { 316 if (max_size < PAGE_CACHE_SIZE) {
316 max_size = PAGE_CACHE_SIZE; 317 max_size = PAGE_CACHE_SIZE;
317 printk(KERN_INFO "%s: set to minimum %d\n", 318 printk(KERN_INFO "%s: set to minimum %d\n",
318 __func__, max_size); 319 __func__, max_size);
319 } 320 }
320 321
321 q->limits.max_segment_size = max_size; 322 q->limits.max_segment_size = max_size;
322 } 323 }
323 EXPORT_SYMBOL(blk_queue_max_segment_size); 324 EXPORT_SYMBOL(blk_queue_max_segment_size);
324 325
325 /** 326 /**
326 * blk_queue_logical_block_size - set logical block size for the queue 327 * blk_queue_logical_block_size - set logical block size for the queue
327 * @q: the request queue for the device 328 * @q: the request queue for the device
328 * @size: the logical block size, in bytes 329 * @size: the logical block size, in bytes
329 * 330 *
330 * Description: 331 * Description:
331 * This should be set to the lowest possible block size that the 332 * This should be set to the lowest possible block size that the
332 * storage device can address. The default of 512 covers most 333 * storage device can address. The default of 512 covers most
333 * hardware. 334 * hardware.
334 **/ 335 **/
335 void blk_queue_logical_block_size(struct request_queue *q, unsigned short size) 336 void blk_queue_logical_block_size(struct request_queue *q, unsigned short size)
336 { 337 {
337 q->limits.logical_block_size = size; 338 q->limits.logical_block_size = size;
338 339
339 if (q->limits.physical_block_size < size) 340 if (q->limits.physical_block_size < size)
340 q->limits.physical_block_size = size; 341 q->limits.physical_block_size = size;
341 342
342 if (q->limits.io_min < q->limits.physical_block_size) 343 if (q->limits.io_min < q->limits.physical_block_size)
343 q->limits.io_min = q->limits.physical_block_size; 344 q->limits.io_min = q->limits.physical_block_size;
344 } 345 }
345 EXPORT_SYMBOL(blk_queue_logical_block_size); 346 EXPORT_SYMBOL(blk_queue_logical_block_size);
346 347
347 /** 348 /**
348 * blk_queue_physical_block_size - set physical block size for the queue 349 * blk_queue_physical_block_size - set physical block size for the queue
349 * @q: the request queue for the device 350 * @q: the request queue for the device
350 * @size: the physical block size, in bytes 351 * @size: the physical block size, in bytes
351 * 352 *
352 * Description: 353 * Description:
353 * This should be set to the lowest possible sector size that the 354 * This should be set to the lowest possible sector size that the
354 * hardware can operate on without reverting to read-modify-write 355 * hardware can operate on without reverting to read-modify-write
355 * operations. 356 * operations.
356 */ 357 */
357 void blk_queue_physical_block_size(struct request_queue *q, unsigned short size) 358 void blk_queue_physical_block_size(struct request_queue *q, unsigned short size)
358 { 359 {
359 q->limits.physical_block_size = size; 360 q->limits.physical_block_size = size;
360 361
361 if (q->limits.physical_block_size < q->limits.logical_block_size) 362 if (q->limits.physical_block_size < q->limits.logical_block_size)
362 q->limits.physical_block_size = q->limits.logical_block_size; 363 q->limits.physical_block_size = q->limits.logical_block_size;
363 364
364 if (q->limits.io_min < q->limits.physical_block_size) 365 if (q->limits.io_min < q->limits.physical_block_size)
365 q->limits.io_min = q->limits.physical_block_size; 366 q->limits.io_min = q->limits.physical_block_size;
366 } 367 }
367 EXPORT_SYMBOL(blk_queue_physical_block_size); 368 EXPORT_SYMBOL(blk_queue_physical_block_size);
368 369
369 /** 370 /**
370 * blk_queue_alignment_offset - set physical block alignment offset 371 * blk_queue_alignment_offset - set physical block alignment offset
371 * @q: the request queue for the device 372 * @q: the request queue for the device
372 * @offset: alignment offset in bytes 373 * @offset: alignment offset in bytes
373 * 374 *
374 * Description: 375 * Description:
375 * Some devices are naturally misaligned to compensate for things like 376 * Some devices are naturally misaligned to compensate for things like
376 * the legacy DOS partition table 63-sector offset. Low-level drivers 377 * the legacy DOS partition table 63-sector offset. Low-level drivers
377 * should call this function for devices whose first sector is not 378 * should call this function for devices whose first sector is not
378 * naturally aligned. 379 * naturally aligned.
379 */ 380 */
380 void blk_queue_alignment_offset(struct request_queue *q, unsigned int offset) 381 void blk_queue_alignment_offset(struct request_queue *q, unsigned int offset)
381 { 382 {
382 q->limits.alignment_offset = 383 q->limits.alignment_offset =
383 offset & (q->limits.physical_block_size - 1); 384 offset & (q->limits.physical_block_size - 1);
384 q->limits.misaligned = 0; 385 q->limits.misaligned = 0;
385 } 386 }
386 EXPORT_SYMBOL(blk_queue_alignment_offset); 387 EXPORT_SYMBOL(blk_queue_alignment_offset);
387 388
388 /** 389 /**
389 * blk_limits_io_min - set minimum request size for a device 390 * blk_limits_io_min - set minimum request size for a device
390 * @limits: the queue limits 391 * @limits: the queue limits
391 * @min: smallest I/O size in bytes 392 * @min: smallest I/O size in bytes
392 * 393 *
393 * Description: 394 * Description:
394 * Some devices have an internal block size bigger than the reported 395 * Some devices have an internal block size bigger than the reported
395 * hardware sector size. This function can be used to signal the 396 * hardware sector size. This function can be used to signal the
396 * smallest I/O the device can perform without incurring a performance 397 * smallest I/O the device can perform without incurring a performance
397 * penalty. 398 * penalty.
398 */ 399 */
399 void blk_limits_io_min(struct queue_limits *limits, unsigned int min) 400 void blk_limits_io_min(struct queue_limits *limits, unsigned int min)
400 { 401 {
401 limits->io_min = min; 402 limits->io_min = min;
402 403
403 if (limits->io_min < limits->logical_block_size) 404 if (limits->io_min < limits->logical_block_size)
404 limits->io_min = limits->logical_block_size; 405 limits->io_min = limits->logical_block_size;
405 406
406 if (limits->io_min < limits->physical_block_size) 407 if (limits->io_min < limits->physical_block_size)
407 limits->io_min = limits->physical_block_size; 408 limits->io_min = limits->physical_block_size;
408 } 409 }
409 EXPORT_SYMBOL(blk_limits_io_min); 410 EXPORT_SYMBOL(blk_limits_io_min);
410 411
411 /** 412 /**
412 * blk_queue_io_min - set minimum request size for the queue 413 * blk_queue_io_min - set minimum request size for the queue
413 * @q: the request queue for the device 414 * @q: the request queue for the device
414 * @min: smallest I/O size in bytes 415 * @min: smallest I/O size in bytes
415 * 416 *
416 * Description: 417 * Description:
417 * Storage devices may report a granularity or preferred minimum I/O 418 * Storage devices may report a granularity or preferred minimum I/O
418 * size which is the smallest request the device can perform without 419 * size which is the smallest request the device can perform without
419 * incurring a performance penalty. For disk drives this is often the 420 * incurring a performance penalty. For disk drives this is often the
420 * physical block size. For RAID arrays it is often the stripe chunk 421 * physical block size. For RAID arrays it is often the stripe chunk
421 * size. A properly aligned multiple of minimum_io_size is the 422 * size. A properly aligned multiple of minimum_io_size is the
422 * preferred request size for workloads where a high number of I/O 423 * preferred request size for workloads where a high number of I/O
423 * operations is desired. 424 * operations is desired.
424 */ 425 */
425 void blk_queue_io_min(struct request_queue *q, unsigned int min) 426 void blk_queue_io_min(struct request_queue *q, unsigned int min)
426 { 427 {
427 blk_limits_io_min(&q->limits, min); 428 blk_limits_io_min(&q->limits, min);
428 } 429 }
429 EXPORT_SYMBOL(blk_queue_io_min); 430 EXPORT_SYMBOL(blk_queue_io_min);
430 431
431 /** 432 /**
432 * blk_limits_io_opt - set optimal request size for a device 433 * blk_limits_io_opt - set optimal request size for a device
433 * @limits: the queue limits 434 * @limits: the queue limits
434 * @opt: smallest I/O size in bytes 435 * @opt: smallest I/O size in bytes
435 * 436 *
436 * Description: 437 * Description:
437 * Storage devices may report an optimal I/O size, which is the 438 * Storage devices may report an optimal I/O size, which is the
438 * device's preferred unit for sustained I/O. This is rarely reported 439 * device's preferred unit for sustained I/O. This is rarely reported
439 * for disk drives. For RAID arrays it is usually the stripe width or 440 * for disk drives. For RAID arrays it is usually the stripe width or
440 * the internal track size. A properly aligned multiple of 441 * the internal track size. A properly aligned multiple of
441 * optimal_io_size is the preferred request size for workloads where 442 * optimal_io_size is the preferred request size for workloads where
442 * sustained throughput is desired. 443 * sustained throughput is desired.
443 */ 444 */
444 void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt) 445 void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt)
445 { 446 {
446 limits->io_opt = opt; 447 limits->io_opt = opt;
447 } 448 }
448 EXPORT_SYMBOL(blk_limits_io_opt); 449 EXPORT_SYMBOL(blk_limits_io_opt);
449 450
450 /** 451 /**
451 * blk_queue_io_opt - set optimal request size for the queue 452 * blk_queue_io_opt - set optimal request size for the queue
452 * @q: the request queue for the device 453 * @q: the request queue for the device
453 * @opt: optimal request size in bytes 454 * @opt: optimal request size in bytes
454 * 455 *
455 * Description: 456 * Description:
456 * Storage devices may report an optimal I/O size, which is the 457 * Storage devices may report an optimal I/O size, which is the
457 * device's preferred unit for sustained I/O. This is rarely reported 458 * device's preferred unit for sustained I/O. This is rarely reported
458 * for disk drives. For RAID arrays it is usually the stripe width or 459 * for disk drives. For RAID arrays it is usually the stripe width or
459 * the internal track size. A properly aligned multiple of 460 * the internal track size. A properly aligned multiple of
460 * optimal_io_size is the preferred request size for workloads where 461 * optimal_io_size is the preferred request size for workloads where
461 * sustained throughput is desired. 462 * sustained throughput is desired.
462 */ 463 */
463 void blk_queue_io_opt(struct request_queue *q, unsigned int opt) 464 void blk_queue_io_opt(struct request_queue *q, unsigned int opt)
464 { 465 {
465 blk_limits_io_opt(&q->limits, opt); 466 blk_limits_io_opt(&q->limits, opt);
466 } 467 }
467 EXPORT_SYMBOL(blk_queue_io_opt); 468 EXPORT_SYMBOL(blk_queue_io_opt);
468 469
469 /* 470 /*
470 * Returns the minimum that is _not_ zero, unless both are zero. 471 * Returns the minimum that is _not_ zero, unless both are zero.
471 */ 472 */
472 #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r)) 473 #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
473 474
474 /** 475 /**
475 * blk_queue_stack_limits - inherit underlying queue limits for stacked drivers 476 * blk_queue_stack_limits - inherit underlying queue limits for stacked drivers
476 * @t: the stacking driver (top) 477 * @t: the stacking driver (top)
477 * @b: the underlying device (bottom) 478 * @b: the underlying device (bottom)
478 **/ 479 **/
479 void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b) 480 void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
480 { 481 {
481 blk_stack_limits(&t->limits, &b->limits, 0); 482 blk_stack_limits(&t->limits, &b->limits, 0);
482 483
483 if (!t->queue_lock) 484 if (!t->queue_lock)
484 WARN_ON_ONCE(1); 485 WARN_ON_ONCE(1);
485 else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) { 486 else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
486 unsigned long flags; 487 unsigned long flags;
487 spin_lock_irqsave(t->queue_lock, flags); 488 spin_lock_irqsave(t->queue_lock, flags);
488 queue_flag_clear(QUEUE_FLAG_CLUSTER, t); 489 queue_flag_clear(QUEUE_FLAG_CLUSTER, t);
489 spin_unlock_irqrestore(t->queue_lock, flags); 490 spin_unlock_irqrestore(t->queue_lock, flags);
490 } 491 }
491 } 492 }
492 EXPORT_SYMBOL(blk_queue_stack_limits); 493 EXPORT_SYMBOL(blk_queue_stack_limits);
493 494
494 /** 495 /**
495 * blk_stack_limits - adjust queue_limits for stacked devices 496 * blk_stack_limits - adjust queue_limits for stacked devices
496 * @t: the stacking driver limits (top) 497 * @t: the stacking driver limits (top)
497 * @b: the underlying queue limits (bottom) 498 * @b: the underlying queue limits (bottom)
498 * @offset: offset to beginning of data within component device 499 * @offset: offset to beginning of data within component device
499 * 500 *
500 * Description: 501 * Description:
501 * Merges two queue_limit structs. Returns 0 if alignment didn't 502 * Merges two queue_limit structs. Returns 0 if alignment didn't
502 * change. Returns -1 if adding the bottom device caused 503 * change. Returns -1 if adding the bottom device caused
503 * misalignment. 504 * misalignment.
504 */ 505 */
505 int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, 506 int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
506 sector_t offset) 507 sector_t offset)
507 { 508 {
508 t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors); 509 t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
509 t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors); 510 t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
510 t->bounce_pfn = min_not_zero(t->bounce_pfn, b->bounce_pfn); 511 t->bounce_pfn = min_not_zero(t->bounce_pfn, b->bounce_pfn);
511 512
512 t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, 513 t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask,
513 b->seg_boundary_mask); 514 b->seg_boundary_mask);
514 515
515 t->max_phys_segments = min_not_zero(t->max_phys_segments, 516 t->max_phys_segments = min_not_zero(t->max_phys_segments,
516 b->max_phys_segments); 517 b->max_phys_segments);
517 518
518 t->max_hw_segments = min_not_zero(t->max_hw_segments, 519 t->max_hw_segments = min_not_zero(t->max_hw_segments,
519 b->max_hw_segments); 520 b->max_hw_segments);
520 521
521 t->max_segment_size = min_not_zero(t->max_segment_size, 522 t->max_segment_size = min_not_zero(t->max_segment_size,
522 b->max_segment_size); 523 b->max_segment_size);
523 524
524 t->logical_block_size = max(t->logical_block_size, 525 t->logical_block_size = max(t->logical_block_size,
525 b->logical_block_size); 526 b->logical_block_size);
526 527
527 t->physical_block_size = max(t->physical_block_size, 528 t->physical_block_size = max(t->physical_block_size,
528 b->physical_block_size); 529 b->physical_block_size);
529 530
530 t->io_min = max(t->io_min, b->io_min); 531 t->io_min = max(t->io_min, b->io_min);
531 t->no_cluster |= b->no_cluster; 532 t->no_cluster |= b->no_cluster;
532 533
533 /* Bottom device offset aligned? */ 534 /* Bottom device offset aligned? */
534 if (offset && 535 if (offset &&
535 (offset & (b->physical_block_size - 1)) != b->alignment_offset) { 536 (offset & (b->physical_block_size - 1)) != b->alignment_offset) {
536 t->misaligned = 1; 537 t->misaligned = 1;
537 return -1; 538 return -1;
538 } 539 }
539 540
540 /* If top has no alignment offset, inherit from bottom */ 541 /* If top has no alignment offset, inherit from bottom */
541 if (!t->alignment_offset) 542 if (!t->alignment_offset)
542 t->alignment_offset = 543 t->alignment_offset =
543 b->alignment_offset & (b->physical_block_size - 1); 544 b->alignment_offset & (b->physical_block_size - 1);
544 545
545 /* Top device aligned on logical block boundary? */ 546 /* Top device aligned on logical block boundary? */
546 if (t->alignment_offset & (t->logical_block_size - 1)) { 547 if (t->alignment_offset & (t->logical_block_size - 1)) {
547 t->misaligned = 1; 548 t->misaligned = 1;
548 return -1; 549 return -1;
549 } 550 }
550 551
551 /* Find lcm() of optimal I/O size */ 552 /* Find lcm() of optimal I/O size */
552 if (t->io_opt && b->io_opt) 553 if (t->io_opt && b->io_opt)
553 t->io_opt = (t->io_opt * b->io_opt) / gcd(t->io_opt, b->io_opt); 554 t->io_opt = (t->io_opt * b->io_opt) / gcd(t->io_opt, b->io_opt);
554 else if (b->io_opt) 555 else if (b->io_opt)
555 t->io_opt = b->io_opt; 556 t->io_opt = b->io_opt;
556 557
557 /* Verify that optimal I/O size is a multiple of io_min */ 558 /* Verify that optimal I/O size is a multiple of io_min */
558 if (t->io_min && t->io_opt % t->io_min) 559 if (t->io_min && t->io_opt % t->io_min)
559 return -1; 560 return -1;
560 561
561 return 0; 562 return 0;
562 } 563 }
563 EXPORT_SYMBOL(blk_stack_limits); 564 EXPORT_SYMBOL(blk_stack_limits);
564 565
565 /** 566 /**
566 * disk_stack_limits - adjust queue limits for stacked drivers 567 * disk_stack_limits - adjust queue limits for stacked drivers
567 * @disk: MD/DM gendisk (top) 568 * @disk: MD/DM gendisk (top)
568 * @bdev: the underlying block device (bottom) 569 * @bdev: the underlying block device (bottom)
569 * @offset: offset to beginning of data within component device 570 * @offset: offset to beginning of data within component device
570 * 571 *
571 * Description: 572 * Description:
572 * Merges the limits for two queues. Returns 0 if alignment 573 * Merges the limits for two queues. Returns 0 if alignment
573 * didn't change. Returns -1 if adding the bottom device caused 574 * didn't change. Returns -1 if adding the bottom device caused
574 * misalignment. 575 * misalignment.
575 */ 576 */
576 void disk_stack_limits(struct gendisk *disk, struct block_device *bdev, 577 void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
577 sector_t offset) 578 sector_t offset)
578 { 579 {
579 struct request_queue *t = disk->queue; 580 struct request_queue *t = disk->queue;
580 struct request_queue *b = bdev_get_queue(bdev); 581 struct request_queue *b = bdev_get_queue(bdev);
581 582
582 offset += get_start_sect(bdev) << 9; 583 offset += get_start_sect(bdev) << 9;
583 584
584 if (blk_stack_limits(&t->limits, &b->limits, offset) < 0) { 585 if (blk_stack_limits(&t->limits, &b->limits, offset) < 0) {
585 char top[BDEVNAME_SIZE], bottom[BDEVNAME_SIZE]; 586 char top[BDEVNAME_SIZE], bottom[BDEVNAME_SIZE];
586 587
587 disk_name(disk, 0, top); 588 disk_name(disk, 0, top);
588 bdevname(bdev, bottom); 589 bdevname(bdev, bottom);
589 590
590 printk(KERN_NOTICE "%s: Warning: Device %s is misaligned\n", 591 printk(KERN_NOTICE "%s: Warning: Device %s is misaligned\n",
591 top, bottom); 592 top, bottom);
592 } 593 }
593 594
594 if (!t->queue_lock) 595 if (!t->queue_lock)
595 WARN_ON_ONCE(1); 596 WARN_ON_ONCE(1);
596 else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) { 597 else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
597 unsigned long flags; 598 unsigned long flags;
598 599
599 spin_lock_irqsave(t->queue_lock, flags); 600 spin_lock_irqsave(t->queue_lock, flags);
600 if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) 601 if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags))
601 queue_flag_clear(QUEUE_FLAG_CLUSTER, t); 602 queue_flag_clear(QUEUE_FLAG_CLUSTER, t);
602 spin_unlock_irqrestore(t->queue_lock, flags); 603 spin_unlock_irqrestore(t->queue_lock, flags);
603 } 604 }
604 } 605 }
605 EXPORT_SYMBOL(disk_stack_limits); 606 EXPORT_SYMBOL(disk_stack_limits);
606 607
607 /** 608 /**
608 * blk_queue_dma_pad - set pad mask 609 * blk_queue_dma_pad - set pad mask
609 * @q: the request queue for the device 610 * @q: the request queue for the device
610 * @mask: pad mask 611 * @mask: pad mask
611 * 612 *
612 * Set dma pad mask. 613 * Set dma pad mask.
613 * 614 *
614 * Appending pad buffer to a request modifies the last entry of a 615 * Appending pad buffer to a request modifies the last entry of a
615 * scatter list such that it includes the pad buffer. 616 * scatter list such that it includes the pad buffer.
616 **/ 617 **/
617 void blk_queue_dma_pad(struct request_queue *q, unsigned int mask) 618 void blk_queue_dma_pad(struct request_queue *q, unsigned int mask)
618 { 619 {
619 q->dma_pad_mask = mask; 620 q->dma_pad_mask = mask;
620 } 621 }
621 EXPORT_SYMBOL(blk_queue_dma_pad); 622 EXPORT_SYMBOL(blk_queue_dma_pad);
622 623
623 /** 624 /**
624 * blk_queue_update_dma_pad - update pad mask 625 * blk_queue_update_dma_pad - update pad mask
625 * @q: the request queue for the device 626 * @q: the request queue for the device
626 * @mask: pad mask 627 * @mask: pad mask
627 * 628 *
628 * Update dma pad mask. 629 * Update dma pad mask.
629 * 630 *
630 * Appending pad buffer to a request modifies the last entry of a 631 * Appending pad buffer to a request modifies the last entry of a
631 * scatter list such that it includes the pad buffer. 632 * scatter list such that it includes the pad buffer.
632 **/ 633 **/
633 void blk_queue_update_dma_pad(struct request_queue *q, unsigned int mask) 634 void blk_queue_update_dma_pad(struct request_queue *q, unsigned int mask)
634 { 635 {
635 if (mask > q->dma_pad_mask) 636 if (mask > q->dma_pad_mask)
636 q->dma_pad_mask = mask; 637 q->dma_pad_mask = mask;
637 } 638 }
638 EXPORT_SYMBOL(blk_queue_update_dma_pad); 639 EXPORT_SYMBOL(blk_queue_update_dma_pad);
639 640
640 /** 641 /**
641 * blk_queue_dma_drain - Set up a drain buffer for excess dma. 642 * blk_queue_dma_drain - Set up a drain buffer for excess dma.
642 * @q: the request queue for the device 643 * @q: the request queue for the device
643 * @dma_drain_needed: fn which returns non-zero if drain is necessary 644 * @dma_drain_needed: fn which returns non-zero if drain is necessary
644 * @buf: physically contiguous buffer 645 * @buf: physically contiguous buffer
645 * @size: size of the buffer in bytes 646 * @size: size of the buffer in bytes
646 * 647 *
647 * Some devices have excess DMA problems and can't simply discard (or 648 * Some devices have excess DMA problems and can't simply discard (or
648 * zero fill) the unwanted piece of the transfer. They have to have a 649 * zero fill) the unwanted piece of the transfer. They have to have a
649 * real area of memory to transfer it into. The use case for this is 650 * real area of memory to transfer it into. The use case for this is
650 * ATAPI devices in DMA mode. If the packet command causes a transfer 651 * ATAPI devices in DMA mode. If the packet command causes a transfer
651 * bigger than the transfer size some HBAs will lock up if there 652 * bigger than the transfer size some HBAs will lock up if there
652 * aren't DMA elements to contain the excess transfer. What this API 653 * aren't DMA elements to contain the excess transfer. What this API
653 * does is adjust the queue so that the buf is always appended 654 * does is adjust the queue so that the buf is always appended
654 * silently to the scatterlist. 655 * silently to the scatterlist.
655 * 656 *
656 * Note: This routine adjusts max_hw_segments to make room for 657 * Note: This routine adjusts max_hw_segments to make room for
657 * appending the drain buffer. If you call 658 * appending the drain buffer. If you call
658 * blk_queue_max_hw_segments() or blk_queue_max_phys_segments() after 659 * blk_queue_max_hw_segments() or blk_queue_max_phys_segments() after
659 * calling this routine, you must set the limit to one fewer than your 660 * calling this routine, you must set the limit to one fewer than your
660 * device can support otherwise there won't be room for the drain 661 * device can support otherwise there won't be room for the drain
661 * buffer. 662 * buffer.
662 */ 663 */
663 int blk_queue_dma_drain(struct request_queue *q, 664 int blk_queue_dma_drain(struct request_queue *q,
664 dma_drain_needed_fn *dma_drain_needed, 665 dma_drain_needed_fn *dma_drain_needed,
665 void *buf, unsigned int size) 666 void *buf, unsigned int size)
666 { 667 {
667 if (queue_max_hw_segments(q) < 2 || queue_max_phys_segments(q) < 2) 668 if (queue_max_hw_segments(q) < 2 || queue_max_phys_segments(q) < 2)
668 return -EINVAL; 669 return -EINVAL;
669 /* make room for appending the drain */ 670 /* make room for appending the drain */
670 blk_queue_max_hw_segments(q, queue_max_hw_segments(q) - 1); 671 blk_queue_max_hw_segments(q, queue_max_hw_segments(q) - 1);
671 blk_queue_max_phys_segments(q, queue_max_phys_segments(q) - 1); 672 blk_queue_max_phys_segments(q, queue_max_phys_segments(q) - 1);
672 q->dma_drain_needed = dma_drain_needed; 673 q->dma_drain_needed = dma_drain_needed;
673 q->dma_drain_buffer = buf; 674 q->dma_drain_buffer = buf;
674 q->dma_drain_size = size; 675 q->dma_drain_size = size;
675 676
676 return 0; 677 return 0;
677 } 678 }
678 EXPORT_SYMBOL_GPL(blk_queue_dma_drain); 679 EXPORT_SYMBOL_GPL(blk_queue_dma_drain);
679 680
680 /** 681 /**
681 * blk_queue_segment_boundary - set boundary rules for segment merging 682 * blk_queue_segment_boundary - set boundary rules for segment merging
682 * @q: the request queue for the device 683 * @q: the request queue for the device
683 * @mask: the memory boundary mask 684 * @mask: the memory boundary mask
684 **/ 685 **/
685 void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask) 686 void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
686 { 687 {
687 if (mask < PAGE_CACHE_SIZE - 1) { 688 if (mask < PAGE_CACHE_SIZE - 1) {
688 mask = PAGE_CACHE_SIZE - 1; 689 mask = PAGE_CACHE_SIZE - 1;
689 printk(KERN_INFO "%s: set to minimum %lx\n", 690 printk(KERN_INFO "%s: set to minimum %lx\n",
690 __func__, mask); 691 __func__, mask);
691 } 692 }
692 693
693 q->limits.seg_boundary_mask = mask; 694 q->limits.seg_boundary_mask = mask;
694 } 695 }
695 EXPORT_SYMBOL(blk_queue_segment_boundary); 696 EXPORT_SYMBOL(blk_queue_segment_boundary);
696 697
697 /** 698 /**
698 * blk_queue_dma_alignment - set dma length and memory alignment 699 * blk_queue_dma_alignment - set dma length and memory alignment
699 * @q: the request queue for the device 700 * @q: the request queue for the device
700 * @mask: alignment mask 701 * @mask: alignment mask
701 * 702 *
702 * description: 703 * description:
703 * set required memory and length alignment for direct dma transactions. 704 * set required memory and length alignment for direct dma transactions.
704 * this is used when building direct io requests for the queue. 705 * this is used when building direct io requests for the queue.
705 * 706 *
706 **/ 707 **/
707 void blk_queue_dma_alignment(struct request_queue *q, int mask) 708 void blk_queue_dma_alignment(struct request_queue *q, int mask)
708 { 709 {
709 q->dma_alignment = mask; 710 q->dma_alignment = mask;
710 } 711 }
711 EXPORT_SYMBOL(blk_queue_dma_alignment); 712 EXPORT_SYMBOL(blk_queue_dma_alignment);
712 713
713 /** 714 /**
714 * blk_queue_update_dma_alignment - update dma length and memory alignment 715 * blk_queue_update_dma_alignment - update dma length and memory alignment
715 * @q: the request queue for the device 716 * @q: the request queue for the device
716 * @mask: alignment mask 717 * @mask: alignment mask
717 * 718 *
718 * description: 719 * description:
719 * update required memory and length alignment for direct dma transactions. 720 * update required memory and length alignment for direct dma transactions.
720 * If the requested alignment is larger than the current alignment, then 721 * If the requested alignment is larger than the current alignment, then
721 * the current queue alignment is updated to the new value, otherwise it 722 * the current queue alignment is updated to the new value, otherwise it
722 * is left alone. The design of this is to allow multiple objects 723 * is left alone. The design of this is to allow multiple objects
723 * (driver, device, transport etc) to set their respective 724 * (driver, device, transport etc) to set their respective
724 * alignments without having them interfere. 725 * alignments without having them interfere.
725 * 726 *
726 **/ 727 **/
727 void blk_queue_update_dma_alignment(struct request_queue *q, int mask) 728 void blk_queue_update_dma_alignment(struct request_queue *q, int mask)
728 { 729 {
729 BUG_ON(mask > PAGE_SIZE); 730 BUG_ON(mask > PAGE_SIZE);
730 731
731 if (mask > q->dma_alignment) 732 if (mask > q->dma_alignment)
732 q->dma_alignment = mask; 733 q->dma_alignment = mask;
733 } 734 }
734 EXPORT_SYMBOL(blk_queue_update_dma_alignment); 735 EXPORT_SYMBOL(blk_queue_update_dma_alignment);
735 736
736 static int __init blk_settings_init(void) 737 static int __init blk_settings_init(void)
737 { 738 {
738 blk_max_low_pfn = max_low_pfn - 1; 739 blk_max_low_pfn = max_low_pfn - 1;
739 blk_max_pfn = max_pfn - 1; 740 blk_max_pfn = max_pfn - 1;
740 return 0; 741 return 0;
741 } 742 }
742 subsys_initcall(blk_settings_init); 743 subsys_initcall(blk_settings_init);
743 744