Annotation of /trunk/kernel-magellan/patches-3.2/0106-3.2.7-all-fixes.patch
Parent Directory | Revision Log
Revision 1663 -
(hide annotations)
(download)
Fri Mar 2 10:03:33 2012 UTC (12 years, 6 months ago) by niro
File size: 32204 byte(s)
Fri Mar 2 10:03:33 2012 UTC (12 years, 6 months ago) by niro
File size: 32204 byte(s)
-added more upstream patches
1 | niro | 1663 | diff --git a/arch/x86/pci/xen.c b/arch/x86/pci/xen.c |
2 | index 492ade8..d99346e 100644 | ||
3 | --- a/arch/x86/pci/xen.c | ||
4 | +++ b/arch/x86/pci/xen.c | ||
5 | @@ -374,7 +374,7 @@ int __init pci_xen_init(void) | ||
6 | |||
7 | int __init pci_xen_hvm_init(void) | ||
8 | { | ||
9 | - if (!xen_feature(XENFEAT_hvm_pirqs)) | ||
10 | + if (!xen_have_vector_callback || !xen_feature(XENFEAT_hvm_pirqs)) | ||
11 | return 0; | ||
12 | |||
13 | #ifdef CONFIG_ACPI | ||
14 | diff --git a/crypto/sha512_generic.c b/crypto/sha512_generic.c | ||
15 | index 88f160b..107f6f7 100644 | ||
16 | --- a/crypto/sha512_generic.c | ||
17 | +++ b/crypto/sha512_generic.c | ||
18 | @@ -31,11 +31,6 @@ static inline u64 Maj(u64 x, u64 y, u64 z) | ||
19 | return (x & y) | (z & (x | y)); | ||
20 | } | ||
21 | |||
22 | -static inline u64 RORu64(u64 x, u64 y) | ||
23 | -{ | ||
24 | - return (x >> y) | (x << (64 - y)); | ||
25 | -} | ||
26 | - | ||
27 | static const u64 sha512_K[80] = { | ||
28 | 0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL, | ||
29 | 0xe9b5dba58189dbbcULL, 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL, | ||
30 | @@ -66,10 +61,10 @@ static const u64 sha512_K[80] = { | ||
31 | 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL, | ||
32 | }; | ||
33 | |||
34 | -#define e0(x) (RORu64(x,28) ^ RORu64(x,34) ^ RORu64(x,39)) | ||
35 | -#define e1(x) (RORu64(x,14) ^ RORu64(x,18) ^ RORu64(x,41)) | ||
36 | -#define s0(x) (RORu64(x, 1) ^ RORu64(x, 8) ^ (x >> 7)) | ||
37 | -#define s1(x) (RORu64(x,19) ^ RORu64(x,61) ^ (x >> 6)) | ||
38 | +#define e0(x) (ror64(x,28) ^ ror64(x,34) ^ ror64(x,39)) | ||
39 | +#define e1(x) (ror64(x,14) ^ ror64(x,18) ^ ror64(x,41)) | ||
40 | +#define s0(x) (ror64(x, 1) ^ ror64(x, 8) ^ (x >> 7)) | ||
41 | +#define s1(x) (ror64(x,19) ^ ror64(x,61) ^ (x >> 6)) | ||
42 | |||
43 | static inline void LOAD_OP(int I, u64 *W, const u8 *input) | ||
44 | { | ||
45 | @@ -78,7 +73,7 @@ static inline void LOAD_OP(int I, u64 *W, const u8 *input) | ||
46 | |||
47 | static inline void BLEND_OP(int I, u64 *W) | ||
48 | { | ||
49 | - W[I % 16] += s1(W[(I-2) % 16]) + W[(I-7) % 16] + s0(W[(I-15) % 16]); | ||
50 | + W[I & 15] += s1(W[(I-2) & 15]) + W[(I-7) & 15] + s0(W[(I-15) & 15]); | ||
51 | } | ||
52 | |||
53 | static void | ||
54 | @@ -89,46 +84,42 @@ sha512_transform(u64 *state, const u8 *input) | ||
55 | int i; | ||
56 | u64 W[16]; | ||
57 | |||
58 | - /* load the input */ | ||
59 | - for (i = 0; i < 16; i++) | ||
60 | - LOAD_OP(i, W, input); | ||
61 | - | ||
62 | /* load the state into our registers */ | ||
63 | a=state[0]; b=state[1]; c=state[2]; d=state[3]; | ||
64 | e=state[4]; f=state[5]; g=state[6]; h=state[7]; | ||
65 | |||
66 | -#define SHA512_0_15(i, a, b, c, d, e, f, g, h) \ | ||
67 | - t1 = h + e1(e) + Ch(e, f, g) + sha512_K[i] + W[i]; \ | ||
68 | - t2 = e0(a) + Maj(a, b, c); \ | ||
69 | - d += t1; \ | ||
70 | - h = t1 + t2 | ||
71 | - | ||
72 | -#define SHA512_16_79(i, a, b, c, d, e, f, g, h) \ | ||
73 | - BLEND_OP(i, W); \ | ||
74 | - t1 = h + e1(e) + Ch(e, f, g) + sha512_K[i] + W[(i)%16]; \ | ||
75 | - t2 = e0(a) + Maj(a, b, c); \ | ||
76 | - d += t1; \ | ||
77 | - h = t1 + t2 | ||
78 | - | ||
79 | - for (i = 0; i < 16; i += 8) { | ||
80 | - SHA512_0_15(i, a, b, c, d, e, f, g, h); | ||
81 | - SHA512_0_15(i + 1, h, a, b, c, d, e, f, g); | ||
82 | - SHA512_0_15(i + 2, g, h, a, b, c, d, e, f); | ||
83 | - SHA512_0_15(i + 3, f, g, h, a, b, c, d, e); | ||
84 | - SHA512_0_15(i + 4, e, f, g, h, a, b, c, d); | ||
85 | - SHA512_0_15(i + 5, d, e, f, g, h, a, b, c); | ||
86 | - SHA512_0_15(i + 6, c, d, e, f, g, h, a, b); | ||
87 | - SHA512_0_15(i + 7, b, c, d, e, f, g, h, a); | ||
88 | - } | ||
89 | - for (i = 16; i < 80; i += 8) { | ||
90 | - SHA512_16_79(i, a, b, c, d, e, f, g, h); | ||
91 | - SHA512_16_79(i + 1, h, a, b, c, d, e, f, g); | ||
92 | - SHA512_16_79(i + 2, g, h, a, b, c, d, e, f); | ||
93 | - SHA512_16_79(i + 3, f, g, h, a, b, c, d, e); | ||
94 | - SHA512_16_79(i + 4, e, f, g, h, a, b, c, d); | ||
95 | - SHA512_16_79(i + 5, d, e, f, g, h, a, b, c); | ||
96 | - SHA512_16_79(i + 6, c, d, e, f, g, h, a, b); | ||
97 | - SHA512_16_79(i + 7, b, c, d, e, f, g, h, a); | ||
98 | + /* now iterate */ | ||
99 | + for (i=0; i<80; i+=8) { | ||
100 | + if (!(i & 8)) { | ||
101 | + int j; | ||
102 | + | ||
103 | + if (i < 16) { | ||
104 | + /* load the input */ | ||
105 | + for (j = 0; j < 16; j++) | ||
106 | + LOAD_OP(i + j, W, input); | ||
107 | + } else { | ||
108 | + for (j = 0; j < 16; j++) { | ||
109 | + BLEND_OP(i + j, W); | ||
110 | + } | ||
111 | + } | ||
112 | + } | ||
113 | + | ||
114 | + t1 = h + e1(e) + Ch(e,f,g) + sha512_K[i ] + W[(i & 15)]; | ||
115 | + t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2; | ||
116 | + t1 = g + e1(d) + Ch(d,e,f) + sha512_K[i+1] + W[(i & 15) + 1]; | ||
117 | + t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2; | ||
118 | + t1 = f + e1(c) + Ch(c,d,e) + sha512_K[i+2] + W[(i & 15) + 2]; | ||
119 | + t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2; | ||
120 | + t1 = e + e1(b) + Ch(b,c,d) + sha512_K[i+3] + W[(i & 15) + 3]; | ||
121 | + t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2; | ||
122 | + t1 = d + e1(a) + Ch(a,b,c) + sha512_K[i+4] + W[(i & 15) + 4]; | ||
123 | + t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2; | ||
124 | + t1 = c + e1(h) + Ch(h,a,b) + sha512_K[i+5] + W[(i & 15) + 5]; | ||
125 | + t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2; | ||
126 | + t1 = b + e1(g) + Ch(g,h,a) + sha512_K[i+6] + W[(i & 15) + 6]; | ||
127 | + t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2; | ||
128 | + t1 = a + e1(f) + Ch(f,g,h) + sha512_K[i+7] + W[(i & 15) + 7]; | ||
129 | + t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2; | ||
130 | } | ||
131 | |||
132 | state[0] += a; state[1] += b; state[2] += c; state[3] += d; | ||
133 | diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c | ||
134 | index db3b461..94f860c 100644 | ||
135 | --- a/drivers/gpu/drm/i915/intel_dp.c | ||
136 | +++ b/drivers/gpu/drm/i915/intel_dp.c | ||
137 | @@ -208,17 +208,8 @@ intel_dp_link_clock(uint8_t link_bw) | ||
138 | */ | ||
139 | |||
140 | static int | ||
141 | -intel_dp_link_required(struct intel_dp *intel_dp, int pixel_clock, int check_bpp) | ||
142 | +intel_dp_link_required(int pixel_clock, int bpp) | ||
143 | { | ||
144 | - struct drm_crtc *crtc = intel_dp->base.base.crtc; | ||
145 | - struct intel_crtc *intel_crtc = to_intel_crtc(crtc); | ||
146 | - int bpp = 24; | ||
147 | - | ||
148 | - if (check_bpp) | ||
149 | - bpp = check_bpp; | ||
150 | - else if (intel_crtc) | ||
151 | - bpp = intel_crtc->bpp; | ||
152 | - | ||
153 | return (pixel_clock * bpp + 9) / 10; | ||
154 | } | ||
155 | |||
156 | @@ -245,12 +236,11 @@ intel_dp_mode_valid(struct drm_connector *connector, | ||
157 | return MODE_PANEL; | ||
158 | } | ||
159 | |||
160 | - mode_rate = intel_dp_link_required(intel_dp, mode->clock, 0); | ||
161 | + mode_rate = intel_dp_link_required(mode->clock, 24); | ||
162 | max_rate = intel_dp_max_data_rate(max_link_clock, max_lanes); | ||
163 | |||
164 | if (mode_rate > max_rate) { | ||
165 | - mode_rate = intel_dp_link_required(intel_dp, | ||
166 | - mode->clock, 18); | ||
167 | + mode_rate = intel_dp_link_required(mode->clock, 18); | ||
168 | if (mode_rate > max_rate) | ||
169 | return MODE_CLOCK_HIGH; | ||
170 | else | ||
171 | @@ -683,7 +673,7 @@ intel_dp_mode_fixup(struct drm_encoder *encoder, struct drm_display_mode *mode, | ||
172 | int lane_count, clock; | ||
173 | int max_lane_count = intel_dp_max_lane_count(intel_dp); | ||
174 | int max_clock = intel_dp_max_link_bw(intel_dp) == DP_LINK_BW_2_7 ? 1 : 0; | ||
175 | - int bpp = mode->private_flags & INTEL_MODE_DP_FORCE_6BPC ? 18 : 0; | ||
176 | + int bpp = mode->private_flags & INTEL_MODE_DP_FORCE_6BPC ? 18 : 24; | ||
177 | static int bws[2] = { DP_LINK_BW_1_62, DP_LINK_BW_2_7 }; | ||
178 | |||
179 | if (is_edp(intel_dp) && intel_dp->panel_fixed_mode) { | ||
180 | @@ -701,7 +691,7 @@ intel_dp_mode_fixup(struct drm_encoder *encoder, struct drm_display_mode *mode, | ||
181 | for (clock = 0; clock <= max_clock; clock++) { | ||
182 | int link_avail = intel_dp_max_data_rate(intel_dp_link_clock(bws[clock]), lane_count); | ||
183 | |||
184 | - if (intel_dp_link_required(intel_dp, mode->clock, bpp) | ||
185 | + if (intel_dp_link_required(mode->clock, bpp) | ||
186 | <= link_avail) { | ||
187 | intel_dp->link_bw = bws[clock]; | ||
188 | intel_dp->lane_count = lane_count; | ||
189 | diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c | ||
190 | index e441911..b83f745 100644 | ||
191 | --- a/drivers/gpu/drm/i915/intel_lvds.c | ||
192 | +++ b/drivers/gpu/drm/i915/intel_lvds.c | ||
193 | @@ -694,6 +694,14 @@ static const struct dmi_system_id intel_no_lvds[] = { | ||
194 | }, | ||
195 | { | ||
196 | .callback = intel_no_lvds_dmi_callback, | ||
197 | + .ident = "AOpen i45GMx-I", | ||
198 | + .matches = { | ||
199 | + DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"), | ||
200 | + DMI_MATCH(DMI_BOARD_NAME, "i45GMx-I"), | ||
201 | + }, | ||
202 | + }, | ||
203 | + { | ||
204 | + .callback = intel_no_lvds_dmi_callback, | ||
205 | .ident = "Aopen i945GTt-VFA", | ||
206 | .matches = { | ||
207 | DMI_MATCH(DMI_PRODUCT_VERSION, "AO00001JW"), | ||
208 | diff --git a/drivers/hwmon/f75375s.c b/drivers/hwmon/f75375s.c | ||
209 | index 95cbfb3..e4ab491 100644 | ||
210 | --- a/drivers/hwmon/f75375s.c | ||
211 | +++ b/drivers/hwmon/f75375s.c | ||
212 | @@ -159,7 +159,7 @@ static inline void f75375_write8(struct i2c_client *client, u8 reg, | ||
213 | static inline void f75375_write16(struct i2c_client *client, u8 reg, | ||
214 | u16 value) | ||
215 | { | ||
216 | - int err = i2c_smbus_write_byte_data(client, reg, (value << 8)); | ||
217 | + int err = i2c_smbus_write_byte_data(client, reg, (value >> 8)); | ||
218 | if (err) | ||
219 | return; | ||
220 | i2c_smbus_write_byte_data(client, reg + 1, (value & 0xFF)); | ||
221 | @@ -311,7 +311,7 @@ static int set_pwm_enable_direct(struct i2c_client *client, int nr, int val) | ||
222 | fanmode |= (3 << FAN_CTRL_MODE(nr)); | ||
223 | break; | ||
224 | case 2: /* AUTOMATIC*/ | ||
225 | - fanmode |= (2 << FAN_CTRL_MODE(nr)); | ||
226 | + fanmode |= (1 << FAN_CTRL_MODE(nr)); | ||
227 | break; | ||
228 | case 3: /* fan speed */ | ||
229 | break; | ||
230 | diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c | ||
231 | index a7ee502..72bc756 100644 | ||
232 | --- a/drivers/mmc/host/atmel-mci.c | ||
233 | +++ b/drivers/mmc/host/atmel-mci.c | ||
234 | @@ -965,11 +965,14 @@ static void atmci_start_request(struct atmel_mci *host, | ||
235 | host->data_status = 0; | ||
236 | |||
237 | if (host->need_reset) { | ||
238 | + iflags = atmci_readl(host, ATMCI_IMR); | ||
239 | + iflags &= (ATMCI_SDIOIRQA | ATMCI_SDIOIRQB); | ||
240 | atmci_writel(host, ATMCI_CR, ATMCI_CR_SWRST); | ||
241 | atmci_writel(host, ATMCI_CR, ATMCI_CR_MCIEN); | ||
242 | atmci_writel(host, ATMCI_MR, host->mode_reg); | ||
243 | if (host->caps.has_cfg_reg) | ||
244 | atmci_writel(host, ATMCI_CFG, host->cfg_reg); | ||
245 | + atmci_writel(host, ATMCI_IER, iflags); | ||
246 | host->need_reset = false; | ||
247 | } | ||
248 | atmci_writel(host, ATMCI_SDCR, slot->sdc_reg); | ||
249 | diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c | ||
250 | index 3aaeb08..baf3d42 100644 | ||
251 | --- a/drivers/mmc/host/dw_mmc.c | ||
252 | +++ b/drivers/mmc/host/dw_mmc.c | ||
253 | @@ -22,7 +22,6 @@ | ||
254 | #include <linux/ioport.h> | ||
255 | #include <linux/module.h> | ||
256 | #include <linux/platform_device.h> | ||
257 | -#include <linux/scatterlist.h> | ||
258 | #include <linux/seq_file.h> | ||
259 | #include <linux/slab.h> | ||
260 | #include <linux/stat.h> | ||
261 | @@ -502,8 +501,14 @@ static void dw_mci_submit_data(struct dw_mci *host, struct mmc_data *data) | ||
262 | host->dir_status = DW_MCI_SEND_STATUS; | ||
263 | |||
264 | if (dw_mci_submit_data_dma(host, data)) { | ||
265 | + int flags = SG_MITER_ATOMIC; | ||
266 | + if (host->data->flags & MMC_DATA_READ) | ||
267 | + flags |= SG_MITER_TO_SG; | ||
268 | + else | ||
269 | + flags |= SG_MITER_FROM_SG; | ||
270 | + | ||
271 | + sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags); | ||
272 | host->sg = data->sg; | ||
273 | - host->pio_offset = 0; | ||
274 | host->part_buf_start = 0; | ||
275 | host->part_buf_count = 0; | ||
276 | |||
277 | @@ -953,6 +958,7 @@ static void dw_mci_tasklet_func(unsigned long priv) | ||
278 | * generates a block interrupt, hence setting | ||
279 | * the scatter-gather pointer to NULL. | ||
280 | */ | ||
281 | + sg_miter_stop(&host->sg_miter); | ||
282 | host->sg = NULL; | ||
283 | ctrl = mci_readl(host, CTRL); | ||
284 | ctrl |= SDMMC_CTRL_FIFO_RESET; | ||
285 | @@ -1286,54 +1292,44 @@ static void dw_mci_pull_data(struct dw_mci *host, void *buf, int cnt) | ||
286 | |||
287 | static void dw_mci_read_data_pio(struct dw_mci *host) | ||
288 | { | ||
289 | - struct scatterlist *sg = host->sg; | ||
290 | - void *buf = sg_virt(sg); | ||
291 | - unsigned int offset = host->pio_offset; | ||
292 | + struct sg_mapping_iter *sg_miter = &host->sg_miter; | ||
293 | + void *buf; | ||
294 | + unsigned int offset; | ||
295 | struct mmc_data *data = host->data; | ||
296 | int shift = host->data_shift; | ||
297 | u32 status; | ||
298 | unsigned int nbytes = 0, len; | ||
299 | + unsigned int remain, fcnt; | ||
300 | |||
301 | do { | ||
302 | - len = host->part_buf_count + | ||
303 | - (SDMMC_GET_FCNT(mci_readl(host, STATUS)) << shift); | ||
304 | - if (offset + len <= sg->length) { | ||
305 | + if (!sg_miter_next(sg_miter)) | ||
306 | + goto done; | ||
307 | + | ||
308 | + host->sg = sg_miter->__sg; | ||
309 | + buf = sg_miter->addr; | ||
310 | + remain = sg_miter->length; | ||
311 | + offset = 0; | ||
312 | + | ||
313 | + do { | ||
314 | + fcnt = (SDMMC_GET_FCNT(mci_readl(host, STATUS)) | ||
315 | + << shift) + host->part_buf_count; | ||
316 | + len = min(remain, fcnt); | ||
317 | + if (!len) | ||
318 | + break; | ||
319 | dw_mci_pull_data(host, (void *)(buf + offset), len); | ||
320 | - | ||
321 | offset += len; | ||
322 | nbytes += len; | ||
323 | - | ||
324 | - if (offset == sg->length) { | ||
325 | - flush_dcache_page(sg_page(sg)); | ||
326 | - host->sg = sg = sg_next(sg); | ||
327 | - if (!sg) | ||
328 | - goto done; | ||
329 | - | ||
330 | - offset = 0; | ||
331 | - buf = sg_virt(sg); | ||
332 | - } | ||
333 | - } else { | ||
334 | - unsigned int remaining = sg->length - offset; | ||
335 | - dw_mci_pull_data(host, (void *)(buf + offset), | ||
336 | - remaining); | ||
337 | - nbytes += remaining; | ||
338 | - | ||
339 | - flush_dcache_page(sg_page(sg)); | ||
340 | - host->sg = sg = sg_next(sg); | ||
341 | - if (!sg) | ||
342 | - goto done; | ||
343 | - | ||
344 | - offset = len - remaining; | ||
345 | - buf = sg_virt(sg); | ||
346 | - dw_mci_pull_data(host, buf, offset); | ||
347 | - nbytes += offset; | ||
348 | - } | ||
349 | + remain -= len; | ||
350 | + } while (remain); | ||
351 | + sg_miter->consumed = offset; | ||
352 | |||
353 | status = mci_readl(host, MINTSTS); | ||
354 | mci_writel(host, RINTSTS, SDMMC_INT_RXDR); | ||
355 | if (status & DW_MCI_DATA_ERROR_FLAGS) { | ||
356 | host->data_status = status; | ||
357 | data->bytes_xfered += nbytes; | ||
358 | + sg_miter_stop(sg_miter); | ||
359 | + host->sg = NULL; | ||
360 | smp_wmb(); | ||
361 | |||
362 | set_bit(EVENT_DATA_ERROR, &host->pending_events); | ||
363 | @@ -1342,65 +1338,66 @@ static void dw_mci_read_data_pio(struct dw_mci *host) | ||
364 | return; | ||
365 | } | ||
366 | } while (status & SDMMC_INT_RXDR); /*if the RXDR is ready read again*/ | ||
367 | - host->pio_offset = offset; | ||
368 | data->bytes_xfered += nbytes; | ||
369 | + | ||
370 | + if (!remain) { | ||
371 | + if (!sg_miter_next(sg_miter)) | ||
372 | + goto done; | ||
373 | + sg_miter->consumed = 0; | ||
374 | + } | ||
375 | + sg_miter_stop(sg_miter); | ||
376 | return; | ||
377 | |||
378 | done: | ||
379 | data->bytes_xfered += nbytes; | ||
380 | + sg_miter_stop(sg_miter); | ||
381 | + host->sg = NULL; | ||
382 | smp_wmb(); | ||
383 | set_bit(EVENT_XFER_COMPLETE, &host->pending_events); | ||
384 | } | ||
385 | |||
386 | static void dw_mci_write_data_pio(struct dw_mci *host) | ||
387 | { | ||
388 | - struct scatterlist *sg = host->sg; | ||
389 | - void *buf = sg_virt(sg); | ||
390 | - unsigned int offset = host->pio_offset; | ||
391 | + struct sg_mapping_iter *sg_miter = &host->sg_miter; | ||
392 | + void *buf; | ||
393 | + unsigned int offset; | ||
394 | struct mmc_data *data = host->data; | ||
395 | int shift = host->data_shift; | ||
396 | u32 status; | ||
397 | unsigned int nbytes = 0, len; | ||
398 | + unsigned int fifo_depth = host->fifo_depth; | ||
399 | + unsigned int remain, fcnt; | ||
400 | |||
401 | do { | ||
402 | - len = ((host->fifo_depth - | ||
403 | - SDMMC_GET_FCNT(mci_readl(host, STATUS))) << shift) | ||
404 | - - host->part_buf_count; | ||
405 | - if (offset + len <= sg->length) { | ||
406 | + if (!sg_miter_next(sg_miter)) | ||
407 | + goto done; | ||
408 | + | ||
409 | + host->sg = sg_miter->__sg; | ||
410 | + buf = sg_miter->addr; | ||
411 | + remain = sg_miter->length; | ||
412 | + offset = 0; | ||
413 | + | ||
414 | + do { | ||
415 | + fcnt = ((fifo_depth - | ||
416 | + SDMMC_GET_FCNT(mci_readl(host, STATUS))) | ||
417 | + << shift) - host->part_buf_count; | ||
418 | + len = min(remain, fcnt); | ||
419 | + if (!len) | ||
420 | + break; | ||
421 | host->push_data(host, (void *)(buf + offset), len); | ||
422 | - | ||
423 | offset += len; | ||
424 | nbytes += len; | ||
425 | - if (offset == sg->length) { | ||
426 | - host->sg = sg = sg_next(sg); | ||
427 | - if (!sg) | ||
428 | - goto done; | ||
429 | - | ||
430 | - offset = 0; | ||
431 | - buf = sg_virt(sg); | ||
432 | - } | ||
433 | - } else { | ||
434 | - unsigned int remaining = sg->length - offset; | ||
435 | - | ||
436 | - host->push_data(host, (void *)(buf + offset), | ||
437 | - remaining); | ||
438 | - nbytes += remaining; | ||
439 | - | ||
440 | - host->sg = sg = sg_next(sg); | ||
441 | - if (!sg) | ||
442 | - goto done; | ||
443 | - | ||
444 | - offset = len - remaining; | ||
445 | - buf = sg_virt(sg); | ||
446 | - host->push_data(host, (void *)buf, offset); | ||
447 | - nbytes += offset; | ||
448 | - } | ||
449 | + remain -= len; | ||
450 | + } while (remain); | ||
451 | + sg_miter->consumed = offset; | ||
452 | |||
453 | status = mci_readl(host, MINTSTS); | ||
454 | mci_writel(host, RINTSTS, SDMMC_INT_TXDR); | ||
455 | if (status & DW_MCI_DATA_ERROR_FLAGS) { | ||
456 | host->data_status = status; | ||
457 | data->bytes_xfered += nbytes; | ||
458 | + sg_miter_stop(sg_miter); | ||
459 | + host->sg = NULL; | ||
460 | |||
461 | smp_wmb(); | ||
462 | |||
463 | @@ -1410,12 +1407,20 @@ static void dw_mci_write_data_pio(struct dw_mci *host) | ||
464 | return; | ||
465 | } | ||
466 | } while (status & SDMMC_INT_TXDR); /* if TXDR write again */ | ||
467 | - host->pio_offset = offset; | ||
468 | data->bytes_xfered += nbytes; | ||
469 | + | ||
470 | + if (!remain) { | ||
471 | + if (!sg_miter_next(sg_miter)) | ||
472 | + goto done; | ||
473 | + sg_miter->consumed = 0; | ||
474 | + } | ||
475 | + sg_miter_stop(sg_miter); | ||
476 | return; | ||
477 | |||
478 | done: | ||
479 | data->bytes_xfered += nbytes; | ||
480 | + sg_miter_stop(sg_miter); | ||
481 | + host->sg = NULL; | ||
482 | smp_wmb(); | ||
483 | set_bit(EVENT_XFER_COMPLETE, &host->pending_events); | ||
484 | } | ||
485 | @@ -1618,6 +1623,7 @@ static void dw_mci_work_routine_card(struct work_struct *work) | ||
486 | * block interrupt, hence setting the | ||
487 | * scatter-gather pointer to NULL. | ||
488 | */ | ||
489 | + sg_miter_stop(&host->sg_miter); | ||
490 | host->sg = NULL; | ||
491 | |||
492 | ctrl = mci_readl(host, CTRL); | ||
493 | diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c | ||
494 | index ced5444..222954d 100644 | ||
495 | --- a/drivers/net/ethernet/intel/igb/igb_main.c | ||
496 | +++ b/drivers/net/ethernet/intel/igb/igb_main.c | ||
497 | @@ -4965,7 +4965,8 @@ static int igb_find_enabled_vfs(struct igb_adapter *adapter) | ||
498 | vf_devfn = pdev->devfn + 0x80; | ||
499 | pvfdev = pci_get_device(hw->vendor_id, device_id, NULL); | ||
500 | while (pvfdev) { | ||
501 | - if (pvfdev->devfn == vf_devfn) | ||
502 | + if (pvfdev->devfn == vf_devfn && | ||
503 | + (pvfdev->bus->number >= pdev->bus->number)) | ||
504 | vfs_found++; | ||
505 | vf_devfn += vf_stride; | ||
506 | pvfdev = pci_get_device(hw->vendor_id, | ||
507 | diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c | ||
508 | index 00fcd39..e571356 100644 | ||
509 | --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c | ||
510 | +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c | ||
511 | @@ -67,7 +67,8 @@ static int ixgbe_find_enabled_vfs(struct ixgbe_adapter *adapter) | ||
512 | vf_devfn = pdev->devfn + 0x80; | ||
513 | pvfdev = pci_get_device(IXGBE_INTEL_VENDOR_ID, device_id, NULL); | ||
514 | while (pvfdev) { | ||
515 | - if (pvfdev->devfn == vf_devfn) | ||
516 | + if (pvfdev->devfn == vf_devfn && | ||
517 | + (pvfdev->bus->number >= pdev->bus->number)) | ||
518 | vfs_found++; | ||
519 | vf_devfn += 2; | ||
520 | pvfdev = pci_get_device(IXGBE_INTEL_VENDOR_ID, | ||
521 | diff --git a/drivers/net/ethernet/toshiba/Kconfig b/drivers/net/ethernet/toshiba/Kconfig | ||
522 | index 0517647..74acb5c 100644 | ||
523 | --- a/drivers/net/ethernet/toshiba/Kconfig | ||
524 | +++ b/drivers/net/ethernet/toshiba/Kconfig | ||
525 | @@ -5,7 +5,7 @@ | ||
526 | config NET_VENDOR_TOSHIBA | ||
527 | bool "Toshiba devices" | ||
528 | default y | ||
529 | - depends on PCI && (PPC_IBM_CELL_BLADE || PPC_CELLEB) || PPC_PS3 | ||
530 | + depends on PCI && (PPC_IBM_CELL_BLADE || PPC_CELLEB || MIPS) || PPC_PS3 | ||
531 | ---help--- | ||
532 | If you have a network (Ethernet) card belonging to this class, say Y | ||
533 | and read the Ethernet-HOWTO, available from | ||
534 | diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c | ||
535 | index 8873c6e..8b0c2ca 100644 | ||
536 | --- a/drivers/net/wireless/ath/ath9k/hw.c | ||
537 | +++ b/drivers/net/wireless/ath/ath9k/hw.c | ||
538 | @@ -1034,13 +1034,16 @@ void ath9k_hw_init_global_settings(struct ath_hw *ah) | ||
539 | |||
540 | /* | ||
541 | * Workaround for early ACK timeouts, add an offset to match the | ||
542 | - * initval's 64us ack timeout value. | ||
543 | + * initval's 64us ack timeout value. Use 48us for the CTS timeout. | ||
544 | * This was initially only meant to work around an issue with delayed | ||
545 | * BA frames in some implementations, but it has been found to fix ACK | ||
546 | * timeout issues in other cases as well. | ||
547 | */ | ||
548 | - if (conf->channel && conf->channel->band == IEEE80211_BAND_2GHZ) | ||
549 | + if (conf->channel && conf->channel->band == IEEE80211_BAND_2GHZ) { | ||
550 | acktimeout += 64 - sifstime - ah->slottime; | ||
551 | + ctstimeout += 48 - sifstime - ah->slottime; | ||
552 | + } | ||
553 | + | ||
554 | |||
555 | ath9k_hw_set_sifs_time(ah, sifstime); | ||
556 | ath9k_hw_setslottime(ah, slottime); | ||
557 | diff --git a/drivers/net/wireless/ath/ath9k/init.c b/drivers/net/wireless/ath/ath9k/init.c | ||
558 | index d4c909f..57622e0 100644 | ||
559 | --- a/drivers/net/wireless/ath/ath9k/init.c | ||
560 | +++ b/drivers/net/wireless/ath/ath9k/init.c | ||
561 | @@ -775,6 +775,11 @@ int ath9k_init_device(u16 devid, struct ath_softc *sc, | ||
562 | ARRAY_SIZE(ath9k_tpt_blink)); | ||
563 | #endif | ||
564 | |||
565 | + INIT_WORK(&sc->hw_reset_work, ath_reset_work); | ||
566 | + INIT_WORK(&sc->hw_check_work, ath_hw_check); | ||
567 | + INIT_WORK(&sc->paprd_work, ath_paprd_calibrate); | ||
568 | + INIT_DELAYED_WORK(&sc->hw_pll_work, ath_hw_pll_work); | ||
569 | + | ||
570 | /* Register with mac80211 */ | ||
571 | error = ieee80211_register_hw(hw); | ||
572 | if (error) | ||
573 | @@ -793,10 +798,6 @@ int ath9k_init_device(u16 devid, struct ath_softc *sc, | ||
574 | goto error_world; | ||
575 | } | ||
576 | |||
577 | - INIT_WORK(&sc->hw_reset_work, ath_reset_work); | ||
578 | - INIT_WORK(&sc->hw_check_work, ath_hw_check); | ||
579 | - INIT_WORK(&sc->paprd_work, ath_paprd_calibrate); | ||
580 | - INIT_DELAYED_WORK(&sc->hw_pll_work, ath_hw_pll_work); | ||
581 | sc->last_rssi = ATH_RSSI_DUMMY_MARKER; | ||
582 | |||
583 | ath_init_leds(sc); | ||
584 | diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c | ||
585 | index 67b862c..2f3aeac 100644 | ||
586 | --- a/drivers/net/wireless/ath/ath9k/recv.c | ||
587 | +++ b/drivers/net/wireless/ath/ath9k/recv.c | ||
588 | @@ -824,6 +824,14 @@ static bool ath9k_rx_accept(struct ath_common *common, | ||
589 | (ATH9K_RXERR_DECRYPT | ATH9K_RXERR_CRC | ATH9K_RXERR_MIC | | ||
590 | ATH9K_RXERR_KEYMISS)); | ||
591 | |||
592 | + /* | ||
593 | + * Key miss events are only relevant for pairwise keys where the | ||
594 | + * descriptor does contain a valid key index. This has been observed | ||
595 | + * mostly with CCMP encryption. | ||
596 | + */ | ||
597 | + if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID) | ||
598 | + rx_stats->rs_status &= ~ATH9K_RXERR_KEYMISS; | ||
599 | + | ||
600 | if (!rx_stats->rs_datalen) | ||
601 | return false; | ||
602 | /* | ||
603 | diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c | ||
604 | index 63e4be4..720edf5 100644 | ||
605 | --- a/fs/cifs/connect.c | ||
606 | +++ b/fs/cifs/connect.c | ||
607 | @@ -756,10 +756,11 @@ standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid) | ||
608 | cifs_dump_mem("Bad SMB: ", buf, | ||
609 | min_t(unsigned int, server->total_read, 48)); | ||
610 | |||
611 | - if (mid) | ||
612 | - handle_mid(mid, server, smb_buffer, length); | ||
613 | + if (!mid) | ||
614 | + return length; | ||
615 | |||
616 | - return length; | ||
617 | + handle_mid(mid, server, smb_buffer, length); | ||
618 | + return 0; | ||
619 | } | ||
620 | |||
621 | static int | ||
622 | diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c | ||
623 | index d7eeb9d..e4c3334 100644 | ||
624 | --- a/fs/cifs/dir.c | ||
625 | +++ b/fs/cifs/dir.c | ||
626 | @@ -492,7 +492,7 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry, | ||
627 | { | ||
628 | int xid; | ||
629 | int rc = 0; /* to get around spurious gcc warning, set to zero here */ | ||
630 | - __u32 oplock = 0; | ||
631 | + __u32 oplock = enable_oplocks ? REQ_OPLOCK : 0; | ||
632 | __u16 fileHandle = 0; | ||
633 | bool posix_open = false; | ||
634 | struct cifs_sb_info *cifs_sb; | ||
635 | diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c | ||
636 | index 517f211..54f5786 100644 | ||
637 | --- a/fs/fs-writeback.c | ||
638 | +++ b/fs/fs-writeback.c | ||
639 | @@ -48,14 +48,6 @@ struct wb_writeback_work { | ||
640 | }; | ||
641 | |||
642 | /* | ||
643 | - * Include the creation of the trace points after defining the | ||
644 | - * wb_writeback_work structure so that the definition remains local to this | ||
645 | - * file. | ||
646 | - */ | ||
647 | -#define CREATE_TRACE_POINTS | ||
648 | -#include <trace/events/writeback.h> | ||
649 | - | ||
650 | -/* | ||
651 | * We don't actually have pdflush, but this one is exported though /proc... | ||
652 | */ | ||
653 | int nr_pdflush_threads; | ||
654 | @@ -87,6 +79,14 @@ static inline struct inode *wb_inode(struct list_head *head) | ||
655 | return list_entry(head, struct inode, i_wb_list); | ||
656 | } | ||
657 | |||
658 | +/* | ||
659 | + * Include the creation of the trace points after defining the | ||
660 | + * wb_writeback_work structure and inline functions so that the definition | ||
661 | + * remains local to this file. | ||
662 | + */ | ||
663 | +#define CREATE_TRACE_POINTS | ||
664 | +#include <trace/events/writeback.h> | ||
665 | + | ||
666 | /* Wakeup flusher thread or forker thread to fork it. Requires bdi->wb_lock. */ | ||
667 | static void bdi_wakeup_flusher(struct backing_dev_info *bdi) | ||
668 | { | ||
669 | diff --git a/include/linux/bitops.h b/include/linux/bitops.h | ||
670 | index a3ef66a..fc8a3ff 100644 | ||
671 | --- a/include/linux/bitops.h | ||
672 | +++ b/include/linux/bitops.h | ||
673 | @@ -50,6 +50,26 @@ static inline unsigned long hweight_long(unsigned long w) | ||
674 | } | ||
675 | |||
676 | /** | ||
677 | + * rol64 - rotate a 64-bit value left | ||
678 | + * @word: value to rotate | ||
679 | + * @shift: bits to roll | ||
680 | + */ | ||
681 | +static inline __u64 rol64(__u64 word, unsigned int shift) | ||
682 | +{ | ||
683 | + return (word << shift) | (word >> (64 - shift)); | ||
684 | +} | ||
685 | + | ||
686 | +/** | ||
687 | + * ror64 - rotate a 64-bit value right | ||
688 | + * @word: value to rotate | ||
689 | + * @shift: bits to roll | ||
690 | + */ | ||
691 | +static inline __u64 ror64(__u64 word, unsigned int shift) | ||
692 | +{ | ||
693 | + return (word >> shift) | (word << (64 - shift)); | ||
694 | +} | ||
695 | + | ||
696 | +/** | ||
697 | * rol32 - rotate a 32-bit value left | ||
698 | * @word: value to rotate | ||
699 | * @shift: bits to roll | ||
700 | diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h | ||
701 | index 6dc9b80..107fcb3 100644 | ||
702 | --- a/include/linux/mmc/dw_mmc.h | ||
703 | +++ b/include/linux/mmc/dw_mmc.h | ||
704 | @@ -14,6 +14,8 @@ | ||
705 | #ifndef LINUX_MMC_DW_MMC_H | ||
706 | #define LINUX_MMC_DW_MMC_H | ||
707 | |||
708 | +#include <linux/scatterlist.h> | ||
709 | + | ||
710 | #define MAX_MCI_SLOTS 2 | ||
711 | |||
712 | enum dw_mci_state { | ||
713 | @@ -40,7 +42,7 @@ struct mmc_data; | ||
714 | * @lock: Spinlock protecting the queue and associated data. | ||
715 | * @regs: Pointer to MMIO registers. | ||
716 | * @sg: Scatterlist entry currently being processed by PIO code, if any. | ||
717 | - * @pio_offset: Offset into the current scatterlist entry. | ||
718 | + * @sg_miter: PIO mapping scatterlist iterator. | ||
719 | * @cur_slot: The slot which is currently using the controller. | ||
720 | * @mrq: The request currently being processed on @cur_slot, | ||
721 | * or NULL if the controller is idle. | ||
722 | @@ -115,7 +117,7 @@ struct dw_mci { | ||
723 | void __iomem *regs; | ||
724 | |||
725 | struct scatterlist *sg; | ||
726 | - unsigned int pio_offset; | ||
727 | + struct sg_mapping_iter sg_miter; | ||
728 | |||
729 | struct dw_mci_slot *cur_slot; | ||
730 | struct mmc_request *mrq; | ||
731 | diff --git a/include/linux/proportions.h b/include/linux/proportions.h | ||
732 | index ef35bb7..26a8a4e 100644 | ||
733 | --- a/include/linux/proportions.h | ||
734 | +++ b/include/linux/proportions.h | ||
735 | @@ -81,7 +81,11 @@ void prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl) | ||
736 | * Limit the time part in order to ensure there are some bits left for the | ||
737 | * cycle counter and fraction multiply. | ||
738 | */ | ||
739 | +#if BITS_PER_LONG == 32 | ||
740 | #define PROP_MAX_SHIFT (3*BITS_PER_LONG/4) | ||
741 | +#else | ||
742 | +#define PROP_MAX_SHIFT (BITS_PER_LONG/2) | ||
743 | +#endif | ||
744 | |||
745 | #define PROP_FRAC_SHIFT (BITS_PER_LONG - PROP_MAX_SHIFT - 1) | ||
746 | #define PROP_FRAC_BASE (1UL << PROP_FRAC_SHIFT) | ||
747 | diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h | ||
748 | index 99d1d0d..1f48f14 100644 | ||
749 | --- a/include/trace/events/writeback.h | ||
750 | +++ b/include/trace/events/writeback.h | ||
751 | @@ -47,7 +47,10 @@ DECLARE_EVENT_CLASS(writeback_work_class, | ||
752 | __field(int, reason) | ||
753 | ), | ||
754 | TP_fast_assign( | ||
755 | - strncpy(__entry->name, dev_name(bdi->dev), 32); | ||
756 | + struct device *dev = bdi->dev; | ||
757 | + if (!dev) | ||
758 | + dev = default_backing_dev_info.dev; | ||
759 | + strncpy(__entry->name, dev_name(dev), 32); | ||
760 | __entry->nr_pages = work->nr_pages; | ||
761 | __entry->sb_dev = work->sb ? work->sb->s_dev : 0; | ||
762 | __entry->sync_mode = work->sync_mode; | ||
763 | @@ -418,7 +421,7 @@ DECLARE_EVENT_CLASS(writeback_single_inode_template, | ||
764 | |||
765 | TP_fast_assign( | ||
766 | strncpy(__entry->name, | ||
767 | - dev_name(inode->i_mapping->backing_dev_info->dev), 32); | ||
768 | + dev_name(inode_to_bdi(inode)->dev), 32); | ||
769 | __entry->ino = inode->i_ino; | ||
770 | __entry->state = inode->i_state; | ||
771 | __entry->dirtied_when = inode->dirtied_when; | ||
772 | diff --git a/kernel/relay.c b/kernel/relay.c | ||
773 | index 226fade..b6f803a 100644 | ||
774 | --- a/kernel/relay.c | ||
775 | +++ b/kernel/relay.c | ||
776 | @@ -164,10 +164,14 @@ depopulate: | ||
777 | */ | ||
778 | static struct rchan_buf *relay_create_buf(struct rchan *chan) | ||
779 | { | ||
780 | - struct rchan_buf *buf = kzalloc(sizeof(struct rchan_buf), GFP_KERNEL); | ||
781 | - if (!buf) | ||
782 | + struct rchan_buf *buf; | ||
783 | + | ||
784 | + if (chan->n_subbufs > UINT_MAX / sizeof(size_t *)) | ||
785 | return NULL; | ||
786 | |||
787 | + buf = kzalloc(sizeof(struct rchan_buf), GFP_KERNEL); | ||
788 | + if (!buf) | ||
789 | + return NULL; | ||
790 | buf->padding = kmalloc(chan->n_subbufs * sizeof(size_t *), GFP_KERNEL); | ||
791 | if (!buf->padding) | ||
792 | goto free_buf; | ||
793 | @@ -574,6 +578,8 @@ struct rchan *relay_open(const char *base_filename, | ||
794 | |||
795 | if (!(subbuf_size && n_subbufs)) | ||
796 | return NULL; | ||
797 | + if (subbuf_size > UINT_MAX / n_subbufs) | ||
798 | + return NULL; | ||
799 | |||
800 | chan = kzalloc(sizeof(struct rchan), GFP_KERNEL); | ||
801 | if (!chan) | ||
802 | diff --git a/mm/backing-dev.c b/mm/backing-dev.c | ||
803 | index 71034f4..2b49dd2 100644 | ||
804 | --- a/mm/backing-dev.c | ||
805 | +++ b/mm/backing-dev.c | ||
806 | @@ -318,7 +318,7 @@ static void wakeup_timer_fn(unsigned long data) | ||
807 | if (bdi->wb.task) { | ||
808 | trace_writeback_wake_thread(bdi); | ||
809 | wake_up_process(bdi->wb.task); | ||
810 | - } else { | ||
811 | + } else if (bdi->dev) { | ||
812 | /* | ||
813 | * When bdi tasks are inactive for long time, they are killed. | ||
814 | * In this case we have to wake-up the forker thread which | ||
815 | @@ -584,6 +584,8 @@ EXPORT_SYMBOL(bdi_register_dev); | ||
816 | */ | ||
817 | static void bdi_wb_shutdown(struct backing_dev_info *bdi) | ||
818 | { | ||
819 | + struct task_struct *task; | ||
820 | + | ||
821 | if (!bdi_cap_writeback_dirty(bdi)) | ||
822 | return; | ||
823 | |||
824 | @@ -604,9 +606,14 @@ static void bdi_wb_shutdown(struct backing_dev_info *bdi) | ||
825 | * unfreeze of the thread before calling kthread_stop(), otherwise | ||
826 | * it would never exet if it is currently stuck in the refrigerator. | ||
827 | */ | ||
828 | - if (bdi->wb.task) { | ||
829 | - thaw_process(bdi->wb.task); | ||
830 | - kthread_stop(bdi->wb.task); | ||
831 | + spin_lock_bh(&bdi->wb_lock); | ||
832 | + task = bdi->wb.task; | ||
833 | + bdi->wb.task = NULL; | ||
834 | + spin_unlock_bh(&bdi->wb_lock); | ||
835 | + | ||
836 | + if (task) { | ||
837 | + thaw_process(task); | ||
838 | + kthread_stop(task); | ||
839 | } | ||
840 | } | ||
841 | |||
842 | @@ -627,7 +634,9 @@ static void bdi_prune_sb(struct backing_dev_info *bdi) | ||
843 | |||
844 | void bdi_unregister(struct backing_dev_info *bdi) | ||
845 | { | ||
846 | - if (bdi->dev) { | ||
847 | + struct device *dev = bdi->dev; | ||
848 | + | ||
849 | + if (dev) { | ||
850 | bdi_set_min_ratio(bdi, 0); | ||
851 | trace_writeback_bdi_unregister(bdi); | ||
852 | bdi_prune_sb(bdi); | ||
853 | @@ -636,8 +645,12 @@ void bdi_unregister(struct backing_dev_info *bdi) | ||
854 | if (!bdi_cap_flush_forker(bdi)) | ||
855 | bdi_wb_shutdown(bdi); | ||
856 | bdi_debug_unregister(bdi); | ||
857 | - device_unregister(bdi->dev); | ||
858 | + | ||
859 | + spin_lock_bh(&bdi->wb_lock); | ||
860 | bdi->dev = NULL; | ||
861 | + spin_unlock_bh(&bdi->wb_lock); | ||
862 | + | ||
863 | + device_unregister(dev); | ||
864 | } | ||
865 | } | ||
866 | EXPORT_SYMBOL(bdi_unregister); | ||
867 | diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c | ||
868 | index 5c51607..064d20f 100644 | ||
869 | --- a/net/mac80211/rx.c | ||
870 | +++ b/net/mac80211/rx.c | ||
871 | @@ -616,7 +616,7 @@ static void ieee80211_sta_reorder_release(struct ieee80211_hw *hw, | ||
872 | index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) % | ||
873 | tid_agg_rx->buf_size; | ||
874 | if (!tid_agg_rx->reorder_buf[index] && | ||
875 | - tid_agg_rx->stored_mpdu_num > 1) { | ||
876 | + tid_agg_rx->stored_mpdu_num) { | ||
877 | /* | ||
878 | * No buffers ready to be released, but check whether any | ||
879 | * frames in the reorder buffer have timed out. | ||
880 | diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c | ||
881 | index 34e5fcc..9c197d4 100644 | ||
882 | --- a/sound/pci/hda/patch_realtek.c | ||
883 | +++ b/sound/pci/hda/patch_realtek.c | ||
884 | @@ -4213,8 +4213,26 @@ enum { | ||
885 | PINFIX_PB_M5210, | ||
886 | PINFIX_ACER_ASPIRE_7736, | ||
887 | PINFIX_ASUS_W90V, | ||
888 | + ALC889_FIXUP_DAC_ROUTE, | ||
889 | }; | ||
890 | |||
891 | +/* Fix the connection of some pins for ALC889: | ||
892 | + * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't | ||
893 | + * work correctly (bko#42740) | ||
894 | + */ | ||
895 | +static void alc889_fixup_dac_route(struct hda_codec *codec, | ||
896 | + const struct alc_fixup *fix, int action) | ||
897 | +{ | ||
898 | + if (action == ALC_FIXUP_ACT_PRE_PROBE) { | ||
899 | + hda_nid_t conn1[2] = { 0x0c, 0x0d }; | ||
900 | + hda_nid_t conn2[2] = { 0x0e, 0x0f }; | ||
901 | + snd_hda_override_conn_list(codec, 0x14, 2, conn1); | ||
902 | + snd_hda_override_conn_list(codec, 0x15, 2, conn1); | ||
903 | + snd_hda_override_conn_list(codec, 0x18, 2, conn2); | ||
904 | + snd_hda_override_conn_list(codec, 0x1a, 2, conn2); | ||
905 | + } | ||
906 | +} | ||
907 | + | ||
908 | static const struct alc_fixup alc882_fixups[] = { | ||
909 | [PINFIX_ABIT_AW9D_MAX] = { | ||
910 | .type = ALC_FIXUP_PINS, | ||
911 | @@ -4251,10 +4269,15 @@ static const struct alc_fixup alc882_fixups[] = { | ||
912 | { } | ||
913 | } | ||
914 | }, | ||
915 | + [ALC889_FIXUP_DAC_ROUTE] = { | ||
916 | + .type = ALC_FIXUP_FUNC, | ||
917 | + .v.func = alc889_fixup_dac_route, | ||
918 | + }, | ||
919 | }; | ||
920 | |||
921 | static const struct snd_pci_quirk alc882_fixup_tbl[] = { | ||
922 | SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210), | ||
923 | + SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE), | ||
924 | SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", PINFIX_ASUS_W90V), | ||
925 | SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530), | ||
926 | SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX), | ||
927 | diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c | ||
928 | index a0a3f50..1fe1308 100644 | ||
929 | --- a/sound/pci/hda/patch_via.c | ||
930 | +++ b/sound/pci/hda/patch_via.c | ||
931 | @@ -665,6 +665,9 @@ static void via_auto_init_analog_input(struct hda_codec *codec) | ||
932 | /* init input-src */ | ||
933 | for (i = 0; i < spec->num_adc_nids; i++) { | ||
934 | int adc_idx = spec->inputs[spec->cur_mux[i]].adc_idx; | ||
935 | + /* secondary ADCs must have the unique MUX */ | ||
936 | + if (i > 0 && !spec->mux_nids[i]) | ||
937 | + break; | ||
938 | if (spec->mux_nids[adc_idx]) { | ||
939 | int mux_idx = spec->inputs[spec->cur_mux[i]].mux_idx; | ||
940 | snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0, | ||
941 | diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c | ||
942 | index 11718b49..55f48fb 100644 | ||
943 | --- a/sound/pci/intel8x0.c | ||
944 | +++ b/sound/pci/intel8x0.c | ||
945 | @@ -2102,6 +2102,12 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = { | ||
946 | }, | ||
947 | { | ||
948 | .subvendor = 0x161f, | ||
949 | + .subdevice = 0x202f, | ||
950 | + .name = "Gateway M520", | ||
951 | + .type = AC97_TUNE_INV_EAPD | ||
952 | + }, | ||
953 | + { | ||
954 | + .subvendor = 0x161f, | ||
955 | .subdevice = 0x203a, | ||
956 | .name = "Gateway 4525GZ", /* AD1981B */ | ||
957 | .type = AC97_TUNE_INV_EAPD | ||
958 | diff --git a/tools/perf/bench/mem-memcpy-x86-64-asm.S b/tools/perf/bench/mem-memcpy-x86-64-asm.S | ||
959 | index a57b66e..185a96d 100644 | ||
960 | --- a/tools/perf/bench/mem-memcpy-x86-64-asm.S | ||
961 | +++ b/tools/perf/bench/mem-memcpy-x86-64-asm.S | ||
962 | @@ -1,2 +1,8 @@ | ||
963 | |||
964 | #include "../../../arch/x86/lib/memcpy_64.S" | ||
965 | +/* | ||
966 | + * We need to provide note.GNU-stack section, saying that we want | ||
967 | + * NOT executable stack. Otherwise the final linking will assume that | ||
968 | + * the ELF stack should not be restricted at all and set it RWX. | ||
969 | + */ | ||
970 | +.section .note.GNU-stack,"",@progbits | ||
971 | diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c | ||
972 | index d7915d4..efca198 100644 | ||
973 | --- a/tools/perf/util/evsel.c | ||
974 | +++ b/tools/perf/util/evsel.c | ||
975 | @@ -390,6 +390,7 @@ int perf_event__parse_sample(const union perf_event *event, u64 type, | ||
976 | |||
977 | data->cpu = data->pid = data->tid = -1; | ||
978 | data->stream_id = data->id = data->time = -1ULL; | ||
979 | + data->period = 1; | ||
980 | |||
981 | if (event->header.type != PERF_RECORD_SAMPLE) { | ||
982 | if (!sample_id_all) |