Annotation of /trunk/kernel-alx/patches-4.14/0171-4.14.72-all-fixes.patch
Parent Directory | Revision Log
Revision 3238 -
(hide annotations)
(download)
Fri Nov 9 12:14:58 2018 UTC (5 years, 10 months ago) by niro
File size: 159643 byte(s)
Fri Nov 9 12:14:58 2018 UTC (5 years, 10 months ago) by niro
File size: 159643 byte(s)
-added up to patches-4.14.79
1 | niro | 3238 | diff --git a/Makefile b/Makefile |
2 | index dd4eaeeb2050..734722bda173 100644 | ||
3 | --- a/Makefile | ||
4 | +++ b/Makefile | ||
5 | @@ -1,7 +1,7 @@ | ||
6 | # SPDX-License-Identifier: GPL-2.0 | ||
7 | VERSION = 4 | ||
8 | PATCHLEVEL = 14 | ||
9 | -SUBLEVEL = 71 | ||
10 | +SUBLEVEL = 72 | ||
11 | EXTRAVERSION = | ||
12 | NAME = Petit Gorille | ||
13 | |||
14 | diff --git a/arch/arm/boot/dts/qcom-msm8974-lge-nexus5-hammerhead.dts b/arch/arm/boot/dts/qcom-msm8974-lge-nexus5-hammerhead.dts | ||
15 | index 4dc0b347b1ee..c2dc9d09484a 100644 | ||
16 | --- a/arch/arm/boot/dts/qcom-msm8974-lge-nexus5-hammerhead.dts | ||
17 | +++ b/arch/arm/boot/dts/qcom-msm8974-lge-nexus5-hammerhead.dts | ||
18 | @@ -189,6 +189,8 @@ | ||
19 | regulator-max-microvolt = <2950000>; | ||
20 | |||
21 | regulator-boot-on; | ||
22 | + regulator-system-load = <200000>; | ||
23 | + regulator-allow-set-load; | ||
24 | }; | ||
25 | |||
26 | l21 { | ||
27 | diff --git a/arch/arm/mach-exynos/suspend.c b/arch/arm/mach-exynos/suspend.c | ||
28 | index b529ba04ed16..eafa26d9f692 100644 | ||
29 | --- a/arch/arm/mach-exynos/suspend.c | ||
30 | +++ b/arch/arm/mach-exynos/suspend.c | ||
31 | @@ -209,6 +209,7 @@ static int __init exynos_pmu_irq_init(struct device_node *node, | ||
32 | NULL); | ||
33 | if (!domain) { | ||
34 | iounmap(pmu_base_addr); | ||
35 | + pmu_base_addr = NULL; | ||
36 | return -ENOMEM; | ||
37 | } | ||
38 | |||
39 | diff --git a/arch/arm/mach-hisi/hotplug.c b/arch/arm/mach-hisi/hotplug.c | ||
40 | index a129aae72602..909bb2493781 100644 | ||
41 | --- a/arch/arm/mach-hisi/hotplug.c | ||
42 | +++ b/arch/arm/mach-hisi/hotplug.c | ||
43 | @@ -148,13 +148,20 @@ static int hi3xxx_hotplug_init(void) | ||
44 | struct device_node *node; | ||
45 | |||
46 | node = of_find_compatible_node(NULL, NULL, "hisilicon,sysctrl"); | ||
47 | - if (node) { | ||
48 | - ctrl_base = of_iomap(node, 0); | ||
49 | - id = HI3620_CTRL; | ||
50 | - return 0; | ||
51 | + if (!node) { | ||
52 | + id = ERROR_CTRL; | ||
53 | + return -ENOENT; | ||
54 | } | ||
55 | - id = ERROR_CTRL; | ||
56 | - return -ENOENT; | ||
57 | + | ||
58 | + ctrl_base = of_iomap(node, 0); | ||
59 | + of_node_put(node); | ||
60 | + if (!ctrl_base) { | ||
61 | + id = ERROR_CTRL; | ||
62 | + return -ENOMEM; | ||
63 | + } | ||
64 | + | ||
65 | + id = HI3620_CTRL; | ||
66 | + return 0; | ||
67 | } | ||
68 | |||
69 | void hi3xxx_set_cpu(int cpu, bool enable) | ||
70 | @@ -173,11 +180,15 @@ static bool hix5hd2_hotplug_init(void) | ||
71 | struct device_node *np; | ||
72 | |||
73 | np = of_find_compatible_node(NULL, NULL, "hisilicon,cpuctrl"); | ||
74 | - if (np) { | ||
75 | - ctrl_base = of_iomap(np, 0); | ||
76 | - return true; | ||
77 | - } | ||
78 | - return false; | ||
79 | + if (!np) | ||
80 | + return false; | ||
81 | + | ||
82 | + ctrl_base = of_iomap(np, 0); | ||
83 | + of_node_put(np); | ||
84 | + if (!ctrl_base) | ||
85 | + return false; | ||
86 | + | ||
87 | + return true; | ||
88 | } | ||
89 | |||
90 | void hix5hd2_set_cpu(int cpu, bool enable) | ||
91 | @@ -219,10 +230,10 @@ void hip01_set_cpu(int cpu, bool enable) | ||
92 | |||
93 | if (!ctrl_base) { | ||
94 | np = of_find_compatible_node(NULL, NULL, "hisilicon,hip01-sysctrl"); | ||
95 | - if (np) | ||
96 | - ctrl_base = of_iomap(np, 0); | ||
97 | - else | ||
98 | - BUG(); | ||
99 | + BUG_ON(!np); | ||
100 | + ctrl_base = of_iomap(np, 0); | ||
101 | + of_node_put(np); | ||
102 | + BUG_ON(!ctrl_base); | ||
103 | } | ||
104 | |||
105 | if (enable) { | ||
106 | diff --git a/arch/arm64/boot/dts/qcom/apq8016-sbc.dtsi b/arch/arm64/boot/dts/qcom/apq8016-sbc.dtsi | ||
107 | index 1d63e6b879de..b6b44fdf7fac 100644 | ||
108 | --- a/arch/arm64/boot/dts/qcom/apq8016-sbc.dtsi | ||
109 | +++ b/arch/arm64/boot/dts/qcom/apq8016-sbc.dtsi | ||
110 | @@ -187,7 +187,7 @@ | ||
111 | led@6 { | ||
112 | label = "apq8016-sbc:blue:bt"; | ||
113 | gpios = <&pm8916_mpps 3 GPIO_ACTIVE_HIGH>; | ||
114 | - linux,default-trigger = "bt"; | ||
115 | + linux,default-trigger = "bluetooth-power"; | ||
116 | default-state = "off"; | ||
117 | }; | ||
118 | }; | ||
119 | diff --git a/arch/arm64/boot/dts/socionext/uniphier-ld20.dtsi b/arch/arm64/boot/dts/socionext/uniphier-ld20.dtsi | ||
120 | index a29c279b6e8e..dba6f0ff8106 100644 | ||
121 | --- a/arch/arm64/boot/dts/socionext/uniphier-ld20.dtsi | ||
122 | +++ b/arch/arm64/boot/dts/socionext/uniphier-ld20.dtsi | ||
123 | @@ -55,6 +55,7 @@ | ||
124 | clocks = <&sys_clk 32>; | ||
125 | enable-method = "psci"; | ||
126 | operating-points-v2 = <&cluster0_opp>; | ||
127 | + #cooling-cells = <2>; | ||
128 | }; | ||
129 | |||
130 | cpu2: cpu@100 { | ||
131 | @@ -73,6 +74,7 @@ | ||
132 | clocks = <&sys_clk 33>; | ||
133 | enable-method = "psci"; | ||
134 | operating-points-v2 = <&cluster1_opp>; | ||
135 | + #cooling-cells = <2>; | ||
136 | }; | ||
137 | }; | ||
138 | |||
139 | diff --git a/arch/arm64/kernel/ptrace.c b/arch/arm64/kernel/ptrace.c | ||
140 | index edaf346d13d5..34d915b6974b 100644 | ||
141 | --- a/arch/arm64/kernel/ptrace.c | ||
142 | +++ b/arch/arm64/kernel/ptrace.c | ||
143 | @@ -274,19 +274,22 @@ static int ptrace_hbp_set_event(unsigned int note_type, | ||
144 | |||
145 | switch (note_type) { | ||
146 | case NT_ARM_HW_BREAK: | ||
147 | - if (idx < ARM_MAX_BRP) { | ||
148 | - tsk->thread.debug.hbp_break[idx] = bp; | ||
149 | - err = 0; | ||
150 | - } | ||
151 | + if (idx >= ARM_MAX_BRP) | ||
152 | + goto out; | ||
153 | + idx = array_index_nospec(idx, ARM_MAX_BRP); | ||
154 | + tsk->thread.debug.hbp_break[idx] = bp; | ||
155 | + err = 0; | ||
156 | break; | ||
157 | case NT_ARM_HW_WATCH: | ||
158 | - if (idx < ARM_MAX_WRP) { | ||
159 | - tsk->thread.debug.hbp_watch[idx] = bp; | ||
160 | - err = 0; | ||
161 | - } | ||
162 | + if (idx >= ARM_MAX_WRP) | ||
163 | + goto out; | ||
164 | + idx = array_index_nospec(idx, ARM_MAX_WRP); | ||
165 | + tsk->thread.debug.hbp_watch[idx] = bp; | ||
166 | + err = 0; | ||
167 | break; | ||
168 | } | ||
169 | |||
170 | +out: | ||
171 | return err; | ||
172 | } | ||
173 | |||
174 | diff --git a/arch/mips/ath79/setup.c b/arch/mips/ath79/setup.c | ||
175 | index f206dafbb0a3..26a058d58d37 100644 | ||
176 | --- a/arch/mips/ath79/setup.c | ||
177 | +++ b/arch/mips/ath79/setup.c | ||
178 | @@ -40,6 +40,7 @@ static char ath79_sys_type[ATH79_SYS_TYPE_LEN]; | ||
179 | |||
180 | static void ath79_restart(char *command) | ||
181 | { | ||
182 | + local_irq_disable(); | ||
183 | ath79_device_reset_set(AR71XX_RESET_FULL_CHIP); | ||
184 | for (;;) | ||
185 | if (cpu_wait) | ||
186 | diff --git a/arch/mips/include/asm/mach-ath79/ath79.h b/arch/mips/include/asm/mach-ath79/ath79.h | ||
187 | index 441faa92c3cd..6e6c0fead776 100644 | ||
188 | --- a/arch/mips/include/asm/mach-ath79/ath79.h | ||
189 | +++ b/arch/mips/include/asm/mach-ath79/ath79.h | ||
190 | @@ -134,6 +134,7 @@ static inline u32 ath79_pll_rr(unsigned reg) | ||
191 | static inline void ath79_reset_wr(unsigned reg, u32 val) | ||
192 | { | ||
193 | __raw_writel(val, ath79_reset_base + reg); | ||
194 | + (void) __raw_readl(ath79_reset_base + reg); /* flush */ | ||
195 | } | ||
196 | |||
197 | static inline u32 ath79_reset_rr(unsigned reg) | ||
198 | diff --git a/arch/mips/jz4740/Platform b/arch/mips/jz4740/Platform | ||
199 | index 28448d358c10..a2a5a85ea1f9 100644 | ||
200 | --- a/arch/mips/jz4740/Platform | ||
201 | +++ b/arch/mips/jz4740/Platform | ||
202 | @@ -1,4 +1,4 @@ | ||
203 | platform-$(CONFIG_MACH_INGENIC) += jz4740/ | ||
204 | cflags-$(CONFIG_MACH_INGENIC) += -I$(srctree)/arch/mips/include/asm/mach-jz4740 | ||
205 | load-$(CONFIG_MACH_INGENIC) += 0xffffffff80010000 | ||
206 | -zload-$(CONFIG_MACH_INGENIC) += 0xffffffff80600000 | ||
207 | +zload-$(CONFIG_MACH_INGENIC) += 0xffffffff81000000 | ||
208 | diff --git a/arch/mips/loongson64/common/cs5536/cs5536_ohci.c b/arch/mips/loongson64/common/cs5536/cs5536_ohci.c | ||
209 | index f7c905e50dc4..92dc6bafc127 100644 | ||
210 | --- a/arch/mips/loongson64/common/cs5536/cs5536_ohci.c | ||
211 | +++ b/arch/mips/loongson64/common/cs5536/cs5536_ohci.c | ||
212 | @@ -138,7 +138,7 @@ u32 pci_ohci_read_reg(int reg) | ||
213 | break; | ||
214 | case PCI_OHCI_INT_REG: | ||
215 | _rdmsr(DIVIL_MSR_REG(PIC_YSEL_LOW), &hi, &lo); | ||
216 | - if ((lo & 0x00000f00) == CS5536_USB_INTR) | ||
217 | + if (((lo >> PIC_YSEL_LOW_USB_SHIFT) & 0xf) == CS5536_USB_INTR) | ||
218 | conf_data = 1; | ||
219 | break; | ||
220 | default: | ||
221 | diff --git a/arch/powerpc/kvm/book3s_hv.c b/arch/powerpc/kvm/book3s_hv.c | ||
222 | index 377d1420bd02..58746328b9bd 100644 | ||
223 | --- a/arch/powerpc/kvm/book3s_hv.c | ||
224 | +++ b/arch/powerpc/kvm/book3s_hv.c | ||
225 | @@ -4356,6 +4356,8 @@ static int kvmppc_book3s_init_hv(void) | ||
226 | pr_err("KVM-HV: Cannot determine method for accessing XICS\n"); | ||
227 | return -ENODEV; | ||
228 | } | ||
229 | + /* presence of intc confirmed - node can be dropped again */ | ||
230 | + of_node_put(np); | ||
231 | } | ||
232 | #endif | ||
233 | |||
234 | diff --git a/arch/powerpc/platforms/powernv/opal.c b/arch/powerpc/platforms/powernv/opal.c | ||
235 | index 65c79ecf5a4d..c8a743af6bf5 100644 | ||
236 | --- a/arch/powerpc/platforms/powernv/opal.c | ||
237 | +++ b/arch/powerpc/platforms/powernv/opal.c | ||
238 | @@ -388,7 +388,7 @@ int opal_put_chars(uint32_t vtermno, const char *data, int total_len) | ||
239 | /* Closed or other error drop */ | ||
240 | if (rc != OPAL_SUCCESS && rc != OPAL_BUSY && | ||
241 | rc != OPAL_BUSY_EVENT) { | ||
242 | - written = total_len; | ||
243 | + written += total_len; | ||
244 | break; | ||
245 | } | ||
246 | if (rc == OPAL_SUCCESS) { | ||
247 | diff --git a/arch/s390/crypto/paes_s390.c b/arch/s390/crypto/paes_s390.c | ||
248 | index a4e903ed7e21..b429aceff050 100644 | ||
249 | --- a/arch/s390/crypto/paes_s390.c | ||
250 | +++ b/arch/s390/crypto/paes_s390.c | ||
251 | @@ -212,7 +212,7 @@ static int cbc_paes_crypt(struct blkcipher_desc *desc, unsigned long modifier, | ||
252 | walk->dst.virt.addr, walk->src.virt.addr, n); | ||
253 | if (k) | ||
254 | ret = blkcipher_walk_done(desc, walk, nbytes - k); | ||
255 | - if (n < k) { | ||
256 | + if (k < n) { | ||
257 | if (__cbc_paes_set_key(ctx) != 0) | ||
258 | return blkcipher_walk_done(desc, walk, -EIO); | ||
259 | memcpy(param.key, ctx->pk.protkey, MAXPROTKEYSIZE); | ||
260 | diff --git a/arch/x86/kernel/eisa.c b/arch/x86/kernel/eisa.c | ||
261 | index f260e452e4f8..e8c8c5d78dbd 100644 | ||
262 | --- a/arch/x86/kernel/eisa.c | ||
263 | +++ b/arch/x86/kernel/eisa.c | ||
264 | @@ -7,11 +7,17 @@ | ||
265 | #include <linux/eisa.h> | ||
266 | #include <linux/io.h> | ||
267 | |||
268 | +#include <xen/xen.h> | ||
269 | + | ||
270 | static __init int eisa_bus_probe(void) | ||
271 | { | ||
272 | - void __iomem *p = ioremap(0x0FFFD9, 4); | ||
273 | + void __iomem *p; | ||
274 | + | ||
275 | + if (xen_pv_domain() && !xen_initial_domain()) | ||
276 | + return 0; | ||
277 | |||
278 | - if (readl(p) == 'E' + ('I'<<8) + ('S'<<16) + ('A'<<24)) | ||
279 | + p = ioremap(0x0FFFD9, 4); | ||
280 | + if (p && readl(p) == 'E' + ('I' << 8) + ('S' << 16) + ('A' << 24)) | ||
281 | EISA_bus = 1; | ||
282 | iounmap(p); | ||
283 | return 0; | ||
284 | diff --git a/arch/x86/mm/pti.c b/arch/x86/mm/pti.c | ||
285 | index d6f11accd37a..b07e3ffc5ac5 100644 | ||
286 | --- a/arch/x86/mm/pti.c | ||
287 | +++ b/arch/x86/mm/pti.c | ||
288 | @@ -162,7 +162,7 @@ static __init p4d_t *pti_user_pagetable_walk_p4d(unsigned long address) | ||
289 | |||
290 | if (pgd_none(*pgd)) { | ||
291 | unsigned long new_p4d_page = __get_free_page(gfp); | ||
292 | - if (!new_p4d_page) | ||
293 | + if (WARN_ON_ONCE(!new_p4d_page)) | ||
294 | return NULL; | ||
295 | |||
296 | set_pgd(pgd, __pgd(_KERNPG_TABLE | __pa(new_p4d_page))); | ||
297 | @@ -181,13 +181,17 @@ static __init p4d_t *pti_user_pagetable_walk_p4d(unsigned long address) | ||
298 | static __init pmd_t *pti_user_pagetable_walk_pmd(unsigned long address) | ||
299 | { | ||
300 | gfp_t gfp = (GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO); | ||
301 | - p4d_t *p4d = pti_user_pagetable_walk_p4d(address); | ||
302 | + p4d_t *p4d; | ||
303 | pud_t *pud; | ||
304 | |||
305 | + p4d = pti_user_pagetable_walk_p4d(address); | ||
306 | + if (!p4d) | ||
307 | + return NULL; | ||
308 | + | ||
309 | BUILD_BUG_ON(p4d_large(*p4d) != 0); | ||
310 | if (p4d_none(*p4d)) { | ||
311 | unsigned long new_pud_page = __get_free_page(gfp); | ||
312 | - if (!new_pud_page) | ||
313 | + if (WARN_ON_ONCE(!new_pud_page)) | ||
314 | return NULL; | ||
315 | |||
316 | set_p4d(p4d, __p4d(_KERNPG_TABLE | __pa(new_pud_page))); | ||
317 | @@ -201,7 +205,7 @@ static __init pmd_t *pti_user_pagetable_walk_pmd(unsigned long address) | ||
318 | } | ||
319 | if (pud_none(*pud)) { | ||
320 | unsigned long new_pmd_page = __get_free_page(gfp); | ||
321 | - if (!new_pmd_page) | ||
322 | + if (WARN_ON_ONCE(!new_pmd_page)) | ||
323 | return NULL; | ||
324 | |||
325 | set_pud(pud, __pud(_KERNPG_TABLE | __pa(new_pmd_page))); | ||
326 | @@ -223,9 +227,13 @@ static __init pmd_t *pti_user_pagetable_walk_pmd(unsigned long address) | ||
327 | static __init pte_t *pti_user_pagetable_walk_pte(unsigned long address) | ||
328 | { | ||
329 | gfp_t gfp = (GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO); | ||
330 | - pmd_t *pmd = pti_user_pagetable_walk_pmd(address); | ||
331 | + pmd_t *pmd; | ||
332 | pte_t *pte; | ||
333 | |||
334 | + pmd = pti_user_pagetable_walk_pmd(address); | ||
335 | + if (!pmd) | ||
336 | + return NULL; | ||
337 | + | ||
338 | /* We can't do anything sensible if we hit a large mapping. */ | ||
339 | if (pmd_large(*pmd)) { | ||
340 | WARN_ON(1); | ||
341 | @@ -283,6 +291,10 @@ pti_clone_pmds(unsigned long start, unsigned long end, pmdval_t clear) | ||
342 | p4d_t *p4d; | ||
343 | pud_t *pud; | ||
344 | |||
345 | + /* Overflow check */ | ||
346 | + if (addr < start) | ||
347 | + break; | ||
348 | + | ||
349 | pgd = pgd_offset_k(addr); | ||
350 | if (WARN_ON(pgd_none(*pgd))) | ||
351 | return; | ||
352 | @@ -319,6 +331,9 @@ static void __init pti_clone_p4d(unsigned long addr) | ||
353 | pgd_t *kernel_pgd; | ||
354 | |||
355 | user_p4d = pti_user_pagetable_walk_p4d(addr); | ||
356 | + if (!user_p4d) | ||
357 | + return; | ||
358 | + | ||
359 | kernel_pgd = pgd_offset_k(addr); | ||
360 | kernel_p4d = p4d_offset(kernel_pgd, addr); | ||
361 | *user_p4d = *kernel_p4d; | ||
362 | diff --git a/arch/xtensa/platforms/iss/setup.c b/arch/xtensa/platforms/iss/setup.c | ||
363 | index f4bbb28026f8..58709e89a8ed 100644 | ||
364 | --- a/arch/xtensa/platforms/iss/setup.c | ||
365 | +++ b/arch/xtensa/platforms/iss/setup.c | ||
366 | @@ -78,23 +78,28 @@ static struct notifier_block iss_panic_block = { | ||
367 | |||
368 | void __init platform_setup(char **p_cmdline) | ||
369 | { | ||
370 | + static void *argv[COMMAND_LINE_SIZE / sizeof(void *)] __initdata; | ||
371 | + static char cmdline[COMMAND_LINE_SIZE] __initdata; | ||
372 | int argc = simc_argc(); | ||
373 | int argv_size = simc_argv_size(); | ||
374 | |||
375 | if (argc > 1) { | ||
376 | - void **argv = alloc_bootmem(argv_size); | ||
377 | - char *cmdline = alloc_bootmem(argv_size); | ||
378 | - int i; | ||
379 | + if (argv_size > sizeof(argv)) { | ||
380 | + pr_err("%s: command line too long: argv_size = %d\n", | ||
381 | + __func__, argv_size); | ||
382 | + } else { | ||
383 | + int i; | ||
384 | |||
385 | - cmdline[0] = 0; | ||
386 | - simc_argv((void *)argv); | ||
387 | + cmdline[0] = 0; | ||
388 | + simc_argv((void *)argv); | ||
389 | |||
390 | - for (i = 1; i < argc; ++i) { | ||
391 | - if (i > 1) | ||
392 | - strcat(cmdline, " "); | ||
393 | - strcat(cmdline, argv[i]); | ||
394 | + for (i = 1; i < argc; ++i) { | ||
395 | + if (i > 1) | ||
396 | + strcat(cmdline, " "); | ||
397 | + strcat(cmdline, argv[i]); | ||
398 | + } | ||
399 | + *p_cmdline = cmdline; | ||
400 | } | ||
401 | - *p_cmdline = cmdline; | ||
402 | } | ||
403 | |||
404 | atomic_notifier_chain_register(&panic_notifier_list, &iss_panic_block); | ||
405 | diff --git a/block/blk-core.c b/block/blk-core.c | ||
406 | index 1d27e2a152e0..6aa2bc4e9652 100644 | ||
407 | --- a/block/blk-core.c | ||
408 | +++ b/block/blk-core.c | ||
409 | @@ -669,9 +669,13 @@ void blk_cleanup_queue(struct request_queue *q) | ||
410 | * make sure all in-progress dispatch are completed because | ||
411 | * blk_freeze_queue() can only complete all requests, and | ||
412 | * dispatch may still be in-progress since we dispatch requests | ||
413 | - * from more than one contexts | ||
414 | + * from more than one contexts. | ||
415 | + * | ||
416 | + * No need to quiesce queue if it isn't initialized yet since | ||
417 | + * blk_freeze_queue() should be enough for cases of passthrough | ||
418 | + * request. | ||
419 | */ | ||
420 | - if (q->mq_ops) | ||
421 | + if (q->mq_ops && blk_queue_init_done(q)) | ||
422 | blk_mq_quiesce_queue(q); | ||
423 | |||
424 | /* for synchronous bio-based driver finish in-flight integrity i/o */ | ||
425 | diff --git a/block/blk-mq-sched.c b/block/blk-mq-sched.c | ||
426 | index eca011fdfa0e..ae5d8f10a27c 100644 | ||
427 | --- a/block/blk-mq-sched.c | ||
428 | +++ b/block/blk-mq-sched.c | ||
429 | @@ -236,7 +236,8 @@ bool __blk_mq_sched_bio_merge(struct request_queue *q, struct bio *bio) | ||
430 | return e->type->ops.mq.bio_merge(hctx, bio); | ||
431 | } | ||
432 | |||
433 | - if (hctx->flags & BLK_MQ_F_SHOULD_MERGE) { | ||
434 | + if ((hctx->flags & BLK_MQ_F_SHOULD_MERGE) && | ||
435 | + !list_empty_careful(&ctx->rq_list)) { | ||
436 | /* default per sw-queue merge */ | ||
437 | spin_lock(&ctx->lock); | ||
438 | ret = blk_mq_attempt_merge(q, ctx, bio); | ||
439 | diff --git a/block/blk-settings.c b/block/blk-settings.c | ||
440 | index 8559e9563c52..474b0b95fcd1 100644 | ||
441 | --- a/block/blk-settings.c | ||
442 | +++ b/block/blk-settings.c | ||
443 | @@ -128,7 +128,7 @@ void blk_set_stacking_limits(struct queue_limits *lim) | ||
444 | |||
445 | /* Inherit limits from component devices */ | ||
446 | lim->max_segments = USHRT_MAX; | ||
447 | - lim->max_discard_segments = 1; | ||
448 | + lim->max_discard_segments = USHRT_MAX; | ||
449 | lim->max_hw_sectors = UINT_MAX; | ||
450 | lim->max_segment_size = UINT_MAX; | ||
451 | lim->max_sectors = UINT_MAX; | ||
452 | diff --git a/crypto/api.c b/crypto/api.c | ||
453 | index 941cd4c6c7ec..e485aed11ad0 100644 | ||
454 | --- a/crypto/api.c | ||
455 | +++ b/crypto/api.c | ||
456 | @@ -215,7 +215,7 @@ struct crypto_alg *crypto_larval_lookup(const char *name, u32 type, u32 mask) | ||
457 | mask &= ~(CRYPTO_ALG_LARVAL | CRYPTO_ALG_DEAD); | ||
458 | |||
459 | alg = crypto_alg_lookup(name, type, mask); | ||
460 | - if (!alg) { | ||
461 | + if (!alg && !(mask & CRYPTO_NOLOAD)) { | ||
462 | request_module("crypto-%s", name); | ||
463 | |||
464 | if (!((type ^ CRYPTO_ALG_NEED_FALLBACK) & mask & | ||
465 | diff --git a/drivers/base/core.c b/drivers/base/core.c | ||
466 | index b054cb2fd2b9..eb066cc827ef 100644 | ||
467 | --- a/drivers/base/core.c | ||
468 | +++ b/drivers/base/core.c | ||
469 | @@ -2783,6 +2783,9 @@ void device_shutdown(void) | ||
470 | { | ||
471 | struct device *dev, *parent; | ||
472 | |||
473 | + wait_for_device_probe(); | ||
474 | + device_block_probing(); | ||
475 | + | ||
476 | spin_lock(&devices_kset->list_lock); | ||
477 | /* | ||
478 | * Walk the devices list backward, shutting down each in turn. | ||
479 | diff --git a/drivers/char/ipmi/ipmi_ssif.c b/drivers/char/ipmi/ipmi_ssif.c | ||
480 | index 6f2eaba1cd6a..932678617dfa 100644 | ||
481 | --- a/drivers/char/ipmi/ipmi_ssif.c | ||
482 | +++ b/drivers/char/ipmi/ipmi_ssif.c | ||
483 | @@ -184,6 +184,8 @@ struct ssif_addr_info { | ||
484 | struct device *dev; | ||
485 | struct i2c_client *client; | ||
486 | |||
487 | + struct i2c_client *added_client; | ||
488 | + | ||
489 | struct mutex clients_mutex; | ||
490 | struct list_head clients; | ||
491 | |||
492 | @@ -1710,15 +1712,7 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id) | ||
493 | |||
494 | out: | ||
495 | if (rv) { | ||
496 | - /* | ||
497 | - * Note that if addr_info->client is assigned, we | ||
498 | - * leave it. The i2c client hangs around even if we | ||
499 | - * return a failure here, and the failure here is not | ||
500 | - * propagated back to the i2c code. This seems to be | ||
501 | - * design intent, strange as it may be. But if we | ||
502 | - * don't leave it, ssif_platform_remove will not remove | ||
503 | - * the client like it should. | ||
504 | - */ | ||
505 | + addr_info->client = NULL; | ||
506 | dev_err(&client->dev, "Unable to start IPMI SSIF: %d\n", rv); | ||
507 | kfree(ssif_info); | ||
508 | } | ||
509 | @@ -1737,7 +1731,8 @@ static int ssif_adapter_handler(struct device *adev, void *opaque) | ||
510 | if (adev->type != &i2c_adapter_type) | ||
511 | return 0; | ||
512 | |||
513 | - i2c_new_device(to_i2c_adapter(adev), &addr_info->binfo); | ||
514 | + addr_info->added_client = i2c_new_device(to_i2c_adapter(adev), | ||
515 | + &addr_info->binfo); | ||
516 | |||
517 | if (!addr_info->adapter_name) | ||
518 | return 1; /* Only try the first I2C adapter by default. */ | ||
519 | @@ -2018,8 +2013,8 @@ static int ssif_platform_remove(struct platform_device *dev) | ||
520 | return 0; | ||
521 | |||
522 | mutex_lock(&ssif_infos_mutex); | ||
523 | - if (addr_info->client) | ||
524 | - i2c_unregister_device(addr_info->client); | ||
525 | + if (addr_info->added_client) | ||
526 | + i2c_unregister_device(addr_info->added_client); | ||
527 | |||
528 | list_del(&addr_info->link); | ||
529 | kfree(addr_info); | ||
530 | diff --git a/drivers/clk/clk-fixed-factor.c b/drivers/clk/clk-fixed-factor.c | ||
531 | index a5d402de5584..20724abd38bd 100644 | ||
532 | --- a/drivers/clk/clk-fixed-factor.c | ||
533 | +++ b/drivers/clk/clk-fixed-factor.c | ||
534 | @@ -177,8 +177,15 @@ static struct clk *_of_fixed_factor_clk_setup(struct device_node *node) | ||
535 | |||
536 | clk = clk_register_fixed_factor(NULL, clk_name, parent_name, flags, | ||
537 | mult, div); | ||
538 | - if (IS_ERR(clk)) | ||
539 | + if (IS_ERR(clk)) { | ||
540 | + /* | ||
541 | + * If parent clock is not registered, registration would fail. | ||
542 | + * Clear OF_POPULATED flag so that clock registration can be | ||
543 | + * attempted again from probe function. | ||
544 | + */ | ||
545 | + of_node_clear_flag(node, OF_POPULATED); | ||
546 | return clk; | ||
547 | + } | ||
548 | |||
549 | ret = of_clk_add_provider(node, of_clk_src_simple_get, clk); | ||
550 | if (ret) { | ||
551 | diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c | ||
552 | index 6f4c98ca6e50..a3f52f678211 100644 | ||
553 | --- a/drivers/clk/clk.c | ||
554 | +++ b/drivers/clk/clk.c | ||
555 | @@ -2557,6 +2557,7 @@ struct clk *__clk_create_clk(struct clk_hw *hw, const char *dev_id, | ||
556 | return clk; | ||
557 | } | ||
558 | |||
559 | +/* keep in sync with __clk_put */ | ||
560 | void __clk_free_clk(struct clk *clk) | ||
561 | { | ||
562 | clk_prepare_lock(); | ||
563 | @@ -2922,6 +2923,7 @@ int __clk_get(struct clk *clk) | ||
564 | return 1; | ||
565 | } | ||
566 | |||
567 | +/* keep in sync with __clk_free_clk */ | ||
568 | void __clk_put(struct clk *clk) | ||
569 | { | ||
570 | struct module *owner; | ||
571 | @@ -2943,6 +2945,7 @@ void __clk_put(struct clk *clk) | ||
572 | |||
573 | module_put(owner); | ||
574 | |||
575 | + kfree_const(clk->con_id); | ||
576 | kfree(clk); | ||
577 | } | ||
578 | |||
579 | diff --git a/drivers/clk/imx/clk-imx6ul.c b/drivers/clk/imx/clk-imx6ul.c | ||
580 | index 41c08fc892b9..5cc5ff1b4e1f 100644 | ||
581 | --- a/drivers/clk/imx/clk-imx6ul.c | ||
582 | +++ b/drivers/clk/imx/clk-imx6ul.c | ||
583 | @@ -135,6 +135,7 @@ static void __init imx6ul_clocks_init(struct device_node *ccm_node) | ||
584 | |||
585 | np = of_find_compatible_node(NULL, NULL, "fsl,imx6ul-anatop"); | ||
586 | base = of_iomap(np, 0); | ||
587 | + of_node_put(np); | ||
588 | WARN_ON(!base); | ||
589 | |||
590 | clks[IMX6UL_PLL1_BYPASS_SRC] = imx_clk_mux("pll1_bypass_src", base + 0x00, 14, 1, pll_bypass_src_sels, ARRAY_SIZE(pll_bypass_src_sels)); | ||
591 | diff --git a/drivers/clk/tegra/clk-bpmp.c b/drivers/clk/tegra/clk-bpmp.c | ||
592 | index 638ace64033b..6c933b0e29a3 100644 | ||
593 | --- a/drivers/clk/tegra/clk-bpmp.c | ||
594 | +++ b/drivers/clk/tegra/clk-bpmp.c | ||
595 | @@ -581,9 +581,15 @@ static struct clk_hw *tegra_bpmp_clk_of_xlate(struct of_phandle_args *clkspec, | ||
596 | unsigned int id = clkspec->args[0], i; | ||
597 | struct tegra_bpmp *bpmp = data; | ||
598 | |||
599 | - for (i = 0; i < bpmp->num_clocks; i++) | ||
600 | - if (bpmp->clocks[i]->id == id) | ||
601 | - return &bpmp->clocks[i]->hw; | ||
602 | + for (i = 0; i < bpmp->num_clocks; i++) { | ||
603 | + struct tegra_bpmp_clk *clk = bpmp->clocks[i]; | ||
604 | + | ||
605 | + if (!clk) | ||
606 | + continue; | ||
607 | + | ||
608 | + if (clk->id == id) | ||
609 | + return &clk->hw; | ||
610 | + } | ||
611 | |||
612 | return NULL; | ||
613 | } | ||
614 | diff --git a/drivers/crypto/sahara.c b/drivers/crypto/sahara.c | ||
615 | index 08e7bdcaa6e3..085c229eab1d 100644 | ||
616 | --- a/drivers/crypto/sahara.c | ||
617 | +++ b/drivers/crypto/sahara.c | ||
618 | @@ -1351,7 +1351,7 @@ err_sha_v4_algs: | ||
619 | |||
620 | err_sha_v3_algs: | ||
621 | for (j = 0; j < k; j++) | ||
622 | - crypto_unregister_ahash(&sha_v4_algs[j]); | ||
623 | + crypto_unregister_ahash(&sha_v3_algs[j]); | ||
624 | |||
625 | err_aes_algs: | ||
626 | for (j = 0; j < i; j++) | ||
627 | @@ -1367,7 +1367,7 @@ static void sahara_unregister_algs(struct sahara_dev *dev) | ||
628 | for (i = 0; i < ARRAY_SIZE(aes_algs); i++) | ||
629 | crypto_unregister_alg(&aes_algs[i]); | ||
630 | |||
631 | - for (i = 0; i < ARRAY_SIZE(sha_v4_algs); i++) | ||
632 | + for (i = 0; i < ARRAY_SIZE(sha_v3_algs); i++) | ||
633 | crypto_unregister_ahash(&sha_v3_algs[i]); | ||
634 | |||
635 | if (dev->version > SAHARA_VERSION_3) | ||
636 | diff --git a/drivers/dma/mv_xor_v2.c b/drivers/dma/mv_xor_v2.c | ||
637 | index 3548caa9e933..75eef589d0ec 100644 | ||
638 | --- a/drivers/dma/mv_xor_v2.c | ||
639 | +++ b/drivers/dma/mv_xor_v2.c | ||
640 | @@ -898,6 +898,8 @@ static int mv_xor_v2_remove(struct platform_device *pdev) | ||
641 | |||
642 | platform_msi_domain_free_irqs(&pdev->dev); | ||
643 | |||
644 | + tasklet_kill(&xor_dev->irq_tasklet); | ||
645 | + | ||
646 | clk_disable_unprepare(xor_dev->clk); | ||
647 | |||
648 | return 0; | ||
649 | diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c | ||
650 | index d19862f4dc9a..6afd42cfbf5d 100644 | ||
651 | --- a/drivers/dma/pl330.c | ||
652 | +++ b/drivers/dma/pl330.c | ||
653 | @@ -2142,13 +2142,14 @@ static int pl330_terminate_all(struct dma_chan *chan) | ||
654 | |||
655 | pm_runtime_get_sync(pl330->ddma.dev); | ||
656 | spin_lock_irqsave(&pch->lock, flags); | ||
657 | + | ||
658 | spin_lock(&pl330->lock); | ||
659 | _stop(pch->thread); | ||
660 | - spin_unlock(&pl330->lock); | ||
661 | - | ||
662 | pch->thread->req[0].desc = NULL; | ||
663 | pch->thread->req[1].desc = NULL; | ||
664 | pch->thread->req_running = -1; | ||
665 | + spin_unlock(&pl330->lock); | ||
666 | + | ||
667 | power_down = pch->active; | ||
668 | pch->active = false; | ||
669 | |||
670 | diff --git a/drivers/firmware/efi/arm-init.c b/drivers/firmware/efi/arm-init.c | ||
671 | index 80d1a885def5..a7c522eac640 100644 | ||
672 | --- a/drivers/firmware/efi/arm-init.c | ||
673 | +++ b/drivers/firmware/efi/arm-init.c | ||
674 | @@ -259,7 +259,6 @@ void __init efi_init(void) | ||
675 | |||
676 | reserve_regions(); | ||
677 | efi_esrt_init(); | ||
678 | - efi_memmap_unmap(); | ||
679 | |||
680 | memblock_reserve(params.mmap & PAGE_MASK, | ||
681 | PAGE_ALIGN(params.mmap_size + | ||
682 | diff --git a/drivers/firmware/efi/arm-runtime.c b/drivers/firmware/efi/arm-runtime.c | ||
683 | index 86a1ad17a32e..8995a48bd067 100644 | ||
684 | --- a/drivers/firmware/efi/arm-runtime.c | ||
685 | +++ b/drivers/firmware/efi/arm-runtime.c | ||
686 | @@ -122,11 +122,13 @@ static int __init arm_enable_runtime_services(void) | ||
687 | { | ||
688 | u64 mapsize; | ||
689 | |||
690 | - if (!efi_enabled(EFI_BOOT)) { | ||
691 | + if (!efi_enabled(EFI_BOOT) || !efi_enabled(EFI_MEMMAP)) { | ||
692 | pr_info("EFI services will not be available.\n"); | ||
693 | return 0; | ||
694 | } | ||
695 | |||
696 | + efi_memmap_unmap(); | ||
697 | + | ||
698 | if (efi_runtime_disabled()) { | ||
699 | pr_info("EFI runtime services will be disabled.\n"); | ||
700 | return 0; | ||
701 | diff --git a/drivers/firmware/efi/esrt.c b/drivers/firmware/efi/esrt.c | ||
702 | index c47e0c6ec00f..f3c28777b8c6 100644 | ||
703 | --- a/drivers/firmware/efi/esrt.c | ||
704 | +++ b/drivers/firmware/efi/esrt.c | ||
705 | @@ -333,7 +333,8 @@ void __init efi_esrt_init(void) | ||
706 | |||
707 | end = esrt_data + size; | ||
708 | pr_info("Reserving ESRT space from %pa to %pa.\n", &esrt_data, &end); | ||
709 | - efi_mem_reserve(esrt_data, esrt_data_size); | ||
710 | + if (md.type == EFI_BOOT_SERVICES_DATA) | ||
711 | + efi_mem_reserve(esrt_data, esrt_data_size); | ||
712 | |||
713 | pr_debug("esrt-init: loaded.\n"); | ||
714 | err_memunmap: | ||
715 | diff --git a/drivers/gpio/gpio-pxa.c b/drivers/gpio/gpio-pxa.c | ||
716 | index 6029899789f3..2943dfc4c470 100644 | ||
717 | --- a/drivers/gpio/gpio-pxa.c | ||
718 | +++ b/drivers/gpio/gpio-pxa.c | ||
719 | @@ -662,6 +662,8 @@ static int pxa_gpio_probe(struct platform_device *pdev) | ||
720 | pchip->irq0 = irq0; | ||
721 | pchip->irq1 = irq1; | ||
722 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | ||
723 | + if (!res) | ||
724 | + return -EINVAL; | ||
725 | gpio_reg_base = devm_ioremap(&pdev->dev, res->start, | ||
726 | resource_size(res)); | ||
727 | if (!gpio_reg_base) | ||
728 | diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h | ||
729 | index 3d4d0634c9dd..7a3d9658d74c 100644 | ||
730 | --- a/drivers/gpio/gpiolib.h | ||
731 | +++ b/drivers/gpio/gpiolib.h | ||
732 | @@ -88,7 +88,7 @@ struct acpi_gpio_info { | ||
733 | }; | ||
734 | |||
735 | /* gpio suffixes used for ACPI and device tree lookup */ | ||
736 | -static const char * const gpio_suffixes[] = { "gpios", "gpio" }; | ||
737 | +static __maybe_unused const char * const gpio_suffixes[] = { "gpios", "gpio" }; | ||
738 | |||
739 | #ifdef CONFIG_OF_GPIO | ||
740 | struct gpio_desc *of_find_gpio(struct device *dev, | ||
741 | diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_process.c b/drivers/gpu/drm/amd/amdkfd/kfd_process.c | ||
742 | index c74cf22a1ed9..3ae88dcff08d 100644 | ||
743 | --- a/drivers/gpu/drm/amd/amdkfd/kfd_process.c | ||
744 | +++ b/drivers/gpu/drm/amd/amdkfd/kfd_process.c | ||
745 | @@ -123,6 +123,8 @@ struct kfd_process *kfd_get_process(const struct task_struct *thread) | ||
746 | return ERR_PTR(-EINVAL); | ||
747 | |||
748 | process = find_process(thread); | ||
749 | + if (!process) | ||
750 | + return ERR_PTR(-EINVAL); | ||
751 | |||
752 | return process; | ||
753 | } | ||
754 | diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c | ||
755 | index 90359c7954c8..3c0ce3ee0710 100644 | ||
756 | --- a/drivers/gpu/drm/i915/i915_gem.c | ||
757 | +++ b/drivers/gpu/drm/i915/i915_gem.c | ||
758 | @@ -687,10 +687,10 @@ flush_write_domain(struct drm_i915_gem_object *obj, unsigned int flush_domains) | ||
759 | |||
760 | switch (obj->base.write_domain) { | ||
761 | case I915_GEM_DOMAIN_GTT: | ||
762 | - if (INTEL_GEN(dev_priv) >= 6 && !HAS_LLC(dev_priv)) { | ||
763 | + if (!HAS_LLC(dev_priv)) { | ||
764 | intel_runtime_pm_get(dev_priv); | ||
765 | spin_lock_irq(&dev_priv->uncore.lock); | ||
766 | - POSTING_READ_FW(RING_ACTHD(dev_priv->engine[RCS]->mmio_base)); | ||
767 | + POSTING_READ_FW(RING_HEAD(dev_priv->engine[RCS]->mmio_base)); | ||
768 | spin_unlock_irq(&dev_priv->uncore.lock); | ||
769 | intel_runtime_pm_put(dev_priv); | ||
770 | } | ||
771 | diff --git a/drivers/gpu/drm/nouveau/nouveau_debugfs.c b/drivers/gpu/drm/nouveau/nouveau_debugfs.c | ||
772 | index 963a4dba8213..9109b69cd052 100644 | ||
773 | --- a/drivers/gpu/drm/nouveau/nouveau_debugfs.c | ||
774 | +++ b/drivers/gpu/drm/nouveau/nouveau_debugfs.c | ||
775 | @@ -160,7 +160,11 @@ nouveau_debugfs_pstate_set(struct file *file, const char __user *ubuf, | ||
776 | args.ustate = value; | ||
777 | } | ||
778 | |||
779 | + ret = pm_runtime_get_sync(drm->dev); | ||
780 | + if (IS_ERR_VALUE(ret) && ret != -EACCES) | ||
781 | + return ret; | ||
782 | ret = nvif_mthd(ctrl, NVIF_CONTROL_PSTATE_USER, &args, sizeof(args)); | ||
783 | + pm_runtime_put_autosuspend(drm->dev); | ||
784 | if (ret < 0) | ||
785 | return ret; | ||
786 | |||
787 | diff --git a/drivers/gpu/drm/nouveau/nouveau_drm.c b/drivers/gpu/drm/nouveau/nouveau_drm.c | ||
788 | index 362a34cb435d..d6f13d7254de 100644 | ||
789 | --- a/drivers/gpu/drm/nouveau/nouveau_drm.c | ||
790 | +++ b/drivers/gpu/drm/nouveau/nouveau_drm.c | ||
791 | @@ -848,8 +848,10 @@ nouveau_drm_open(struct drm_device *dev, struct drm_file *fpriv) | ||
792 | get_task_comm(tmpname, current); | ||
793 | snprintf(name, sizeof(name), "%s[%d]", tmpname, pid_nr(fpriv->pid)); | ||
794 | |||
795 | - if (!(cli = kzalloc(sizeof(*cli), GFP_KERNEL))) | ||
796 | - return ret; | ||
797 | + if (!(cli = kzalloc(sizeof(*cli), GFP_KERNEL))) { | ||
798 | + ret = -ENOMEM; | ||
799 | + goto done; | ||
800 | + } | ||
801 | |||
802 | ret = nouveau_cli_init(drm, name, cli); | ||
803 | if (ret) | ||
804 | diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/device/tegra.c b/drivers/gpu/drm/nouveau/nvkm/engine/device/tegra.c | ||
805 | index 189ed80e21ff..fa1ead337c23 100644 | ||
806 | --- a/drivers/gpu/drm/nouveau/nvkm/engine/device/tegra.c | ||
807 | +++ b/drivers/gpu/drm/nouveau/nvkm/engine/device/tegra.c | ||
808 | @@ -23,6 +23,10 @@ | ||
809 | #ifdef CONFIG_NOUVEAU_PLATFORM_DRIVER | ||
810 | #include "priv.h" | ||
811 | |||
812 | +#if IS_ENABLED(CONFIG_ARM_DMA_USE_IOMMU) | ||
813 | +#include <asm/dma-iommu.h> | ||
814 | +#endif | ||
815 | + | ||
816 | static int | ||
817 | nvkm_device_tegra_power_up(struct nvkm_device_tegra *tdev) | ||
818 | { | ||
819 | @@ -105,6 +109,15 @@ nvkm_device_tegra_probe_iommu(struct nvkm_device_tegra *tdev) | ||
820 | unsigned long pgsize_bitmap; | ||
821 | int ret; | ||
822 | |||
823 | +#if IS_ENABLED(CONFIG_ARM_DMA_USE_IOMMU) | ||
824 | + if (dev->archdata.mapping) { | ||
825 | + struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev); | ||
826 | + | ||
827 | + arm_iommu_detach_device(dev); | ||
828 | + arm_iommu_release_mapping(mapping); | ||
829 | + } | ||
830 | +#endif | ||
831 | + | ||
832 | if (!tdev->func->iommu_bit) | ||
833 | return; | ||
834 | |||
835 | diff --git a/drivers/gpu/drm/panel/panel-samsung-s6e8aa0.c b/drivers/gpu/drm/panel/panel-samsung-s6e8aa0.c | ||
836 | index a188a3959f1a..6ad827b93ae1 100644 | ||
837 | --- a/drivers/gpu/drm/panel/panel-samsung-s6e8aa0.c | ||
838 | +++ b/drivers/gpu/drm/panel/panel-samsung-s6e8aa0.c | ||
839 | @@ -823,7 +823,7 @@ static void s6e8aa0_read_mtp_id(struct s6e8aa0 *ctx) | ||
840 | int ret, i; | ||
841 | |||
842 | ret = s6e8aa0_dcs_read(ctx, 0xd1, id, ARRAY_SIZE(id)); | ||
843 | - if (ret < ARRAY_SIZE(id) || id[0] == 0x00) { | ||
844 | + if (ret < 0 || ret < ARRAY_SIZE(id) || id[0] == 0x00) { | ||
845 | dev_err(ctx->dev, "read id failed\n"); | ||
846 | ctx->error = -EIO; | ||
847 | return; | ||
848 | diff --git a/drivers/gpu/ipu-v3/ipu-csi.c b/drivers/gpu/ipu-v3/ipu-csi.c | ||
849 | index 24e12b87a0cb..2bc51d4d3f1e 100644 | ||
850 | --- a/drivers/gpu/ipu-v3/ipu-csi.c | ||
851 | +++ b/drivers/gpu/ipu-v3/ipu-csi.c | ||
852 | @@ -316,13 +316,17 @@ static int mbus_code_to_bus_cfg(struct ipu_csi_bus_config *cfg, u32 mbus_code) | ||
853 | /* | ||
854 | * Fill a CSI bus config struct from mbus_config and mbus_framefmt. | ||
855 | */ | ||
856 | -static void fill_csi_bus_cfg(struct ipu_csi_bus_config *csicfg, | ||
857 | +static int fill_csi_bus_cfg(struct ipu_csi_bus_config *csicfg, | ||
858 | struct v4l2_mbus_config *mbus_cfg, | ||
859 | struct v4l2_mbus_framefmt *mbus_fmt) | ||
860 | { | ||
861 | + int ret; | ||
862 | + | ||
863 | memset(csicfg, 0, sizeof(*csicfg)); | ||
864 | |||
865 | - mbus_code_to_bus_cfg(csicfg, mbus_fmt->code); | ||
866 | + ret = mbus_code_to_bus_cfg(csicfg, mbus_fmt->code); | ||
867 | + if (ret < 0) | ||
868 | + return ret; | ||
869 | |||
870 | switch (mbus_cfg->type) { | ||
871 | case V4L2_MBUS_PARALLEL: | ||
872 | @@ -353,6 +357,8 @@ static void fill_csi_bus_cfg(struct ipu_csi_bus_config *csicfg, | ||
873 | /* will never get here, keep compiler quiet */ | ||
874 | break; | ||
875 | } | ||
876 | + | ||
877 | + return 0; | ||
878 | } | ||
879 | |||
880 | int ipu_csi_init_interface(struct ipu_csi *csi, | ||
881 | @@ -362,8 +368,11 @@ int ipu_csi_init_interface(struct ipu_csi *csi, | ||
882 | struct ipu_csi_bus_config cfg; | ||
883 | unsigned long flags; | ||
884 | u32 width, height, data = 0; | ||
885 | + int ret; | ||
886 | |||
887 | - fill_csi_bus_cfg(&cfg, mbus_cfg, mbus_fmt); | ||
888 | + ret = fill_csi_bus_cfg(&cfg, mbus_cfg, mbus_fmt); | ||
889 | + if (ret < 0) | ||
890 | + return ret; | ||
891 | |||
892 | /* set default sensor frame width and height */ | ||
893 | width = mbus_fmt->width; | ||
894 | @@ -584,11 +593,14 @@ int ipu_csi_set_mipi_datatype(struct ipu_csi *csi, u32 vc, | ||
895 | struct ipu_csi_bus_config cfg; | ||
896 | unsigned long flags; | ||
897 | u32 temp; | ||
898 | + int ret; | ||
899 | |||
900 | if (vc > 3) | ||
901 | return -EINVAL; | ||
902 | |||
903 | - mbus_code_to_bus_cfg(&cfg, mbus_fmt->code); | ||
904 | + ret = mbus_code_to_bus_cfg(&cfg, mbus_fmt->code); | ||
905 | + if (ret < 0) | ||
906 | + return ret; | ||
907 | |||
908 | spin_lock_irqsave(&csi->lock, flags); | ||
909 | |||
910 | diff --git a/drivers/hwtracing/coresight/coresight-etm4x.c b/drivers/hwtracing/coresight/coresight-etm4x.c | ||
911 | index cf364a514c12..5a1a14bcae72 100644 | ||
912 | --- a/drivers/hwtracing/coresight/coresight-etm4x.c | ||
913 | +++ b/drivers/hwtracing/coresight/coresight-etm4x.c | ||
914 | @@ -1034,7 +1034,8 @@ static int etm4_probe(struct amba_device *adev, const struct amba_id *id) | ||
915 | } | ||
916 | |||
917 | pm_runtime_put(&adev->dev); | ||
918 | - dev_info(dev, "%s initialized\n", (char *)id->data); | ||
919 | + dev_info(dev, "CPU%d: ETM v%d.%d initialized\n", | ||
920 | + drvdata->cpu, drvdata->arch >> 4, drvdata->arch & 0xf); | ||
921 | |||
922 | if (boot_enable) { | ||
923 | coresight_enable(drvdata->csdev); | ||
924 | @@ -1052,23 +1053,19 @@ err_arch_supported: | ||
925 | return ret; | ||
926 | } | ||
927 | |||
928 | +#define ETM4x_AMBA_ID(pid) \ | ||
929 | + { \ | ||
930 | + .id = pid, \ | ||
931 | + .mask = 0x000fffff, \ | ||
932 | + } | ||
933 | + | ||
934 | static const struct amba_id etm4_ids[] = { | ||
935 | - { /* ETM 4.0 - Cortex-A53 */ | ||
936 | - .id = 0x000bb95d, | ||
937 | - .mask = 0x000fffff, | ||
938 | - .data = "ETM 4.0", | ||
939 | - }, | ||
940 | - { /* ETM 4.0 - Cortex-A57 */ | ||
941 | - .id = 0x000bb95e, | ||
942 | - .mask = 0x000fffff, | ||
943 | - .data = "ETM 4.0", | ||
944 | - }, | ||
945 | - { /* ETM 4.0 - A72, Maia, HiSilicon */ | ||
946 | - .id = 0x000bb95a, | ||
947 | - .mask = 0x000fffff, | ||
948 | - .data = "ETM 4.0", | ||
949 | - }, | ||
950 | - { 0, 0}, | ||
951 | + ETM4x_AMBA_ID(0x000bb95d), /* Cortex-A53 */ | ||
952 | + ETM4x_AMBA_ID(0x000bb95e), /* Cortex-A57 */ | ||
953 | + ETM4x_AMBA_ID(0x000bb95a), /* Cortex-A72 */ | ||
954 | + ETM4x_AMBA_ID(0x000bb959), /* Cortex-A73 */ | ||
955 | + ETM4x_AMBA_ID(0x000bb9da), /* Cortex-A35 */ | ||
956 | + {}, | ||
957 | }; | ||
958 | |||
959 | static struct amba_driver etm4x_driver = { | ||
960 | diff --git a/drivers/hwtracing/coresight/coresight-tpiu.c b/drivers/hwtracing/coresight/coresight-tpiu.c | ||
961 | index 735dca089389..15dd01f8c197 100644 | ||
962 | --- a/drivers/hwtracing/coresight/coresight-tpiu.c | ||
963 | +++ b/drivers/hwtracing/coresight/coresight-tpiu.c | ||
964 | @@ -47,8 +47,9 @@ | ||
965 | |||
966 | /** register definition **/ | ||
967 | /* FFSR - 0x300 */ | ||
968 | -#define FFSR_FT_STOPPED BIT(1) | ||
969 | +#define FFSR_FT_STOPPED_BIT 1 | ||
970 | /* FFCR - 0x304 */ | ||
971 | +#define FFCR_FON_MAN_BIT 6 | ||
972 | #define FFCR_FON_MAN BIT(6) | ||
973 | #define FFCR_STOP_FI BIT(12) | ||
974 | |||
975 | @@ -93,9 +94,9 @@ static void tpiu_disable_hw(struct tpiu_drvdata *drvdata) | ||
976 | /* Generate manual flush */ | ||
977 | writel_relaxed(FFCR_STOP_FI | FFCR_FON_MAN, drvdata->base + TPIU_FFCR); | ||
978 | /* Wait for flush to complete */ | ||
979 | - coresight_timeout(drvdata->base, TPIU_FFCR, FFCR_FON_MAN, 0); | ||
980 | + coresight_timeout(drvdata->base, TPIU_FFCR, FFCR_FON_MAN_BIT, 0); | ||
981 | /* Wait for formatter to stop */ | ||
982 | - coresight_timeout(drvdata->base, TPIU_FFSR, FFSR_FT_STOPPED, 1); | ||
983 | + coresight_timeout(drvdata->base, TPIU_FFSR, FFSR_FT_STOPPED_BIT, 1); | ||
984 | |||
985 | CS_LOCK(drvdata->base); | ||
986 | } | ||
987 | diff --git a/drivers/hwtracing/coresight/coresight.c b/drivers/hwtracing/coresight/coresight.c | ||
988 | index b8091bef21dc..e571e4010dff 100644 | ||
989 | --- a/drivers/hwtracing/coresight/coresight.c | ||
990 | +++ b/drivers/hwtracing/coresight/coresight.c | ||
991 | @@ -115,7 +115,7 @@ static int coresight_find_link_inport(struct coresight_device *csdev, | ||
992 | dev_err(&csdev->dev, "couldn't find inport, parent: %s, child: %s\n", | ||
993 | dev_name(&parent->dev), dev_name(&csdev->dev)); | ||
994 | |||
995 | - return 0; | ||
996 | + return -ENODEV; | ||
997 | } | ||
998 | |||
999 | static int coresight_find_link_outport(struct coresight_device *csdev, | ||
1000 | @@ -133,7 +133,7 @@ static int coresight_find_link_outport(struct coresight_device *csdev, | ||
1001 | dev_err(&csdev->dev, "couldn't find outport, parent: %s, child: %s\n", | ||
1002 | dev_name(&csdev->dev), dev_name(&child->dev)); | ||
1003 | |||
1004 | - return 0; | ||
1005 | + return -ENODEV; | ||
1006 | } | ||
1007 | |||
1008 | static int coresight_enable_sink(struct coresight_device *csdev, u32 mode) | ||
1009 | @@ -186,6 +186,9 @@ static int coresight_enable_link(struct coresight_device *csdev, | ||
1010 | else | ||
1011 | refport = 0; | ||
1012 | |||
1013 | + if (refport < 0) | ||
1014 | + return refport; | ||
1015 | + | ||
1016 | if (atomic_inc_return(&csdev->refcnt[refport]) == 1) { | ||
1017 | if (link_ops(csdev)->enable) { | ||
1018 | ret = link_ops(csdev)->enable(csdev, inport, outport); | ||
1019 | diff --git a/drivers/i2c/busses/i2c-aspeed.c b/drivers/i2c/busses/i2c-aspeed.c | ||
1020 | index 2feae9a421e6..a074735456bc 100644 | ||
1021 | --- a/drivers/i2c/busses/i2c-aspeed.c | ||
1022 | +++ b/drivers/i2c/busses/i2c-aspeed.c | ||
1023 | @@ -110,22 +110,22 @@ | ||
1024 | #define ASPEED_I2CD_DEV_ADDR_MASK GENMASK(6, 0) | ||
1025 | |||
1026 | enum aspeed_i2c_master_state { | ||
1027 | + ASPEED_I2C_MASTER_INACTIVE, | ||
1028 | ASPEED_I2C_MASTER_START, | ||
1029 | ASPEED_I2C_MASTER_TX_FIRST, | ||
1030 | ASPEED_I2C_MASTER_TX, | ||
1031 | ASPEED_I2C_MASTER_RX_FIRST, | ||
1032 | ASPEED_I2C_MASTER_RX, | ||
1033 | ASPEED_I2C_MASTER_STOP, | ||
1034 | - ASPEED_I2C_MASTER_INACTIVE, | ||
1035 | }; | ||
1036 | |||
1037 | enum aspeed_i2c_slave_state { | ||
1038 | + ASPEED_I2C_SLAVE_STOP, | ||
1039 | ASPEED_I2C_SLAVE_START, | ||
1040 | ASPEED_I2C_SLAVE_READ_REQUESTED, | ||
1041 | ASPEED_I2C_SLAVE_READ_PROCESSED, | ||
1042 | ASPEED_I2C_SLAVE_WRITE_REQUESTED, | ||
1043 | ASPEED_I2C_SLAVE_WRITE_RECEIVED, | ||
1044 | - ASPEED_I2C_SLAVE_STOP, | ||
1045 | }; | ||
1046 | |||
1047 | struct aspeed_i2c_bus { | ||
1048 | diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c | ||
1049 | index 752dbc388c27..7c5eca312aa8 100644 | ||
1050 | --- a/drivers/infiniband/core/cma.c | ||
1051 | +++ b/drivers/infiniband/core/cma.c | ||
1052 | @@ -730,6 +730,7 @@ static int cma_resolve_ib_dev(struct rdma_id_private *id_priv) | ||
1053 | dgid = (union ib_gid *) &addr->sib_addr; | ||
1054 | pkey = ntohs(addr->sib_pkey); | ||
1055 | |||
1056 | + mutex_lock(&lock); | ||
1057 | list_for_each_entry(cur_dev, &dev_list, list) { | ||
1058 | for (p = 1; p <= cur_dev->device->phys_port_cnt; ++p) { | ||
1059 | if (!rdma_cap_af_ib(cur_dev->device, p)) | ||
1060 | @@ -756,18 +757,19 @@ static int cma_resolve_ib_dev(struct rdma_id_private *id_priv) | ||
1061 | cma_dev = cur_dev; | ||
1062 | sgid = gid; | ||
1063 | id_priv->id.port_num = p; | ||
1064 | + goto found; | ||
1065 | } | ||
1066 | } | ||
1067 | } | ||
1068 | } | ||
1069 | - | ||
1070 | - if (!cma_dev) | ||
1071 | - return -ENODEV; | ||
1072 | + mutex_unlock(&lock); | ||
1073 | + return -ENODEV; | ||
1074 | |||
1075 | found: | ||
1076 | cma_attach_to_dev(id_priv, cma_dev); | ||
1077 | - addr = (struct sockaddr_ib *) cma_src_addr(id_priv); | ||
1078 | - memcpy(&addr->sib_addr, &sgid, sizeof sgid); | ||
1079 | + mutex_unlock(&lock); | ||
1080 | + addr = (struct sockaddr_ib *)cma_src_addr(id_priv); | ||
1081 | + memcpy(&addr->sib_addr, &sgid, sizeof(sgid)); | ||
1082 | cma_translate_ib(addr, &id_priv->id.route.addr.dev_addr); | ||
1083 | return 0; | ||
1084 | } | ||
1085 | diff --git a/drivers/infiniband/sw/rxe/rxe_recv.c b/drivers/infiniband/sw/rxe/rxe_recv.c | ||
1086 | index fb8c83e055e1..83412df726a5 100644 | ||
1087 | --- a/drivers/infiniband/sw/rxe/rxe_recv.c | ||
1088 | +++ b/drivers/infiniband/sw/rxe/rxe_recv.c | ||
1089 | @@ -225,9 +225,14 @@ static int hdr_check(struct rxe_pkt_info *pkt) | ||
1090 | goto err1; | ||
1091 | } | ||
1092 | |||
1093 | + if (unlikely(qpn == 0)) { | ||
1094 | + pr_warn_once("QP 0 not supported"); | ||
1095 | + goto err1; | ||
1096 | + } | ||
1097 | + | ||
1098 | if (qpn != IB_MULTICAST_QPN) { | ||
1099 | - index = (qpn == 0) ? port->qp_smi_index : | ||
1100 | - ((qpn == 1) ? port->qp_gsi_index : qpn); | ||
1101 | + index = (qpn == 1) ? port->qp_gsi_index : qpn; | ||
1102 | + | ||
1103 | qp = rxe_pool_get_index(&rxe->qp_pool, index); | ||
1104 | if (unlikely(!qp)) { | ||
1105 | pr_warn_ratelimited("no qp matches qpn 0x%x\n", qpn); | ||
1106 | diff --git a/drivers/infiniband/ulp/ipoib/ipoib_cm.c b/drivers/infiniband/ulp/ipoib/ipoib_cm.c | ||
1107 | index 7a5ed5a5391e..9939f32d0154 100644 | ||
1108 | --- a/drivers/infiniband/ulp/ipoib/ipoib_cm.c | ||
1109 | +++ b/drivers/infiniband/ulp/ipoib/ipoib_cm.c | ||
1110 | @@ -1018,12 +1018,14 @@ static int ipoib_cm_rep_handler(struct ib_cm_id *cm_id, struct ib_cm_event *even | ||
1111 | |||
1112 | skb_queue_head_init(&skqueue); | ||
1113 | |||
1114 | + netif_tx_lock_bh(p->dev); | ||
1115 | spin_lock_irq(&priv->lock); | ||
1116 | set_bit(IPOIB_FLAG_OPER_UP, &p->flags); | ||
1117 | if (p->neigh) | ||
1118 | while ((skb = __skb_dequeue(&p->neigh->queue))) | ||
1119 | __skb_queue_tail(&skqueue, skb); | ||
1120 | spin_unlock_irq(&priv->lock); | ||
1121 | + netif_tx_unlock_bh(p->dev); | ||
1122 | |||
1123 | while ((skb = __skb_dequeue(&skqueue))) { | ||
1124 | skb->dev = p->dev; | ||
1125 | diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c | ||
1126 | index 6bc9a768f721..e6ff16b27acd 100644 | ||
1127 | --- a/drivers/infiniband/ulp/ipoib/ipoib_main.c | ||
1128 | +++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c | ||
1129 | @@ -1752,7 +1752,8 @@ int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port) | ||
1130 | goto out_free_pd; | ||
1131 | } | ||
1132 | |||
1133 | - if (ipoib_neigh_hash_init(priv) < 0) { | ||
1134 | + ret = ipoib_neigh_hash_init(priv); | ||
1135 | + if (ret) { | ||
1136 | pr_warn("%s failed to init neigh hash\n", dev->name); | ||
1137 | goto out_dev_uninit; | ||
1138 | } | ||
1139 | diff --git a/drivers/input/touchscreen/rohm_bu21023.c b/drivers/input/touchscreen/rohm_bu21023.c | ||
1140 | index eeaf6ff03597..fc54e044fece 100644 | ||
1141 | --- a/drivers/input/touchscreen/rohm_bu21023.c | ||
1142 | +++ b/drivers/input/touchscreen/rohm_bu21023.c | ||
1143 | @@ -304,7 +304,7 @@ static int rohm_i2c_burst_read(struct i2c_client *client, u8 start, void *buf, | ||
1144 | msg[1].len = len; | ||
1145 | msg[1].buf = buf; | ||
1146 | |||
1147 | - i2c_lock_adapter(adap); | ||
1148 | + i2c_lock_bus(adap, I2C_LOCK_SEGMENT); | ||
1149 | |||
1150 | for (i = 0; i < 2; i++) { | ||
1151 | if (__i2c_transfer(adap, &msg[i], 1) < 0) { | ||
1152 | @@ -313,7 +313,7 @@ static int rohm_i2c_burst_read(struct i2c_client *client, u8 start, void *buf, | ||
1153 | } | ||
1154 | } | ||
1155 | |||
1156 | - i2c_unlock_adapter(adap); | ||
1157 | + i2c_unlock_bus(adap, I2C_LOCK_SEGMENT); | ||
1158 | |||
1159 | return ret; | ||
1160 | } | ||
1161 | diff --git a/drivers/iommu/arm-smmu-v3.c b/drivers/iommu/arm-smmu-v3.c | ||
1162 | index 8f7a3c00b6cf..26e99c03390f 100644 | ||
1163 | --- a/drivers/iommu/arm-smmu-v3.c | ||
1164 | +++ b/drivers/iommu/arm-smmu-v3.c | ||
1165 | @@ -1272,6 +1272,7 @@ static irqreturn_t arm_smmu_priq_thread(int irq, void *dev) | ||
1166 | |||
1167 | /* Sync our overflow flag, as we believe we're up to speed */ | ||
1168 | q->cons = Q_OVF(q, q->prod) | Q_WRP(q, q->cons) | Q_IDX(q, q->cons); | ||
1169 | + writel(q->cons, q->cons_reg); | ||
1170 | return IRQ_HANDLED; | ||
1171 | } | ||
1172 | |||
1173 | diff --git a/drivers/iommu/io-pgtable-arm-v7s.c b/drivers/iommu/io-pgtable-arm-v7s.c | ||
1174 | index 6961fc393f0b..29b7a6755fcd 100644 | ||
1175 | --- a/drivers/iommu/io-pgtable-arm-v7s.c | ||
1176 | +++ b/drivers/iommu/io-pgtable-arm-v7s.c | ||
1177 | @@ -192,6 +192,7 @@ static void *__arm_v7s_alloc_table(int lvl, gfp_t gfp, | ||
1178 | { | ||
1179 | struct io_pgtable_cfg *cfg = &data->iop.cfg; | ||
1180 | struct device *dev = cfg->iommu_dev; | ||
1181 | + phys_addr_t phys; | ||
1182 | dma_addr_t dma; | ||
1183 | size_t size = ARM_V7S_TABLE_SIZE(lvl); | ||
1184 | void *table = NULL; | ||
1185 | @@ -200,6 +201,10 @@ static void *__arm_v7s_alloc_table(int lvl, gfp_t gfp, | ||
1186 | table = (void *)__get_dma_pages(__GFP_ZERO, get_order(size)); | ||
1187 | else if (lvl == 2) | ||
1188 | table = kmem_cache_zalloc(data->l2_tables, gfp | GFP_DMA); | ||
1189 | + phys = virt_to_phys(table); | ||
1190 | + if (phys != (arm_v7s_iopte)phys) | ||
1191 | + /* Doesn't fit in PTE */ | ||
1192 | + goto out_free; | ||
1193 | if (table && !(cfg->quirks & IO_PGTABLE_QUIRK_NO_DMA)) { | ||
1194 | dma = dma_map_single(dev, table, size, DMA_TO_DEVICE); | ||
1195 | if (dma_mapping_error(dev, dma)) | ||
1196 | @@ -209,7 +214,7 @@ static void *__arm_v7s_alloc_table(int lvl, gfp_t gfp, | ||
1197 | * address directly, so if the DMA layer suggests otherwise by | ||
1198 | * translating or truncating them, that bodes very badly... | ||
1199 | */ | ||
1200 | - if (dma != virt_to_phys(table)) | ||
1201 | + if (dma != phys) | ||
1202 | goto out_unmap; | ||
1203 | } | ||
1204 | kmemleak_ignore(table); | ||
1205 | diff --git a/drivers/media/i2c/ov5645.c b/drivers/media/i2c/ov5645.c | ||
1206 | index a31fe18c71d6..2d96c1849759 100644 | ||
1207 | --- a/drivers/media/i2c/ov5645.c | ||
1208 | +++ b/drivers/media/i2c/ov5645.c | ||
1209 | @@ -510,8 +510,8 @@ static const struct reg_value ov5645_setting_full[] = { | ||
1210 | }; | ||
1211 | |||
1212 | static const s64 link_freq[] = { | ||
1213 | - 222880000, | ||
1214 | - 334320000 | ||
1215 | + 224000000, | ||
1216 | + 336000000 | ||
1217 | }; | ||
1218 | |||
1219 | static const struct ov5645_mode_info ov5645_mode_info_data[] = { | ||
1220 | @@ -520,7 +520,7 @@ static const struct ov5645_mode_info ov5645_mode_info_data[] = { | ||
1221 | .height = 960, | ||
1222 | .data = ov5645_setting_sxga, | ||
1223 | .data_size = ARRAY_SIZE(ov5645_setting_sxga), | ||
1224 | - .pixel_clock = 111440000, | ||
1225 | + .pixel_clock = 112000000, | ||
1226 | .link_freq = 0 /* an index in link_freq[] */ | ||
1227 | }, | ||
1228 | { | ||
1229 | @@ -528,7 +528,7 @@ static const struct ov5645_mode_info ov5645_mode_info_data[] = { | ||
1230 | .height = 1080, | ||
1231 | .data = ov5645_setting_1080p, | ||
1232 | .data_size = ARRAY_SIZE(ov5645_setting_1080p), | ||
1233 | - .pixel_clock = 167160000, | ||
1234 | + .pixel_clock = 168000000, | ||
1235 | .link_freq = 1 /* an index in link_freq[] */ | ||
1236 | }, | ||
1237 | { | ||
1238 | @@ -536,7 +536,7 @@ static const struct ov5645_mode_info ov5645_mode_info_data[] = { | ||
1239 | .height = 1944, | ||
1240 | .data = ov5645_setting_full, | ||
1241 | .data_size = ARRAY_SIZE(ov5645_setting_full), | ||
1242 | - .pixel_clock = 167160000, | ||
1243 | + .pixel_clock = 168000000, | ||
1244 | .link_freq = 1 /* an index in link_freq[] */ | ||
1245 | }, | ||
1246 | }; | ||
1247 | @@ -1157,7 +1157,8 @@ static int ov5645_probe(struct i2c_client *client, | ||
1248 | return ret; | ||
1249 | } | ||
1250 | |||
1251 | - if (xclk_freq != 23880000) { | ||
1252 | + /* external clock must be 24MHz, allow 1% tolerance */ | ||
1253 | + if (xclk_freq < 23760000 || xclk_freq > 24240000) { | ||
1254 | dev_err(dev, "external clock frequency %u is not supported\n", | ||
1255 | xclk_freq); | ||
1256 | return -EINVAL; | ||
1257 | diff --git a/drivers/media/pci/tw686x/tw686x-video.c b/drivers/media/pci/tw686x/tw686x-video.c | ||
1258 | index 0ea8dd44026c..3a06c000f97b 100644 | ||
1259 | --- a/drivers/media/pci/tw686x/tw686x-video.c | ||
1260 | +++ b/drivers/media/pci/tw686x/tw686x-video.c | ||
1261 | @@ -1190,6 +1190,14 @@ int tw686x_video_init(struct tw686x_dev *dev) | ||
1262 | return err; | ||
1263 | } | ||
1264 | |||
1265 | + /* Initialize vc->dev and vc->ch for the error path */ | ||
1266 | + for (ch = 0; ch < max_channels(dev); ch++) { | ||
1267 | + struct tw686x_video_channel *vc = &dev->video_channels[ch]; | ||
1268 | + | ||
1269 | + vc->dev = dev; | ||
1270 | + vc->ch = ch; | ||
1271 | + } | ||
1272 | + | ||
1273 | for (ch = 0; ch < max_channels(dev); ch++) { | ||
1274 | struct tw686x_video_channel *vc = &dev->video_channels[ch]; | ||
1275 | struct video_device *vdev; | ||
1276 | @@ -1198,9 +1206,6 @@ int tw686x_video_init(struct tw686x_dev *dev) | ||
1277 | spin_lock_init(&vc->qlock); | ||
1278 | INIT_LIST_HEAD(&vc->vidq_queued); | ||
1279 | |||
1280 | - vc->dev = dev; | ||
1281 | - vc->ch = ch; | ||
1282 | - | ||
1283 | /* default settings */ | ||
1284 | err = tw686x_set_standard(vc, V4L2_STD_NTSC); | ||
1285 | if (err) | ||
1286 | diff --git a/drivers/media/v4l2-core/videobuf2-core.c b/drivers/media/v4l2-core/videobuf2-core.c | ||
1287 | index 2dbf632c10de..43522a09b11d 100644 | ||
1288 | --- a/drivers/media/v4l2-core/videobuf2-core.c | ||
1289 | +++ b/drivers/media/v4l2-core/videobuf2-core.c | ||
1290 | @@ -1373,6 +1373,11 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb) | ||
1291 | struct vb2_buffer *vb; | ||
1292 | int ret; | ||
1293 | |||
1294 | + if (q->error) { | ||
1295 | + dprintk(1, "fatal error occurred on queue\n"); | ||
1296 | + return -EIO; | ||
1297 | + } | ||
1298 | + | ||
1299 | vb = q->bufs[index]; | ||
1300 | |||
1301 | switch (vb->state) { | ||
1302 | diff --git a/drivers/mfd/88pm860x-i2c.c b/drivers/mfd/88pm860x-i2c.c | ||
1303 | index 84e313107233..7b9052ea7413 100644 | ||
1304 | --- a/drivers/mfd/88pm860x-i2c.c | ||
1305 | +++ b/drivers/mfd/88pm860x-i2c.c | ||
1306 | @@ -146,14 +146,14 @@ int pm860x_page_reg_write(struct i2c_client *i2c, int reg, | ||
1307 | unsigned char zero; | ||
1308 | int ret; | ||
1309 | |||
1310 | - i2c_lock_adapter(i2c->adapter); | ||
1311 | + i2c_lock_bus(i2c->adapter, I2C_LOCK_SEGMENT); | ||
1312 | read_device(i2c, 0xFA, 0, &zero); | ||
1313 | read_device(i2c, 0xFB, 0, &zero); | ||
1314 | read_device(i2c, 0xFF, 0, &zero); | ||
1315 | ret = write_device(i2c, reg, 1, &data); | ||
1316 | read_device(i2c, 0xFE, 0, &zero); | ||
1317 | read_device(i2c, 0xFC, 0, &zero); | ||
1318 | - i2c_unlock_adapter(i2c->adapter); | ||
1319 | + i2c_unlock_bus(i2c->adapter, I2C_LOCK_SEGMENT); | ||
1320 | return ret; | ||
1321 | } | ||
1322 | EXPORT_SYMBOL(pm860x_page_reg_write); | ||
1323 | @@ -164,14 +164,14 @@ int pm860x_page_bulk_read(struct i2c_client *i2c, int reg, | ||
1324 | unsigned char zero = 0; | ||
1325 | int ret; | ||
1326 | |||
1327 | - i2c_lock_adapter(i2c->adapter); | ||
1328 | + i2c_lock_bus(i2c->adapter, I2C_LOCK_SEGMENT); | ||
1329 | read_device(i2c, 0xfa, 0, &zero); | ||
1330 | read_device(i2c, 0xfb, 0, &zero); | ||
1331 | read_device(i2c, 0xff, 0, &zero); | ||
1332 | ret = read_device(i2c, reg, count, buf); | ||
1333 | read_device(i2c, 0xFE, 0, &zero); | ||
1334 | read_device(i2c, 0xFC, 0, &zero); | ||
1335 | - i2c_unlock_adapter(i2c->adapter); | ||
1336 | + i2c_unlock_bus(i2c->adapter, I2C_LOCK_SEGMENT); | ||
1337 | return ret; | ||
1338 | } | ||
1339 | EXPORT_SYMBOL(pm860x_page_bulk_read); | ||
1340 | diff --git a/drivers/misc/hmc6352.c b/drivers/misc/hmc6352.c | ||
1341 | index eeb7eef62174..38f90e179927 100644 | ||
1342 | --- a/drivers/misc/hmc6352.c | ||
1343 | +++ b/drivers/misc/hmc6352.c | ||
1344 | @@ -27,6 +27,7 @@ | ||
1345 | #include <linux/err.h> | ||
1346 | #include <linux/delay.h> | ||
1347 | #include <linux/sysfs.h> | ||
1348 | +#include <linux/nospec.h> | ||
1349 | |||
1350 | static DEFINE_MUTEX(compass_mutex); | ||
1351 | |||
1352 | @@ -50,6 +51,7 @@ static int compass_store(struct device *dev, const char *buf, size_t count, | ||
1353 | return ret; | ||
1354 | if (val >= strlen(map)) | ||
1355 | return -EINVAL; | ||
1356 | + val = array_index_nospec(val, strlen(map)); | ||
1357 | mutex_lock(&compass_mutex); | ||
1358 | ret = compass_command(c, map[val]); | ||
1359 | mutex_unlock(&compass_mutex); | ||
1360 | diff --git a/drivers/misc/mei/bus-fixup.c b/drivers/misc/mei/bus-fixup.c | ||
1361 | index 0208c4b027c5..fa0236a5e59a 100644 | ||
1362 | --- a/drivers/misc/mei/bus-fixup.c | ||
1363 | +++ b/drivers/misc/mei/bus-fixup.c | ||
1364 | @@ -267,7 +267,7 @@ static int mei_nfc_if_version(struct mei_cl *cl, | ||
1365 | |||
1366 | ret = 0; | ||
1367 | bytes_recv = __mei_cl_recv(cl, (u8 *)reply, if_version_length, 0); | ||
1368 | - if (bytes_recv < if_version_length) { | ||
1369 | + if (bytes_recv < 0 || bytes_recv < if_version_length) { | ||
1370 | dev_err(bus->dev, "Could not read IF version\n"); | ||
1371 | ret = -EIO; | ||
1372 | goto err; | ||
1373 | diff --git a/drivers/misc/mei/bus.c b/drivers/misc/mei/bus.c | ||
1374 | index 1ac10cb64d6e..37b13bc5c16f 100644 | ||
1375 | --- a/drivers/misc/mei/bus.c | ||
1376 | +++ b/drivers/misc/mei/bus.c | ||
1377 | @@ -465,17 +465,15 @@ int mei_cldev_enable(struct mei_cl_device *cldev) | ||
1378 | |||
1379 | cl = cldev->cl; | ||
1380 | |||
1381 | + mutex_lock(&bus->device_lock); | ||
1382 | if (cl->state == MEI_FILE_UNINITIALIZED) { | ||
1383 | - mutex_lock(&bus->device_lock); | ||
1384 | ret = mei_cl_link(cl); | ||
1385 | - mutex_unlock(&bus->device_lock); | ||
1386 | if (ret) | ||
1387 | - return ret; | ||
1388 | + goto out; | ||
1389 | /* update pointers */ | ||
1390 | cl->cldev = cldev; | ||
1391 | } | ||
1392 | |||
1393 | - mutex_lock(&bus->device_lock); | ||
1394 | if (mei_cl_is_connected(cl)) { | ||
1395 | ret = 0; | ||
1396 | goto out; | ||
1397 | @@ -841,12 +839,13 @@ static void mei_cl_bus_dev_release(struct device *dev) | ||
1398 | |||
1399 | mei_me_cl_put(cldev->me_cl); | ||
1400 | mei_dev_bus_put(cldev->bus); | ||
1401 | + mei_cl_unlink(cldev->cl); | ||
1402 | kfree(cldev->cl); | ||
1403 | kfree(cldev); | ||
1404 | } | ||
1405 | |||
1406 | static const struct device_type mei_cl_device_type = { | ||
1407 | - .release = mei_cl_bus_dev_release, | ||
1408 | + .release = mei_cl_bus_dev_release, | ||
1409 | }; | ||
1410 | |||
1411 | /** | ||
1412 | diff --git a/drivers/misc/mei/hbm.c b/drivers/misc/mei/hbm.c | ||
1413 | index fe6595fe94f1..995ff1b7e7b5 100644 | ||
1414 | --- a/drivers/misc/mei/hbm.c | ||
1415 | +++ b/drivers/misc/mei/hbm.c | ||
1416 | @@ -1140,15 +1140,18 @@ int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr) | ||
1417 | |||
1418 | props_res = (struct hbm_props_response *)mei_msg; | ||
1419 | |||
1420 | - if (props_res->status) { | ||
1421 | + if (props_res->status == MEI_HBMS_CLIENT_NOT_FOUND) { | ||
1422 | + dev_dbg(dev->dev, "hbm: properties response: %d CLIENT_NOT_FOUND\n", | ||
1423 | + props_res->me_addr); | ||
1424 | + } else if (props_res->status) { | ||
1425 | dev_err(dev->dev, "hbm: properties response: wrong status = %d %s\n", | ||
1426 | props_res->status, | ||
1427 | mei_hbm_status_str(props_res->status)); | ||
1428 | return -EPROTO; | ||
1429 | + } else { | ||
1430 | + mei_hbm_me_cl_add(dev, props_res); | ||
1431 | } | ||
1432 | |||
1433 | - mei_hbm_me_cl_add(dev, props_res); | ||
1434 | - | ||
1435 | /* request property for the next client */ | ||
1436 | if (mei_hbm_prop_req(dev, props_res->me_addr + 1)) | ||
1437 | return -EIO; | ||
1438 | diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c | ||
1439 | index 3b5e6d11069b..9e03fada16dc 100644 | ||
1440 | --- a/drivers/mmc/host/omap_hsmmc.c | ||
1441 | +++ b/drivers/mmc/host/omap_hsmmc.c | ||
1442 | @@ -2194,6 +2194,7 @@ static int omap_hsmmc_remove(struct platform_device *pdev) | ||
1443 | dma_release_channel(host->tx_chan); | ||
1444 | dma_release_channel(host->rx_chan); | ||
1445 | |||
1446 | + dev_pm_clear_wake_irq(host->dev); | ||
1447 | pm_runtime_dont_use_autosuspend(host->dev); | ||
1448 | pm_runtime_put_sync(host->dev); | ||
1449 | pm_runtime_disable(host->dev); | ||
1450 | diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c | ||
1451 | index 4ffa6b173a21..8332f56e6c0d 100644 | ||
1452 | --- a/drivers/mmc/host/sdhci-of-esdhc.c | ||
1453 | +++ b/drivers/mmc/host/sdhci-of-esdhc.c | ||
1454 | @@ -22,6 +22,7 @@ | ||
1455 | #include <linux/sys_soc.h> | ||
1456 | #include <linux/clk.h> | ||
1457 | #include <linux/ktime.h> | ||
1458 | +#include <linux/dma-mapping.h> | ||
1459 | #include <linux/mmc/host.h> | ||
1460 | #include "sdhci-pltfm.h" | ||
1461 | #include "sdhci-esdhc.h" | ||
1462 | @@ -427,6 +428,11 @@ static void esdhc_of_adma_workaround(struct sdhci_host *host, u32 intmask) | ||
1463 | static int esdhc_of_enable_dma(struct sdhci_host *host) | ||
1464 | { | ||
1465 | u32 value; | ||
1466 | + struct device *dev = mmc_dev(host->mmc); | ||
1467 | + | ||
1468 | + if (of_device_is_compatible(dev->of_node, "fsl,ls1043a-esdhc") || | ||
1469 | + of_device_is_compatible(dev->of_node, "fsl,ls1046a-esdhc")) | ||
1470 | + dma_set_mask_and_coherent(dev, DMA_BIT_MASK(40)); | ||
1471 | |||
1472 | value = sdhci_readl(host, ESDHC_DMA_SYSCTL); | ||
1473 | value |= ESDHC_DMA_SNOOP; | ||
1474 | diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c | ||
1475 | index 0cd6fa80db66..ce3f344d2b66 100644 | ||
1476 | --- a/drivers/mmc/host/sdhci-tegra.c | ||
1477 | +++ b/drivers/mmc/host/sdhci-tegra.c | ||
1478 | @@ -334,7 +334,8 @@ static const struct sdhci_pltfm_data sdhci_tegra30_pdata = { | ||
1479 | SDHCI_QUIRK_NO_HISPD_BIT | | ||
1480 | SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC | | ||
1481 | SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN, | ||
1482 | - .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN, | ||
1483 | + .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN | | ||
1484 | + SDHCI_QUIRK2_BROKEN_HS200, | ||
1485 | .ops = &tegra_sdhci_ops, | ||
1486 | }; | ||
1487 | |||
1488 | diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c | ||
1489 | index d35deb79965d..f063fe569339 100644 | ||
1490 | --- a/drivers/mmc/host/sdhci.c | ||
1491 | +++ b/drivers/mmc/host/sdhci.c | ||
1492 | @@ -3631,14 +3631,21 @@ int sdhci_setup_host(struct sdhci_host *host) | ||
1493 | mmc_gpio_get_cd(host->mmc) < 0) | ||
1494 | mmc->caps |= MMC_CAP_NEEDS_POLL; | ||
1495 | |||
1496 | - /* If vqmmc regulator and no 1.8V signalling, then there's no UHS */ | ||
1497 | if (!IS_ERR(mmc->supply.vqmmc)) { | ||
1498 | ret = regulator_enable(mmc->supply.vqmmc); | ||
1499 | + | ||
1500 | + /* If vqmmc provides no 1.8V signalling, then there's no UHS */ | ||
1501 | if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000, | ||
1502 | 1950000)) | ||
1503 | host->caps1 &= ~(SDHCI_SUPPORT_SDR104 | | ||
1504 | SDHCI_SUPPORT_SDR50 | | ||
1505 | SDHCI_SUPPORT_DDR50); | ||
1506 | + | ||
1507 | + /* In eMMC case vqmmc might be a fixed 1.8V regulator */ | ||
1508 | + if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000, | ||
1509 | + 3600000)) | ||
1510 | + host->flags &= ~SDHCI_SIGNALING_330; | ||
1511 | + | ||
1512 | if (ret) { | ||
1513 | pr_warn("%s: Failed to enable vqmmc regulator: %d\n", | ||
1514 | mmc_hostname(mmc), ret); | ||
1515 | diff --git a/drivers/mtd/maps/solutionengine.c b/drivers/mtd/maps/solutionengine.c | ||
1516 | index bb580bc16445..c07f21b20463 100644 | ||
1517 | --- a/drivers/mtd/maps/solutionengine.c | ||
1518 | +++ b/drivers/mtd/maps/solutionengine.c | ||
1519 | @@ -59,9 +59,9 @@ static int __init init_soleng_maps(void) | ||
1520 | return -ENXIO; | ||
1521 | } | ||
1522 | } | ||
1523 | - printk(KERN_NOTICE "Solution Engine: Flash at 0x%08lx, EPROM at 0x%08lx\n", | ||
1524 | - soleng_flash_map.phys & 0x1fffffff, | ||
1525 | - soleng_eprom_map.phys & 0x1fffffff); | ||
1526 | + printk(KERN_NOTICE "Solution Engine: Flash at 0x%pap, EPROM at 0x%pap\n", | ||
1527 | + &soleng_flash_map.phys, | ||
1528 | + &soleng_eprom_map.phys); | ||
1529 | flash_mtd->owner = THIS_MODULE; | ||
1530 | |||
1531 | eprom_mtd = do_map_probe("map_rom", &soleng_eprom_map); | ||
1532 | diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c | ||
1533 | index b25f444c5914..fa4d12217652 100644 | ||
1534 | --- a/drivers/mtd/mtdchar.c | ||
1535 | +++ b/drivers/mtd/mtdchar.c | ||
1536 | @@ -160,8 +160,12 @@ static ssize_t mtdchar_read(struct file *file, char __user *buf, size_t count, | ||
1537 | |||
1538 | pr_debug("MTD_read\n"); | ||
1539 | |||
1540 | - if (*ppos + count > mtd->size) | ||
1541 | - count = mtd->size - *ppos; | ||
1542 | + if (*ppos + count > mtd->size) { | ||
1543 | + if (*ppos < mtd->size) | ||
1544 | + count = mtd->size - *ppos; | ||
1545 | + else | ||
1546 | + count = 0; | ||
1547 | + } | ||
1548 | |||
1549 | if (!count) | ||
1550 | return 0; | ||
1551 | @@ -246,7 +250,7 @@ static ssize_t mtdchar_write(struct file *file, const char __user *buf, size_t c | ||
1552 | |||
1553 | pr_debug("MTD_write\n"); | ||
1554 | |||
1555 | - if (*ppos == mtd->size) | ||
1556 | + if (*ppos >= mtd->size) | ||
1557 | return -ENOSPC; | ||
1558 | |||
1559 | if (*ppos + count > mtd->size) | ||
1560 | diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-desc.c b/drivers/net/ethernet/amd/xgbe/xgbe-desc.c | ||
1561 | index 45d92304068e..a5eaf174d914 100644 | ||
1562 | --- a/drivers/net/ethernet/amd/xgbe/xgbe-desc.c | ||
1563 | +++ b/drivers/net/ethernet/amd/xgbe/xgbe-desc.c | ||
1564 | @@ -289,7 +289,7 @@ static int xgbe_alloc_pages(struct xgbe_prv_data *pdata, | ||
1565 | struct page *pages = NULL; | ||
1566 | dma_addr_t pages_dma; | ||
1567 | gfp_t gfp; | ||
1568 | - int order, ret; | ||
1569 | + int order; | ||
1570 | |||
1571 | again: | ||
1572 | order = alloc_order; | ||
1573 | @@ -316,10 +316,9 @@ again: | ||
1574 | /* Map the pages */ | ||
1575 | pages_dma = dma_map_page(pdata->dev, pages, 0, | ||
1576 | PAGE_SIZE << order, DMA_FROM_DEVICE); | ||
1577 | - ret = dma_mapping_error(pdata->dev, pages_dma); | ||
1578 | - if (ret) { | ||
1579 | + if (dma_mapping_error(pdata->dev, pages_dma)) { | ||
1580 | put_page(pages); | ||
1581 | - return ret; | ||
1582 | + return -ENOMEM; | ||
1583 | } | ||
1584 | |||
1585 | pa->pages = pages; | ||
1586 | diff --git a/drivers/net/ethernet/cavium/liquidio/cn23xx_pf_device.c b/drivers/net/ethernet/cavium/liquidio/cn23xx_pf_device.c | ||
1587 | index e8b290473ee2..2e089b5ff8f3 100644 | ||
1588 | --- a/drivers/net/ethernet/cavium/liquidio/cn23xx_pf_device.c | ||
1589 | +++ b/drivers/net/ethernet/cavium/liquidio/cn23xx_pf_device.c | ||
1590 | @@ -493,6 +493,9 @@ static void cn23xx_pf_setup_global_output_regs(struct octeon_device *oct) | ||
1591 | for (q_no = srn; q_no < ern; q_no++) { | ||
1592 | reg_val = octeon_read_csr(oct, CN23XX_SLI_OQ_PKT_CONTROL(q_no)); | ||
1593 | |||
1594 | + /* clear IPTR */ | ||
1595 | + reg_val &= ~CN23XX_PKT_OUTPUT_CTL_IPTR; | ||
1596 | + | ||
1597 | /* set DPTR */ | ||
1598 | reg_val |= CN23XX_PKT_OUTPUT_CTL_DPTR; | ||
1599 | |||
1600 | diff --git a/drivers/net/ethernet/cavium/liquidio/cn23xx_vf_device.c b/drivers/net/ethernet/cavium/liquidio/cn23xx_vf_device.c | ||
1601 | index 9338a0008378..1f8b7f651254 100644 | ||
1602 | --- a/drivers/net/ethernet/cavium/liquidio/cn23xx_vf_device.c | ||
1603 | +++ b/drivers/net/ethernet/cavium/liquidio/cn23xx_vf_device.c | ||
1604 | @@ -165,6 +165,9 @@ static void cn23xx_vf_setup_global_output_regs(struct octeon_device *oct) | ||
1605 | reg_val = | ||
1606 | octeon_read_csr(oct, CN23XX_VF_SLI_OQ_PKT_CONTROL(q_no)); | ||
1607 | |||
1608 | + /* clear IPTR */ | ||
1609 | + reg_val &= ~CN23XX_PKT_OUTPUT_CTL_IPTR; | ||
1610 | + | ||
1611 | /* set DPTR */ | ||
1612 | reg_val |= CN23XX_PKT_OUTPUT_CTL_DPTR; | ||
1613 | |||
1614 | diff --git a/drivers/net/ethernet/emulex/benet/be_cmds.c b/drivers/net/ethernet/emulex/benet/be_cmds.c | ||
1615 | index 02dd5246dfae..1589a568bfe0 100644 | ||
1616 | --- a/drivers/net/ethernet/emulex/benet/be_cmds.c | ||
1617 | +++ b/drivers/net/ethernet/emulex/benet/be_cmds.c | ||
1618 | @@ -4500,7 +4500,7 @@ int be_cmd_get_profile_config(struct be_adapter *adapter, | ||
1619 | port_res->max_vfs += le16_to_cpu(pcie->num_vfs); | ||
1620 | } | ||
1621 | } | ||
1622 | - return status; | ||
1623 | + goto err; | ||
1624 | } | ||
1625 | |||
1626 | pcie = be_get_pcie_desc(resp->func_param, desc_count, | ||
1627 | diff --git a/drivers/net/ethernet/intel/e1000e/defines.h b/drivers/net/ethernet/intel/e1000e/defines.h | ||
1628 | index afb7ebe20b24..824fd44e25f0 100644 | ||
1629 | --- a/drivers/net/ethernet/intel/e1000e/defines.h | ||
1630 | +++ b/drivers/net/ethernet/intel/e1000e/defines.h | ||
1631 | @@ -400,6 +400,10 @@ | ||
1632 | #define E1000_ICR_RXDMT0 0x00000010 /* Rx desc min. threshold (0) */ | ||
1633 | #define E1000_ICR_RXO 0x00000040 /* Receiver Overrun */ | ||
1634 | #define E1000_ICR_RXT0 0x00000080 /* Rx timer intr (ring 0) */ | ||
1635 | +#define E1000_ICR_MDAC 0x00000200 /* MDIO Access Complete */ | ||
1636 | +#define E1000_ICR_SRPD 0x00010000 /* Small Receive Packet Detected */ | ||
1637 | +#define E1000_ICR_ACK 0x00020000 /* Receive ACK Frame Detected */ | ||
1638 | +#define E1000_ICR_MNG 0x00040000 /* Manageability Event Detected */ | ||
1639 | #define E1000_ICR_ECCER 0x00400000 /* Uncorrectable ECC Error */ | ||
1640 | /* If this bit asserted, the driver should claim the interrupt */ | ||
1641 | #define E1000_ICR_INT_ASSERTED 0x80000000 | ||
1642 | @@ -407,7 +411,7 @@ | ||
1643 | #define E1000_ICR_RXQ1 0x00200000 /* Rx Queue 1 Interrupt */ | ||
1644 | #define E1000_ICR_TXQ0 0x00400000 /* Tx Queue 0 Interrupt */ | ||
1645 | #define E1000_ICR_TXQ1 0x00800000 /* Tx Queue 1 Interrupt */ | ||
1646 | -#define E1000_ICR_OTHER 0x01000000 /* Other Interrupts */ | ||
1647 | +#define E1000_ICR_OTHER 0x01000000 /* Other Interrupt */ | ||
1648 | |||
1649 | /* PBA ECC Register */ | ||
1650 | #define E1000_PBA_ECC_COUNTER_MASK 0xFFF00000 /* ECC counter mask */ | ||
1651 | @@ -431,12 +435,27 @@ | ||
1652 | E1000_IMS_RXSEQ | \ | ||
1653 | E1000_IMS_LSC) | ||
1654 | |||
1655 | +/* These are all of the events related to the OTHER interrupt. | ||
1656 | + */ | ||
1657 | +#define IMS_OTHER_MASK ( \ | ||
1658 | + E1000_IMS_LSC | \ | ||
1659 | + E1000_IMS_RXO | \ | ||
1660 | + E1000_IMS_MDAC | \ | ||
1661 | + E1000_IMS_SRPD | \ | ||
1662 | + E1000_IMS_ACK | \ | ||
1663 | + E1000_IMS_MNG) | ||
1664 | + | ||
1665 | /* Interrupt Mask Set */ | ||
1666 | #define E1000_IMS_TXDW E1000_ICR_TXDW /* Transmit desc written back */ | ||
1667 | #define E1000_IMS_LSC E1000_ICR_LSC /* Link Status Change */ | ||
1668 | #define E1000_IMS_RXSEQ E1000_ICR_RXSEQ /* Rx sequence error */ | ||
1669 | #define E1000_IMS_RXDMT0 E1000_ICR_RXDMT0 /* Rx desc min. threshold */ | ||
1670 | +#define E1000_IMS_RXO E1000_ICR_RXO /* Receiver Overrun */ | ||
1671 | #define E1000_IMS_RXT0 E1000_ICR_RXT0 /* Rx timer intr */ | ||
1672 | +#define E1000_IMS_MDAC E1000_ICR_MDAC /* MDIO Access Complete */ | ||
1673 | +#define E1000_IMS_SRPD E1000_ICR_SRPD /* Small Receive Packet */ | ||
1674 | +#define E1000_IMS_ACK E1000_ICR_ACK /* Receive ACK Frame Detected */ | ||
1675 | +#define E1000_IMS_MNG E1000_ICR_MNG /* Manageability Event */ | ||
1676 | #define E1000_IMS_ECCER E1000_ICR_ECCER /* Uncorrectable ECC Error */ | ||
1677 | #define E1000_IMS_RXQ0 E1000_ICR_RXQ0 /* Rx Queue 0 Interrupt */ | ||
1678 | #define E1000_IMS_RXQ1 E1000_ICR_RXQ1 /* Rx Queue 1 Interrupt */ | ||
1679 | diff --git a/drivers/net/ethernet/intel/e1000e/ich8lan.c b/drivers/net/ethernet/intel/e1000e/ich8lan.c | ||
1680 | index ff308b05d68c..00eedf202e62 100644 | ||
1681 | --- a/drivers/net/ethernet/intel/e1000e/ich8lan.c | ||
1682 | +++ b/drivers/net/ethernet/intel/e1000e/ich8lan.c | ||
1683 | @@ -1367,9 +1367,6 @@ out: | ||
1684 | * Checks to see of the link status of the hardware has changed. If a | ||
1685 | * change in link status has been detected, then we read the PHY registers | ||
1686 | * to get the current speed/duplex if link exists. | ||
1687 | - * | ||
1688 | - * Returns a negative error code (-E1000_ERR_*) or 0 (link down) or 1 (link | ||
1689 | - * up). | ||
1690 | **/ | ||
1691 | static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1692 | { | ||
1693 | @@ -1385,7 +1382,8 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1694 | * Change or Rx Sequence Error interrupt. | ||
1695 | */ | ||
1696 | if (!mac->get_link_status) | ||
1697 | - return 1; | ||
1698 | + return 0; | ||
1699 | + mac->get_link_status = false; | ||
1700 | |||
1701 | /* First we want to see if the MII Status Register reports | ||
1702 | * link. If so, then we want to get the current speed/duplex | ||
1703 | @@ -1393,12 +1391,12 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1704 | */ | ||
1705 | ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link); | ||
1706 | if (ret_val) | ||
1707 | - return ret_val; | ||
1708 | + goto out; | ||
1709 | |||
1710 | if (hw->mac.type == e1000_pchlan) { | ||
1711 | ret_val = e1000_k1_gig_workaround_hv(hw, link); | ||
1712 | if (ret_val) | ||
1713 | - return ret_val; | ||
1714 | + goto out; | ||
1715 | } | ||
1716 | |||
1717 | /* When connected at 10Mbps half-duplex, some parts are excessively | ||
1718 | @@ -1431,7 +1429,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1719 | |||
1720 | ret_val = hw->phy.ops.acquire(hw); | ||
1721 | if (ret_val) | ||
1722 | - return ret_val; | ||
1723 | + goto out; | ||
1724 | |||
1725 | if (hw->mac.type == e1000_pch2lan) | ||
1726 | emi_addr = I82579_RX_CONFIG; | ||
1727 | @@ -1453,7 +1451,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1728 | hw->phy.ops.release(hw); | ||
1729 | |||
1730 | if (ret_val) | ||
1731 | - return ret_val; | ||
1732 | + goto out; | ||
1733 | |||
1734 | if (hw->mac.type >= e1000_pch_spt) { | ||
1735 | u16 data; | ||
1736 | @@ -1462,14 +1460,14 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1737 | if (speed == SPEED_1000) { | ||
1738 | ret_val = hw->phy.ops.acquire(hw); | ||
1739 | if (ret_val) | ||
1740 | - return ret_val; | ||
1741 | + goto out; | ||
1742 | |||
1743 | ret_val = e1e_rphy_locked(hw, | ||
1744 | PHY_REG(776, 20), | ||
1745 | &data); | ||
1746 | if (ret_val) { | ||
1747 | hw->phy.ops.release(hw); | ||
1748 | - return ret_val; | ||
1749 | + goto out; | ||
1750 | } | ||
1751 | |||
1752 | ptr_gap = (data & (0x3FF << 2)) >> 2; | ||
1753 | @@ -1483,18 +1481,18 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1754 | } | ||
1755 | hw->phy.ops.release(hw); | ||
1756 | if (ret_val) | ||
1757 | - return ret_val; | ||
1758 | + goto out; | ||
1759 | } else { | ||
1760 | ret_val = hw->phy.ops.acquire(hw); | ||
1761 | if (ret_val) | ||
1762 | - return ret_val; | ||
1763 | + goto out; | ||
1764 | |||
1765 | ret_val = e1e_wphy_locked(hw, | ||
1766 | PHY_REG(776, 20), | ||
1767 | 0xC023); | ||
1768 | hw->phy.ops.release(hw); | ||
1769 | if (ret_val) | ||
1770 | - return ret_val; | ||
1771 | + goto out; | ||
1772 | |||
1773 | } | ||
1774 | } | ||
1775 | @@ -1521,7 +1519,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1776 | (hw->adapter->pdev->device == E1000_DEV_ID_PCH_I218_V3)) { | ||
1777 | ret_val = e1000_k1_workaround_lpt_lp(hw, link); | ||
1778 | if (ret_val) | ||
1779 | - return ret_val; | ||
1780 | + goto out; | ||
1781 | } | ||
1782 | if (hw->mac.type >= e1000_pch_lpt) { | ||
1783 | /* Set platform power management values for | ||
1784 | @@ -1529,7 +1527,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1785 | */ | ||
1786 | ret_val = e1000_platform_pm_pch_lpt(hw, link); | ||
1787 | if (ret_val) | ||
1788 | - return ret_val; | ||
1789 | + goto out; | ||
1790 | } | ||
1791 | |||
1792 | /* Clear link partner's EEE ability */ | ||
1793 | @@ -1552,9 +1550,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1794 | } | ||
1795 | |||
1796 | if (!link) | ||
1797 | - return 0; /* No link detected */ | ||
1798 | - | ||
1799 | - mac->get_link_status = false; | ||
1800 | + goto out; | ||
1801 | |||
1802 | switch (hw->mac.type) { | ||
1803 | case e1000_pch2lan: | ||
1804 | @@ -1616,12 +1612,14 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) | ||
1805 | * different link partner. | ||
1806 | */ | ||
1807 | ret_val = e1000e_config_fc_after_link_up(hw); | ||
1808 | - if (ret_val) { | ||
1809 | + if (ret_val) | ||
1810 | e_dbg("Error configuring flow control\n"); | ||
1811 | - return ret_val; | ||
1812 | - } | ||
1813 | |||
1814 | - return 1; | ||
1815 | + return ret_val; | ||
1816 | + | ||
1817 | +out: | ||
1818 | + mac->get_link_status = true; | ||
1819 | + return ret_val; | ||
1820 | } | ||
1821 | |||
1822 | static s32 e1000_get_variants_ich8lan(struct e1000_adapter *adapter) | ||
1823 | diff --git a/drivers/net/ethernet/intel/e1000e/mac.c b/drivers/net/ethernet/intel/e1000e/mac.c | ||
1824 | index db735644b312..48cc945fc8b0 100644 | ||
1825 | --- a/drivers/net/ethernet/intel/e1000e/mac.c | ||
1826 | +++ b/drivers/net/ethernet/intel/e1000e/mac.c | ||
1827 | @@ -410,9 +410,6 @@ void e1000e_clear_hw_cntrs_base(struct e1000_hw *hw) | ||
1828 | * Checks to see of the link status of the hardware has changed. If a | ||
1829 | * change in link status has been detected, then we read the PHY registers | ||
1830 | * to get the current speed/duplex if link exists. | ||
1831 | - * | ||
1832 | - * Returns a negative error code (-E1000_ERR_*) or 0 (link down) or 1 (link | ||
1833 | - * up). | ||
1834 | **/ | ||
1835 | s32 e1000e_check_for_copper_link(struct e1000_hw *hw) | ||
1836 | { | ||
1837 | @@ -426,20 +423,16 @@ s32 e1000e_check_for_copper_link(struct e1000_hw *hw) | ||
1838 | * Change or Rx Sequence Error interrupt. | ||
1839 | */ | ||
1840 | if (!mac->get_link_status) | ||
1841 | - return 1; | ||
1842 | + return 0; | ||
1843 | + mac->get_link_status = false; | ||
1844 | |||
1845 | /* First we want to see if the MII Status Register reports | ||
1846 | * link. If so, then we want to get the current speed/duplex | ||
1847 | * of the PHY. | ||
1848 | */ | ||
1849 | ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link); | ||
1850 | - if (ret_val) | ||
1851 | - return ret_val; | ||
1852 | - | ||
1853 | - if (!link) | ||
1854 | - return 0; /* No link detected */ | ||
1855 | - | ||
1856 | - mac->get_link_status = false; | ||
1857 | + if (ret_val || !link) | ||
1858 | + goto out; | ||
1859 | |||
1860 | /* Check if there was DownShift, must be checked | ||
1861 | * immediately after link-up | ||
1862 | @@ -464,12 +457,14 @@ s32 e1000e_check_for_copper_link(struct e1000_hw *hw) | ||
1863 | * different link partner. | ||
1864 | */ | ||
1865 | ret_val = e1000e_config_fc_after_link_up(hw); | ||
1866 | - if (ret_val) { | ||
1867 | + if (ret_val) | ||
1868 | e_dbg("Error configuring flow control\n"); | ||
1869 | - return ret_val; | ||
1870 | - } | ||
1871 | |||
1872 | - return 1; | ||
1873 | + return ret_val; | ||
1874 | + | ||
1875 | +out: | ||
1876 | + mac->get_link_status = true; | ||
1877 | + return ret_val; | ||
1878 | } | ||
1879 | |||
1880 | /** | ||
1881 | diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c | ||
1882 | index 6265ce8915b6..a25dc581a903 100644 | ||
1883 | --- a/drivers/net/ethernet/intel/e1000e/netdev.c | ||
1884 | +++ b/drivers/net/ethernet/intel/e1000e/netdev.c | ||
1885 | @@ -1910,30 +1910,20 @@ static irqreturn_t e1000_msix_other(int __always_unused irq, void *data) | ||
1886 | struct net_device *netdev = data; | ||
1887 | struct e1000_adapter *adapter = netdev_priv(netdev); | ||
1888 | struct e1000_hw *hw = &adapter->hw; | ||
1889 | - u32 icr; | ||
1890 | - bool enable = true; | ||
1891 | - | ||
1892 | - icr = er32(ICR); | ||
1893 | - if (icr & E1000_ICR_RXO) { | ||
1894 | - ew32(ICR, E1000_ICR_RXO); | ||
1895 | - enable = false; | ||
1896 | - /* napi poll will re-enable Other, make sure it runs */ | ||
1897 | - if (napi_schedule_prep(&adapter->napi)) { | ||
1898 | - adapter->total_rx_bytes = 0; | ||
1899 | - adapter->total_rx_packets = 0; | ||
1900 | - __napi_schedule(&adapter->napi); | ||
1901 | - } | ||
1902 | - } | ||
1903 | + u32 icr = er32(ICR); | ||
1904 | + | ||
1905 | + if (icr & adapter->eiac_mask) | ||
1906 | + ew32(ICS, (icr & adapter->eiac_mask)); | ||
1907 | + | ||
1908 | if (icr & E1000_ICR_LSC) { | ||
1909 | - ew32(ICR, E1000_ICR_LSC); | ||
1910 | hw->mac.get_link_status = true; | ||
1911 | /* guard against interrupt when we're going down */ | ||
1912 | if (!test_bit(__E1000_DOWN, &adapter->state)) | ||
1913 | mod_timer(&adapter->watchdog_timer, jiffies + 1); | ||
1914 | } | ||
1915 | |||
1916 | - if (enable && !test_bit(__E1000_DOWN, &adapter->state)) | ||
1917 | - ew32(IMS, E1000_IMS_OTHER); | ||
1918 | + if (!test_bit(__E1000_DOWN, &adapter->state)) | ||
1919 | + ew32(IMS, E1000_IMS_OTHER | IMS_OTHER_MASK); | ||
1920 | |||
1921 | return IRQ_HANDLED; | ||
1922 | } | ||
1923 | @@ -2036,7 +2026,6 @@ static void e1000_configure_msix(struct e1000_adapter *adapter) | ||
1924 | hw->hw_addr + E1000_EITR_82574(vector)); | ||
1925 | else | ||
1926 | writel(1, hw->hw_addr + E1000_EITR_82574(vector)); | ||
1927 | - adapter->eiac_mask |= E1000_IMS_OTHER; | ||
1928 | |||
1929 | /* Cause Tx interrupts on every write back */ | ||
1930 | ivar |= BIT(31); | ||
1931 | @@ -2261,7 +2250,8 @@ static void e1000_irq_enable(struct e1000_adapter *adapter) | ||
1932 | |||
1933 | if (adapter->msix_entries) { | ||
1934 | ew32(EIAC_82574, adapter->eiac_mask & E1000_EIAC_MASK_82574); | ||
1935 | - ew32(IMS, adapter->eiac_mask | E1000_IMS_LSC); | ||
1936 | + ew32(IMS, adapter->eiac_mask | E1000_IMS_OTHER | | ||
1937 | + IMS_OTHER_MASK); | ||
1938 | } else if (hw->mac.type >= e1000_pch_lpt) { | ||
1939 | ew32(IMS, IMS_ENABLE_MASK | E1000_IMS_ECCER); | ||
1940 | } else { | ||
1941 | @@ -2703,8 +2693,7 @@ static int e1000e_poll(struct napi_struct *napi, int weight) | ||
1942 | napi_complete_done(napi, work_done); | ||
1943 | if (!test_bit(__E1000_DOWN, &adapter->state)) { | ||
1944 | if (adapter->msix_entries) | ||
1945 | - ew32(IMS, adapter->rx_ring->ims_val | | ||
1946 | - E1000_IMS_OTHER); | ||
1947 | + ew32(IMS, adapter->rx_ring->ims_val); | ||
1948 | else | ||
1949 | e1000_irq_enable(adapter); | ||
1950 | } | ||
1951 | @@ -5100,7 +5089,7 @@ static bool e1000e_has_link(struct e1000_adapter *adapter) | ||
1952 | case e1000_media_type_copper: | ||
1953 | if (hw->mac.get_link_status) { | ||
1954 | ret_val = hw->mac.ops.check_for_link(hw); | ||
1955 | - link_active = ret_val > 0; | ||
1956 | + link_active = !hw->mac.get_link_status; | ||
1957 | } else { | ||
1958 | link_active = true; | ||
1959 | } | ||
1960 | diff --git a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c | ||
1961 | index cf94fdf25155..c7654209668b 100644 | ||
1962 | --- a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c | ||
1963 | +++ b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c | ||
1964 | @@ -449,6 +449,7 @@ const char *mlx5_command_str(int command) | ||
1965 | MLX5_COMMAND_STR_CASE(SET_HCA_CAP); | ||
1966 | MLX5_COMMAND_STR_CASE(QUERY_ISSI); | ||
1967 | MLX5_COMMAND_STR_CASE(SET_ISSI); | ||
1968 | + MLX5_COMMAND_STR_CASE(SET_DRIVER_VERSION); | ||
1969 | MLX5_COMMAND_STR_CASE(CREATE_MKEY); | ||
1970 | MLX5_COMMAND_STR_CASE(QUERY_MKEY); | ||
1971 | MLX5_COMMAND_STR_CASE(DESTROY_MKEY); | ||
1972 | diff --git a/drivers/net/ethernet/mellanox/mlx5/core/dev.c b/drivers/net/ethernet/mellanox/mlx5/core/dev.c | ||
1973 | index 17b723218b0c..9f9c9ff10735 100644 | ||
1974 | --- a/drivers/net/ethernet/mellanox/mlx5/core/dev.c | ||
1975 | +++ b/drivers/net/ethernet/mellanox/mlx5/core/dev.c | ||
1976 | @@ -132,11 +132,11 @@ void mlx5_add_device(struct mlx5_interface *intf, struct mlx5_priv *priv) | ||
1977 | delayed_event_start(priv); | ||
1978 | |||
1979 | dev_ctx->context = intf->add(dev); | ||
1980 | - set_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state); | ||
1981 | - if (intf->attach) | ||
1982 | - set_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state); | ||
1983 | - | ||
1984 | if (dev_ctx->context) { | ||
1985 | + set_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state); | ||
1986 | + if (intf->attach) | ||
1987 | + set_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state); | ||
1988 | + | ||
1989 | spin_lock_irq(&priv->ctx_lock); | ||
1990 | list_add_tail(&dev_ctx->list, &priv->ctx_list); | ||
1991 | |||
1992 | @@ -211,12 +211,17 @@ static void mlx5_attach_interface(struct mlx5_interface *intf, struct mlx5_priv | ||
1993 | if (intf->attach) { | ||
1994 | if (test_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state)) | ||
1995 | goto out; | ||
1996 | - intf->attach(dev, dev_ctx->context); | ||
1997 | + if (intf->attach(dev, dev_ctx->context)) | ||
1998 | + goto out; | ||
1999 | + | ||
2000 | set_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state); | ||
2001 | } else { | ||
2002 | if (test_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state)) | ||
2003 | goto out; | ||
2004 | dev_ctx->context = intf->add(dev); | ||
2005 | + if (!dev_ctx->context) | ||
2006 | + goto out; | ||
2007 | + | ||
2008 | set_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state); | ||
2009 | } | ||
2010 | |||
2011 | diff --git a/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c b/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c | ||
2012 | index c699055c0ffd..4b52b722135d 100644 | ||
2013 | --- a/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c | ||
2014 | +++ b/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c | ||
2015 | @@ -557,6 +557,7 @@ static int esw_create_offloads_fdb_tables(struct mlx5_eswitch *esw, int nvports) | ||
2016 | if (err) | ||
2017 | goto miss_rule_err; | ||
2018 | |||
2019 | + kvfree(flow_group_in); | ||
2020 | return 0; | ||
2021 | |||
2022 | miss_rule_err: | ||
2023 | diff --git a/drivers/net/ethernet/mellanox/mlx5/core/health.c b/drivers/net/ethernet/mellanox/mlx5/core/health.c | ||
2024 | index db86e1506c8b..61f284966a8c 100644 | ||
2025 | --- a/drivers/net/ethernet/mellanox/mlx5/core/health.c | ||
2026 | +++ b/drivers/net/ethernet/mellanox/mlx5/core/health.c | ||
2027 | @@ -333,9 +333,17 @@ void mlx5_start_health_poll(struct mlx5_core_dev *dev) | ||
2028 | add_timer(&health->timer); | ||
2029 | } | ||
2030 | |||
2031 | -void mlx5_stop_health_poll(struct mlx5_core_dev *dev) | ||
2032 | +void mlx5_stop_health_poll(struct mlx5_core_dev *dev, bool disable_health) | ||
2033 | { | ||
2034 | struct mlx5_core_health *health = &dev->priv.health; | ||
2035 | + unsigned long flags; | ||
2036 | + | ||
2037 | + if (disable_health) { | ||
2038 | + spin_lock_irqsave(&health->wq_lock, flags); | ||
2039 | + set_bit(MLX5_DROP_NEW_HEALTH_WORK, &health->flags); | ||
2040 | + set_bit(MLX5_DROP_NEW_RECOVERY_WORK, &health->flags); | ||
2041 | + spin_unlock_irqrestore(&health->wq_lock, flags); | ||
2042 | + } | ||
2043 | |||
2044 | del_timer_sync(&health->timer); | ||
2045 | } | ||
2046 | diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c | ||
2047 | index 4ddd632d10f9..e99f1382a4f0 100644 | ||
2048 | --- a/drivers/net/ethernet/mellanox/mlx5/core/main.c | ||
2049 | +++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c | ||
2050 | @@ -857,8 +857,10 @@ static int mlx5_pci_init(struct mlx5_core_dev *dev, struct mlx5_priv *priv) | ||
2051 | priv->numa_node = dev_to_node(&dev->pdev->dev); | ||
2052 | |||
2053 | priv->dbg_root = debugfs_create_dir(dev_name(&pdev->dev), mlx5_debugfs_root); | ||
2054 | - if (!priv->dbg_root) | ||
2055 | + if (!priv->dbg_root) { | ||
2056 | + dev_err(&pdev->dev, "Cannot create debugfs dir, aborting\n"); | ||
2057 | return -ENOMEM; | ||
2058 | + } | ||
2059 | |||
2060 | err = mlx5_pci_enable_device(dev); | ||
2061 | if (err) { | ||
2062 | @@ -907,7 +909,7 @@ static void mlx5_pci_close(struct mlx5_core_dev *dev, struct mlx5_priv *priv) | ||
2063 | pci_clear_master(dev->pdev); | ||
2064 | release_bar(dev->pdev); | ||
2065 | mlx5_pci_disable_device(dev); | ||
2066 | - debugfs_remove(priv->dbg_root); | ||
2067 | + debugfs_remove_recursive(priv->dbg_root); | ||
2068 | } | ||
2069 | |||
2070 | static int mlx5_init_once(struct mlx5_core_dev *dev, struct mlx5_priv *priv) | ||
2071 | @@ -1227,7 +1229,7 @@ err_cleanup_once: | ||
2072 | mlx5_cleanup_once(dev); | ||
2073 | |||
2074 | err_stop_poll: | ||
2075 | - mlx5_stop_health_poll(dev); | ||
2076 | + mlx5_stop_health_poll(dev, boot); | ||
2077 | if (mlx5_cmd_teardown_hca(dev)) { | ||
2078 | dev_err(&dev->pdev->dev, "tear_down_hca failed, skip cleanup\n"); | ||
2079 | goto out_err; | ||
2080 | @@ -1286,7 +1288,7 @@ static int mlx5_unload_one(struct mlx5_core_dev *dev, struct mlx5_priv *priv, | ||
2081 | mlx5_free_irq_vectors(dev); | ||
2082 | if (cleanup) | ||
2083 | mlx5_cleanup_once(dev); | ||
2084 | - mlx5_stop_health_poll(dev); | ||
2085 | + mlx5_stop_health_poll(dev, cleanup); | ||
2086 | err = mlx5_cmd_teardown_hca(dev); | ||
2087 | if (err) { | ||
2088 | dev_err(&dev->pdev->dev, "tear_down_hca failed, skip cleanup\n"); | ||
2089 | @@ -1548,7 +1550,7 @@ static int mlx5_try_fast_unload(struct mlx5_core_dev *dev) | ||
2090 | * with the HCA, so the health polll is no longer needed. | ||
2091 | */ | ||
2092 | mlx5_drain_health_wq(dev); | ||
2093 | - mlx5_stop_health_poll(dev); | ||
2094 | + mlx5_stop_health_poll(dev, false); | ||
2095 | |||
2096 | ret = mlx5_cmd_force_teardown_hca(dev); | ||
2097 | if (ret) { | ||
2098 | diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c | ||
2099 | index b482a8fb0e92..56751990bcee 100644 | ||
2100 | --- a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c | ||
2101 | +++ b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c | ||
2102 | @@ -1087,7 +1087,7 @@ static bool nfp_net_xdp_complete(struct nfp_net_tx_ring *tx_ring) | ||
2103 | * @dp: NFP Net data path struct | ||
2104 | * @tx_ring: TX ring structure | ||
2105 | * | ||
2106 | - * Assumes that the device is stopped | ||
2107 | + * Assumes that the device is stopped, must be idempotent. | ||
2108 | */ | ||
2109 | static void | ||
2110 | nfp_net_tx_ring_reset(struct nfp_net_dp *dp, struct nfp_net_tx_ring *tx_ring) | ||
2111 | @@ -1289,13 +1289,18 @@ static void nfp_net_rx_give_one(const struct nfp_net_dp *dp, | ||
2112 | * nfp_net_rx_ring_reset() - Reflect in SW state of freelist after disable | ||
2113 | * @rx_ring: RX ring structure | ||
2114 | * | ||
2115 | - * Warning: Do *not* call if ring buffers were never put on the FW freelist | ||
2116 | - * (i.e. device was not enabled)! | ||
2117 | + * Assumes that the device is stopped, must be idempotent. | ||
2118 | */ | ||
2119 | static void nfp_net_rx_ring_reset(struct nfp_net_rx_ring *rx_ring) | ||
2120 | { | ||
2121 | unsigned int wr_idx, last_idx; | ||
2122 | |||
2123 | + /* wr_p == rd_p means ring was never fed FL bufs. RX rings are always | ||
2124 | + * kept at cnt - 1 FL bufs. | ||
2125 | + */ | ||
2126 | + if (rx_ring->wr_p == 0 && rx_ring->rd_p == 0) | ||
2127 | + return; | ||
2128 | + | ||
2129 | /* Move the empty entry to the end of the list */ | ||
2130 | wr_idx = D_IDX(rx_ring, rx_ring->wr_p); | ||
2131 | last_idx = rx_ring->cnt - 1; | ||
2132 | @@ -2505,6 +2510,8 @@ static void nfp_net_vec_clear_ring_data(struct nfp_net *nn, unsigned int idx) | ||
2133 | /** | ||
2134 | * nfp_net_clear_config_and_disable() - Clear control BAR and disable NFP | ||
2135 | * @nn: NFP Net device to reconfigure | ||
2136 | + * | ||
2137 | + * Warning: must be fully idempotent. | ||
2138 | */ | ||
2139 | static void nfp_net_clear_config_and_disable(struct nfp_net *nn) | ||
2140 | { | ||
2141 | diff --git a/drivers/net/ethernet/qualcomm/qca_7k.c b/drivers/net/ethernet/qualcomm/qca_7k.c | ||
2142 | index ffe7a16bdfc8..6c8543fb90c0 100644 | ||
2143 | --- a/drivers/net/ethernet/qualcomm/qca_7k.c | ||
2144 | +++ b/drivers/net/ethernet/qualcomm/qca_7k.c | ||
2145 | @@ -45,34 +45,33 @@ qcaspi_read_register(struct qcaspi *qca, u16 reg, u16 *result) | ||
2146 | { | ||
2147 | __be16 rx_data; | ||
2148 | __be16 tx_data; | ||
2149 | - struct spi_transfer *transfer; | ||
2150 | - struct spi_message *msg; | ||
2151 | + struct spi_transfer transfer[2]; | ||
2152 | + struct spi_message msg; | ||
2153 | int ret; | ||
2154 | |||
2155 | + memset(transfer, 0, sizeof(transfer)); | ||
2156 | + | ||
2157 | + spi_message_init(&msg); | ||
2158 | + | ||
2159 | tx_data = cpu_to_be16(QCA7K_SPI_READ | QCA7K_SPI_INTERNAL | reg); | ||
2160 | + *result = 0; | ||
2161 | + | ||
2162 | + transfer[0].tx_buf = &tx_data; | ||
2163 | + transfer[0].len = QCASPI_CMD_LEN; | ||
2164 | + transfer[1].rx_buf = &rx_data; | ||
2165 | + transfer[1].len = QCASPI_CMD_LEN; | ||
2166 | + | ||
2167 | + spi_message_add_tail(&transfer[0], &msg); | ||
2168 | |||
2169 | if (qca->legacy_mode) { | ||
2170 | - msg = &qca->spi_msg1; | ||
2171 | - transfer = &qca->spi_xfer1; | ||
2172 | - transfer->tx_buf = &tx_data; | ||
2173 | - transfer->rx_buf = NULL; | ||
2174 | - transfer->len = QCASPI_CMD_LEN; | ||
2175 | - spi_sync(qca->spi_dev, msg); | ||
2176 | - } else { | ||
2177 | - msg = &qca->spi_msg2; | ||
2178 | - transfer = &qca->spi_xfer2[0]; | ||
2179 | - transfer->tx_buf = &tx_data; | ||
2180 | - transfer->rx_buf = NULL; | ||
2181 | - transfer->len = QCASPI_CMD_LEN; | ||
2182 | - transfer = &qca->spi_xfer2[1]; | ||
2183 | + spi_sync(qca->spi_dev, &msg); | ||
2184 | + spi_message_init(&msg); | ||
2185 | } | ||
2186 | - transfer->tx_buf = NULL; | ||
2187 | - transfer->rx_buf = &rx_data; | ||
2188 | - transfer->len = QCASPI_CMD_LEN; | ||
2189 | - ret = spi_sync(qca->spi_dev, msg); | ||
2190 | + spi_message_add_tail(&transfer[1], &msg); | ||
2191 | + ret = spi_sync(qca->spi_dev, &msg); | ||
2192 | |||
2193 | if (!ret) | ||
2194 | - ret = msg->status; | ||
2195 | + ret = msg.status; | ||
2196 | |||
2197 | if (ret) | ||
2198 | qcaspi_spi_error(qca); | ||
2199 | @@ -86,35 +85,32 @@ int | ||
2200 | qcaspi_write_register(struct qcaspi *qca, u16 reg, u16 value) | ||
2201 | { | ||
2202 | __be16 tx_data[2]; | ||
2203 | - struct spi_transfer *transfer; | ||
2204 | - struct spi_message *msg; | ||
2205 | + struct spi_transfer transfer[2]; | ||
2206 | + struct spi_message msg; | ||
2207 | int ret; | ||
2208 | |||
2209 | + memset(&transfer, 0, sizeof(transfer)); | ||
2210 | + | ||
2211 | + spi_message_init(&msg); | ||
2212 | + | ||
2213 | tx_data[0] = cpu_to_be16(QCA7K_SPI_WRITE | QCA7K_SPI_INTERNAL | reg); | ||
2214 | tx_data[1] = cpu_to_be16(value); | ||
2215 | |||
2216 | + transfer[0].tx_buf = &tx_data[0]; | ||
2217 | + transfer[0].len = QCASPI_CMD_LEN; | ||
2218 | + transfer[1].tx_buf = &tx_data[1]; | ||
2219 | + transfer[1].len = QCASPI_CMD_LEN; | ||
2220 | + | ||
2221 | + spi_message_add_tail(&transfer[0], &msg); | ||
2222 | if (qca->legacy_mode) { | ||
2223 | - msg = &qca->spi_msg1; | ||
2224 | - transfer = &qca->spi_xfer1; | ||
2225 | - transfer->tx_buf = &tx_data[0]; | ||
2226 | - transfer->rx_buf = NULL; | ||
2227 | - transfer->len = QCASPI_CMD_LEN; | ||
2228 | - spi_sync(qca->spi_dev, msg); | ||
2229 | - } else { | ||
2230 | - msg = &qca->spi_msg2; | ||
2231 | - transfer = &qca->spi_xfer2[0]; | ||
2232 | - transfer->tx_buf = &tx_data[0]; | ||
2233 | - transfer->rx_buf = NULL; | ||
2234 | - transfer->len = QCASPI_CMD_LEN; | ||
2235 | - transfer = &qca->spi_xfer2[1]; | ||
2236 | + spi_sync(qca->spi_dev, &msg); | ||
2237 | + spi_message_init(&msg); | ||
2238 | } | ||
2239 | - transfer->tx_buf = &tx_data[1]; | ||
2240 | - transfer->rx_buf = NULL; | ||
2241 | - transfer->len = QCASPI_CMD_LEN; | ||
2242 | - ret = spi_sync(qca->spi_dev, msg); | ||
2243 | + spi_message_add_tail(&transfer[1], &msg); | ||
2244 | + ret = spi_sync(qca->spi_dev, &msg); | ||
2245 | |||
2246 | if (!ret) | ||
2247 | - ret = msg->status; | ||
2248 | + ret = msg.status; | ||
2249 | |||
2250 | if (ret) | ||
2251 | qcaspi_spi_error(qca); | ||
2252 | diff --git a/drivers/net/ethernet/qualcomm/qca_spi.c b/drivers/net/ethernet/qualcomm/qca_spi.c | ||
2253 | index b1f5f0b8e546..275fc6f154a7 100644 | ||
2254 | --- a/drivers/net/ethernet/qualcomm/qca_spi.c | ||
2255 | +++ b/drivers/net/ethernet/qualcomm/qca_spi.c | ||
2256 | @@ -99,22 +99,24 @@ static u32 | ||
2257 | qcaspi_write_burst(struct qcaspi *qca, u8 *src, u32 len) | ||
2258 | { | ||
2259 | __be16 cmd; | ||
2260 | - struct spi_message *msg = &qca->spi_msg2; | ||
2261 | - struct spi_transfer *transfer = &qca->spi_xfer2[0]; | ||
2262 | + struct spi_message msg; | ||
2263 | + struct spi_transfer transfer[2]; | ||
2264 | int ret; | ||
2265 | |||
2266 | + memset(&transfer, 0, sizeof(transfer)); | ||
2267 | + spi_message_init(&msg); | ||
2268 | + | ||
2269 | cmd = cpu_to_be16(QCA7K_SPI_WRITE | QCA7K_SPI_EXTERNAL); | ||
2270 | - transfer->tx_buf = &cmd; | ||
2271 | - transfer->rx_buf = NULL; | ||
2272 | - transfer->len = QCASPI_CMD_LEN; | ||
2273 | - transfer = &qca->spi_xfer2[1]; | ||
2274 | - transfer->tx_buf = src; | ||
2275 | - transfer->rx_buf = NULL; | ||
2276 | - transfer->len = len; | ||
2277 | + transfer[0].tx_buf = &cmd; | ||
2278 | + transfer[0].len = QCASPI_CMD_LEN; | ||
2279 | + transfer[1].tx_buf = src; | ||
2280 | + transfer[1].len = len; | ||
2281 | |||
2282 | - ret = spi_sync(qca->spi_dev, msg); | ||
2283 | + spi_message_add_tail(&transfer[0], &msg); | ||
2284 | + spi_message_add_tail(&transfer[1], &msg); | ||
2285 | + ret = spi_sync(qca->spi_dev, &msg); | ||
2286 | |||
2287 | - if (ret || (msg->actual_length != QCASPI_CMD_LEN + len)) { | ||
2288 | + if (ret || (msg.actual_length != QCASPI_CMD_LEN + len)) { | ||
2289 | qcaspi_spi_error(qca); | ||
2290 | return 0; | ||
2291 | } | ||
2292 | @@ -125,17 +127,20 @@ qcaspi_write_burst(struct qcaspi *qca, u8 *src, u32 len) | ||
2293 | static u32 | ||
2294 | qcaspi_write_legacy(struct qcaspi *qca, u8 *src, u32 len) | ||
2295 | { | ||
2296 | - struct spi_message *msg = &qca->spi_msg1; | ||
2297 | - struct spi_transfer *transfer = &qca->spi_xfer1; | ||
2298 | + struct spi_message msg; | ||
2299 | + struct spi_transfer transfer; | ||
2300 | int ret; | ||
2301 | |||
2302 | - transfer->tx_buf = src; | ||
2303 | - transfer->rx_buf = NULL; | ||
2304 | - transfer->len = len; | ||
2305 | + memset(&transfer, 0, sizeof(transfer)); | ||
2306 | + spi_message_init(&msg); | ||
2307 | + | ||
2308 | + transfer.tx_buf = src; | ||
2309 | + transfer.len = len; | ||
2310 | |||
2311 | - ret = spi_sync(qca->spi_dev, msg); | ||
2312 | + spi_message_add_tail(&transfer, &msg); | ||
2313 | + ret = spi_sync(qca->spi_dev, &msg); | ||
2314 | |||
2315 | - if (ret || (msg->actual_length != len)) { | ||
2316 | + if (ret || (msg.actual_length != len)) { | ||
2317 | qcaspi_spi_error(qca); | ||
2318 | return 0; | ||
2319 | } | ||
2320 | @@ -146,23 +151,25 @@ qcaspi_write_legacy(struct qcaspi *qca, u8 *src, u32 len) | ||
2321 | static u32 | ||
2322 | qcaspi_read_burst(struct qcaspi *qca, u8 *dst, u32 len) | ||
2323 | { | ||
2324 | - struct spi_message *msg = &qca->spi_msg2; | ||
2325 | + struct spi_message msg; | ||
2326 | __be16 cmd; | ||
2327 | - struct spi_transfer *transfer = &qca->spi_xfer2[0]; | ||
2328 | + struct spi_transfer transfer[2]; | ||
2329 | int ret; | ||
2330 | |||
2331 | + memset(&transfer, 0, sizeof(transfer)); | ||
2332 | + spi_message_init(&msg); | ||
2333 | + | ||
2334 | cmd = cpu_to_be16(QCA7K_SPI_READ | QCA7K_SPI_EXTERNAL); | ||
2335 | - transfer->tx_buf = &cmd; | ||
2336 | - transfer->rx_buf = NULL; | ||
2337 | - transfer->len = QCASPI_CMD_LEN; | ||
2338 | - transfer = &qca->spi_xfer2[1]; | ||
2339 | - transfer->tx_buf = NULL; | ||
2340 | - transfer->rx_buf = dst; | ||
2341 | - transfer->len = len; | ||
2342 | + transfer[0].tx_buf = &cmd; | ||
2343 | + transfer[0].len = QCASPI_CMD_LEN; | ||
2344 | + transfer[1].rx_buf = dst; | ||
2345 | + transfer[1].len = len; | ||
2346 | |||
2347 | - ret = spi_sync(qca->spi_dev, msg); | ||
2348 | + spi_message_add_tail(&transfer[0], &msg); | ||
2349 | + spi_message_add_tail(&transfer[1], &msg); | ||
2350 | + ret = spi_sync(qca->spi_dev, &msg); | ||
2351 | |||
2352 | - if (ret || (msg->actual_length != QCASPI_CMD_LEN + len)) { | ||
2353 | + if (ret || (msg.actual_length != QCASPI_CMD_LEN + len)) { | ||
2354 | qcaspi_spi_error(qca); | ||
2355 | return 0; | ||
2356 | } | ||
2357 | @@ -173,17 +180,20 @@ qcaspi_read_burst(struct qcaspi *qca, u8 *dst, u32 len) | ||
2358 | static u32 | ||
2359 | qcaspi_read_legacy(struct qcaspi *qca, u8 *dst, u32 len) | ||
2360 | { | ||
2361 | - struct spi_message *msg = &qca->spi_msg1; | ||
2362 | - struct spi_transfer *transfer = &qca->spi_xfer1; | ||
2363 | + struct spi_message msg; | ||
2364 | + struct spi_transfer transfer; | ||
2365 | int ret; | ||
2366 | |||
2367 | - transfer->tx_buf = NULL; | ||
2368 | - transfer->rx_buf = dst; | ||
2369 | - transfer->len = len; | ||
2370 | + memset(&transfer, 0, sizeof(transfer)); | ||
2371 | + spi_message_init(&msg); | ||
2372 | |||
2373 | - ret = spi_sync(qca->spi_dev, msg); | ||
2374 | + transfer.rx_buf = dst; | ||
2375 | + transfer.len = len; | ||
2376 | |||
2377 | - if (ret || (msg->actual_length != len)) { | ||
2378 | + spi_message_add_tail(&transfer, &msg); | ||
2379 | + ret = spi_sync(qca->spi_dev, &msg); | ||
2380 | + | ||
2381 | + if (ret || (msg.actual_length != len)) { | ||
2382 | qcaspi_spi_error(qca); | ||
2383 | return 0; | ||
2384 | } | ||
2385 | @@ -195,19 +205,23 @@ static int | ||
2386 | qcaspi_tx_cmd(struct qcaspi *qca, u16 cmd) | ||
2387 | { | ||
2388 | __be16 tx_data; | ||
2389 | - struct spi_message *msg = &qca->spi_msg1; | ||
2390 | - struct spi_transfer *transfer = &qca->spi_xfer1; | ||
2391 | + struct spi_message msg; | ||
2392 | + struct spi_transfer transfer; | ||
2393 | int ret; | ||
2394 | |||
2395 | + memset(&transfer, 0, sizeof(transfer)); | ||
2396 | + | ||
2397 | + spi_message_init(&msg); | ||
2398 | + | ||
2399 | tx_data = cpu_to_be16(cmd); | ||
2400 | - transfer->len = sizeof(tx_data); | ||
2401 | - transfer->tx_buf = &tx_data; | ||
2402 | - transfer->rx_buf = NULL; | ||
2403 | + transfer.len = sizeof(cmd); | ||
2404 | + transfer.tx_buf = &tx_data; | ||
2405 | + spi_message_add_tail(&transfer, &msg); | ||
2406 | |||
2407 | - ret = spi_sync(qca->spi_dev, msg); | ||
2408 | + ret = spi_sync(qca->spi_dev, &msg); | ||
2409 | |||
2410 | if (!ret) | ||
2411 | - ret = msg->status; | ||
2412 | + ret = msg.status; | ||
2413 | |||
2414 | if (ret) | ||
2415 | qcaspi_spi_error(qca); | ||
2416 | @@ -836,16 +850,6 @@ qcaspi_netdev_setup(struct net_device *dev) | ||
2417 | qca = netdev_priv(dev); | ||
2418 | memset(qca, 0, sizeof(struct qcaspi)); | ||
2419 | |||
2420 | - memset(&qca->spi_xfer1, 0, sizeof(struct spi_transfer)); | ||
2421 | - memset(&qca->spi_xfer2, 0, sizeof(struct spi_transfer) * 2); | ||
2422 | - | ||
2423 | - spi_message_init(&qca->spi_msg1); | ||
2424 | - spi_message_add_tail(&qca->spi_xfer1, &qca->spi_msg1); | ||
2425 | - | ||
2426 | - spi_message_init(&qca->spi_msg2); | ||
2427 | - spi_message_add_tail(&qca->spi_xfer2[0], &qca->spi_msg2); | ||
2428 | - spi_message_add_tail(&qca->spi_xfer2[1], &qca->spi_msg2); | ||
2429 | - | ||
2430 | memset(&qca->txr, 0, sizeof(qca->txr)); | ||
2431 | qca->txr.count = TX_RING_MAX_LEN; | ||
2432 | } | ||
2433 | diff --git a/drivers/net/ethernet/qualcomm/qca_spi.h b/drivers/net/ethernet/qualcomm/qca_spi.h | ||
2434 | index fc4beb1b32d1..fc0e98726b36 100644 | ||
2435 | --- a/drivers/net/ethernet/qualcomm/qca_spi.h | ||
2436 | +++ b/drivers/net/ethernet/qualcomm/qca_spi.h | ||
2437 | @@ -83,11 +83,6 @@ struct qcaspi { | ||
2438 | struct tx_ring txr; | ||
2439 | struct qcaspi_stats stats; | ||
2440 | |||
2441 | - struct spi_message spi_msg1; | ||
2442 | - struct spi_message spi_msg2; | ||
2443 | - struct spi_transfer spi_xfer1; | ||
2444 | - struct spi_transfer spi_xfer2[2]; | ||
2445 | - | ||
2446 | u8 *rx_buffer; | ||
2447 | u32 buffer_size; | ||
2448 | u8 sync; | ||
2449 | diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c | ||
2450 | index 328c37e9096d..17025d46bdac 100644 | ||
2451 | --- a/drivers/net/hyperv/rndis_filter.c | ||
2452 | +++ b/drivers/net/hyperv/rndis_filter.c | ||
2453 | @@ -1299,7 +1299,7 @@ out: | ||
2454 | /* setting up multiple channels failed */ | ||
2455 | net_device->max_chn = 1; | ||
2456 | net_device->num_chn = 1; | ||
2457 | - return 0; | ||
2458 | + return net_device; | ||
2459 | |||
2460 | err_dev_remv: | ||
2461 | rndis_filter_device_remove(dev, net_device); | ||
2462 | diff --git a/drivers/net/wan/fsl_ucc_hdlc.c b/drivers/net/wan/fsl_ucc_hdlc.c | ||
2463 | index 33df76405b86..18b648648adb 100644 | ||
2464 | --- a/drivers/net/wan/fsl_ucc_hdlc.c | ||
2465 | +++ b/drivers/net/wan/fsl_ucc_hdlc.c | ||
2466 | @@ -192,7 +192,7 @@ static int uhdlc_init(struct ucc_hdlc_private *priv) | ||
2467 | priv->ucc_pram_offset = qe_muram_alloc(sizeof(struct ucc_hdlc_param), | ||
2468 | ALIGNMENT_OF_UCC_HDLC_PRAM); | ||
2469 | |||
2470 | - if (priv->ucc_pram_offset < 0) { | ||
2471 | + if (IS_ERR_VALUE(priv->ucc_pram_offset)) { | ||
2472 | dev_err(priv->dev, "Can not allocate MURAM for hdlc parameter.\n"); | ||
2473 | ret = -ENOMEM; | ||
2474 | goto free_tx_bd; | ||
2475 | @@ -228,14 +228,14 @@ static int uhdlc_init(struct ucc_hdlc_private *priv) | ||
2476 | |||
2477 | /* Alloc riptr, tiptr */ | ||
2478 | riptr = qe_muram_alloc(32, 32); | ||
2479 | - if (riptr < 0) { | ||
2480 | + if (IS_ERR_VALUE(riptr)) { | ||
2481 | dev_err(priv->dev, "Cannot allocate MURAM mem for Receive internal temp data pointer\n"); | ||
2482 | ret = -ENOMEM; | ||
2483 | goto free_tx_skbuff; | ||
2484 | } | ||
2485 | |||
2486 | tiptr = qe_muram_alloc(32, 32); | ||
2487 | - if (tiptr < 0) { | ||
2488 | + if (IS_ERR_VALUE(tiptr)) { | ||
2489 | dev_err(priv->dev, "Cannot allocate MURAM mem for Transmit internal temp data pointer\n"); | ||
2490 | ret = -ENOMEM; | ||
2491 | goto free_riptr; | ||
2492 | diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c | ||
2493 | index d5e790dd589a..d80343429de5 100644 | ||
2494 | --- a/drivers/net/xen-netfront.c | ||
2495 | +++ b/drivers/net/xen-netfront.c | ||
2496 | @@ -87,8 +87,7 @@ struct netfront_cb { | ||
2497 | /* IRQ name is queue name with "-tx" or "-rx" appended */ | ||
2498 | #define IRQ_NAME_SIZE (QUEUE_NAME_SIZE + 3) | ||
2499 | |||
2500 | -static DECLARE_WAIT_QUEUE_HEAD(module_load_q); | ||
2501 | -static DECLARE_WAIT_QUEUE_HEAD(module_unload_q); | ||
2502 | +static DECLARE_WAIT_QUEUE_HEAD(module_wq); | ||
2503 | |||
2504 | struct netfront_stats { | ||
2505 | u64 packets; | ||
2506 | @@ -1331,11 +1330,11 @@ static struct net_device *xennet_create_dev(struct xenbus_device *dev) | ||
2507 | netif_carrier_off(netdev); | ||
2508 | |||
2509 | xenbus_switch_state(dev, XenbusStateInitialising); | ||
2510 | - wait_event(module_load_q, | ||
2511 | - xenbus_read_driver_state(dev->otherend) != | ||
2512 | - XenbusStateClosed && | ||
2513 | - xenbus_read_driver_state(dev->otherend) != | ||
2514 | - XenbusStateUnknown); | ||
2515 | + wait_event(module_wq, | ||
2516 | + xenbus_read_driver_state(dev->otherend) != | ||
2517 | + XenbusStateClosed && | ||
2518 | + xenbus_read_driver_state(dev->otherend) != | ||
2519 | + XenbusStateUnknown); | ||
2520 | return netdev; | ||
2521 | |||
2522 | exit: | ||
2523 | @@ -1603,6 +1602,7 @@ static int xennet_init_queue(struct netfront_queue *queue) | ||
2524 | { | ||
2525 | unsigned short i; | ||
2526 | int err = 0; | ||
2527 | + char *devid; | ||
2528 | |||
2529 | spin_lock_init(&queue->tx_lock); | ||
2530 | spin_lock_init(&queue->rx_lock); | ||
2531 | @@ -1610,8 +1610,9 @@ static int xennet_init_queue(struct netfront_queue *queue) | ||
2532 | setup_timer(&queue->rx_refill_timer, rx_refill_timeout, | ||
2533 | (unsigned long)queue); | ||
2534 | |||
2535 | - snprintf(queue->name, sizeof(queue->name), "%s-q%u", | ||
2536 | - queue->info->netdev->name, queue->id); | ||
2537 | + devid = strrchr(queue->info->xbdev->nodename, '/') + 1; | ||
2538 | + snprintf(queue->name, sizeof(queue->name), "vif%s-q%u", | ||
2539 | + devid, queue->id); | ||
2540 | |||
2541 | /* Initialise tx_skbs as a free chain containing every entry. */ | ||
2542 | queue->tx_skb_freelist = 0; | ||
2543 | @@ -2007,15 +2008,14 @@ static void netback_changed(struct xenbus_device *dev, | ||
2544 | |||
2545 | dev_dbg(&dev->dev, "%s\n", xenbus_strstate(backend_state)); | ||
2546 | |||
2547 | + wake_up_all(&module_wq); | ||
2548 | + | ||
2549 | switch (backend_state) { | ||
2550 | case XenbusStateInitialising: | ||
2551 | case XenbusStateInitialised: | ||
2552 | case XenbusStateReconfiguring: | ||
2553 | case XenbusStateReconfigured: | ||
2554 | - break; | ||
2555 | - | ||
2556 | case XenbusStateUnknown: | ||
2557 | - wake_up_all(&module_unload_q); | ||
2558 | break; | ||
2559 | |||
2560 | case XenbusStateInitWait: | ||
2561 | @@ -2031,12 +2031,10 @@ static void netback_changed(struct xenbus_device *dev, | ||
2562 | break; | ||
2563 | |||
2564 | case XenbusStateClosed: | ||
2565 | - wake_up_all(&module_unload_q); | ||
2566 | if (dev->state == XenbusStateClosed) | ||
2567 | break; | ||
2568 | /* Missed the backend's CLOSING state -- fallthrough */ | ||
2569 | case XenbusStateClosing: | ||
2570 | - wake_up_all(&module_unload_q); | ||
2571 | xenbus_frontend_closed(dev); | ||
2572 | break; | ||
2573 | } | ||
2574 | @@ -2144,14 +2142,14 @@ static int xennet_remove(struct xenbus_device *dev) | ||
2575 | |||
2576 | if (xenbus_read_driver_state(dev->otherend) != XenbusStateClosed) { | ||
2577 | xenbus_switch_state(dev, XenbusStateClosing); | ||
2578 | - wait_event(module_unload_q, | ||
2579 | + wait_event(module_wq, | ||
2580 | xenbus_read_driver_state(dev->otherend) == | ||
2581 | XenbusStateClosing || | ||
2582 | xenbus_read_driver_state(dev->otherend) == | ||
2583 | XenbusStateUnknown); | ||
2584 | |||
2585 | xenbus_switch_state(dev, XenbusStateClosed); | ||
2586 | - wait_event(module_unload_q, | ||
2587 | + wait_event(module_wq, | ||
2588 | xenbus_read_driver_state(dev->otherend) == | ||
2589 | XenbusStateClosed || | ||
2590 | xenbus_read_driver_state(dev->otherend) == | ||
2591 | diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c | ||
2592 | index 48a831d58e7a..9fffe41ead50 100644 | ||
2593 | --- a/drivers/nvme/host/rdma.c | ||
2594 | +++ b/drivers/nvme/host/rdma.c | ||
2595 | @@ -1728,6 +1728,8 @@ static void nvme_rdma_shutdown_ctrl(struct nvme_rdma_ctrl *ctrl, bool shutdown) | ||
2596 | nvme_stop_queues(&ctrl->ctrl); | ||
2597 | blk_mq_tagset_busy_iter(&ctrl->tag_set, | ||
2598 | nvme_cancel_request, &ctrl->ctrl); | ||
2599 | + if (shutdown) | ||
2600 | + nvme_start_queues(&ctrl->ctrl); | ||
2601 | nvme_rdma_destroy_io_queues(ctrl, shutdown); | ||
2602 | } | ||
2603 | |||
2604 | diff --git a/drivers/parport/parport_sunbpp.c b/drivers/parport/parport_sunbpp.c | ||
2605 | index 01cf1c1a841a..8de329546b82 100644 | ||
2606 | --- a/drivers/parport/parport_sunbpp.c | ||
2607 | +++ b/drivers/parport/parport_sunbpp.c | ||
2608 | @@ -286,12 +286,16 @@ static int bpp_probe(struct platform_device *op) | ||
2609 | |||
2610 | ops = kmemdup(&parport_sunbpp_ops, sizeof(struct parport_operations), | ||
2611 | GFP_KERNEL); | ||
2612 | - if (!ops) | ||
2613 | + if (!ops) { | ||
2614 | + err = -ENOMEM; | ||
2615 | goto out_unmap; | ||
2616 | + } | ||
2617 | |||
2618 | dprintk(("register_port\n")); | ||
2619 | - if (!(p = parport_register_port((unsigned long)base, irq, dma, ops))) | ||
2620 | + if (!(p = parport_register_port((unsigned long)base, irq, dma, ops))) { | ||
2621 | + err = -ENOMEM; | ||
2622 | goto out_free_ops; | ||
2623 | + } | ||
2624 | |||
2625 | p->size = size; | ||
2626 | p->dev = &op->dev; | ||
2627 | diff --git a/drivers/pinctrl/pinctrl-rza1.c b/drivers/pinctrl/pinctrl-rza1.c | ||
2628 | index 04d058706b80..a865dc56a491 100644 | ||
2629 | --- a/drivers/pinctrl/pinctrl-rza1.c | ||
2630 | +++ b/drivers/pinctrl/pinctrl-rza1.c | ||
2631 | @@ -878,6 +878,7 @@ static int rza1_dt_node_to_map(struct pinctrl_dev *pctldev, | ||
2632 | const char *grpname; | ||
2633 | const char **fngrps; | ||
2634 | int ret, npins; | ||
2635 | + int gsel, fsel; | ||
2636 | |||
2637 | npins = rza1_dt_node_pin_count(np); | ||
2638 | if (npins < 0) { | ||
2639 | @@ -927,18 +928,19 @@ static int rza1_dt_node_to_map(struct pinctrl_dev *pctldev, | ||
2640 | fngrps[0] = grpname; | ||
2641 | |||
2642 | mutex_lock(&rza1_pctl->mutex); | ||
2643 | - ret = pinctrl_generic_add_group(pctldev, grpname, grpins, npins, | ||
2644 | - NULL); | ||
2645 | - if (ret) { | ||
2646 | + gsel = pinctrl_generic_add_group(pctldev, grpname, grpins, npins, | ||
2647 | + NULL); | ||
2648 | + if (gsel < 0) { | ||
2649 | mutex_unlock(&rza1_pctl->mutex); | ||
2650 | - return ret; | ||
2651 | + return gsel; | ||
2652 | } | ||
2653 | |||
2654 | - ret = pinmux_generic_add_function(pctldev, grpname, fngrps, 1, | ||
2655 | - mux_confs); | ||
2656 | - if (ret) | ||
2657 | + fsel = pinmux_generic_add_function(pctldev, grpname, fngrps, 1, | ||
2658 | + mux_confs); | ||
2659 | + if (fsel < 0) { | ||
2660 | + ret = fsel; | ||
2661 | goto remove_group; | ||
2662 | - mutex_unlock(&rza1_pctl->mutex); | ||
2663 | + } | ||
2664 | |||
2665 | dev_info(rza1_pctl->dev, "Parsed function and group %s with %d pins\n", | ||
2666 | grpname, npins); | ||
2667 | @@ -955,15 +957,15 @@ static int rza1_dt_node_to_map(struct pinctrl_dev *pctldev, | ||
2668 | (*map)->data.mux.group = np->name; | ||
2669 | (*map)->data.mux.function = np->name; | ||
2670 | *num_maps = 1; | ||
2671 | + mutex_unlock(&rza1_pctl->mutex); | ||
2672 | |||
2673 | return 0; | ||
2674 | |||
2675 | remove_function: | ||
2676 | - mutex_lock(&rza1_pctl->mutex); | ||
2677 | - pinmux_generic_remove_last_function(pctldev); | ||
2678 | + pinmux_generic_remove_function(pctldev, fsel); | ||
2679 | |||
2680 | remove_group: | ||
2681 | - pinctrl_generic_remove_last_group(pctldev); | ||
2682 | + pinctrl_generic_remove_group(pctldev, gsel); | ||
2683 | mutex_unlock(&rza1_pctl->mutex); | ||
2684 | |||
2685 | dev_info(rza1_pctl->dev, "Unable to parse function and group %s\n", | ||
2686 | diff --git a/drivers/pinctrl/qcom/pinctrl-msm.c b/drivers/pinctrl/qcom/pinctrl-msm.c | ||
2687 | index ff491da64dab..31632c087504 100644 | ||
2688 | --- a/drivers/pinctrl/qcom/pinctrl-msm.c | ||
2689 | +++ b/drivers/pinctrl/qcom/pinctrl-msm.c | ||
2690 | @@ -238,22 +238,30 @@ static int msm_config_group_get(struct pinctrl_dev *pctldev, | ||
2691 | /* Convert register value to pinconf value */ | ||
2692 | switch (param) { | ||
2693 | case PIN_CONFIG_BIAS_DISABLE: | ||
2694 | - arg = arg == MSM_NO_PULL; | ||
2695 | + if (arg != MSM_NO_PULL) | ||
2696 | + return -EINVAL; | ||
2697 | + arg = 1; | ||
2698 | break; | ||
2699 | case PIN_CONFIG_BIAS_PULL_DOWN: | ||
2700 | - arg = arg == MSM_PULL_DOWN; | ||
2701 | + if (arg != MSM_PULL_DOWN) | ||
2702 | + return -EINVAL; | ||
2703 | + arg = 1; | ||
2704 | break; | ||
2705 | case PIN_CONFIG_BIAS_BUS_HOLD: | ||
2706 | if (pctrl->soc->pull_no_keeper) | ||
2707 | return -ENOTSUPP; | ||
2708 | |||
2709 | - arg = arg == MSM_KEEPER; | ||
2710 | + if (arg != MSM_KEEPER) | ||
2711 | + return -EINVAL; | ||
2712 | + arg = 1; | ||
2713 | break; | ||
2714 | case PIN_CONFIG_BIAS_PULL_UP: | ||
2715 | if (pctrl->soc->pull_no_keeper) | ||
2716 | arg = arg == MSM_PULL_UP_NO_KEEPER; | ||
2717 | else | ||
2718 | arg = arg == MSM_PULL_UP; | ||
2719 | + if (!arg) | ||
2720 | + return -EINVAL; | ||
2721 | break; | ||
2722 | case PIN_CONFIG_DRIVE_STRENGTH: | ||
2723 | arg = msm_regval_to_drive(arg); | ||
2724 | diff --git a/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c b/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c | ||
2725 | index c2c0bab04257..22aaf4375fac 100644 | ||
2726 | --- a/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c | ||
2727 | +++ b/drivers/pinctrl/qcom/pinctrl-spmi-gpio.c | ||
2728 | @@ -390,31 +390,47 @@ static int pmic_gpio_config_get(struct pinctrl_dev *pctldev, | ||
2729 | |||
2730 | switch (param) { | ||
2731 | case PIN_CONFIG_DRIVE_PUSH_PULL: | ||
2732 | - arg = pad->buffer_type == PMIC_GPIO_OUT_BUF_CMOS; | ||
2733 | + if (pad->buffer_type != PMIC_GPIO_OUT_BUF_CMOS) | ||
2734 | + return -EINVAL; | ||
2735 | + arg = 1; | ||
2736 | break; | ||
2737 | case PIN_CONFIG_DRIVE_OPEN_DRAIN: | ||
2738 | - arg = pad->buffer_type == PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS; | ||
2739 | + if (pad->buffer_type != PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS) | ||
2740 | + return -EINVAL; | ||
2741 | + arg = 1; | ||
2742 | break; | ||
2743 | case PIN_CONFIG_DRIVE_OPEN_SOURCE: | ||
2744 | - arg = pad->buffer_type == PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS; | ||
2745 | + if (pad->buffer_type != PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS) | ||
2746 | + return -EINVAL; | ||
2747 | + arg = 1; | ||
2748 | break; | ||
2749 | case PIN_CONFIG_BIAS_PULL_DOWN: | ||
2750 | - arg = pad->pullup == PMIC_GPIO_PULL_DOWN; | ||
2751 | + if (pad->pullup != PMIC_GPIO_PULL_DOWN) | ||
2752 | + return -EINVAL; | ||
2753 | + arg = 1; | ||
2754 | break; | ||
2755 | case PIN_CONFIG_BIAS_DISABLE: | ||
2756 | - arg = pad->pullup = PMIC_GPIO_PULL_DISABLE; | ||
2757 | + if (pad->pullup != PMIC_GPIO_PULL_DISABLE) | ||
2758 | + return -EINVAL; | ||
2759 | + arg = 1; | ||
2760 | break; | ||
2761 | case PIN_CONFIG_BIAS_PULL_UP: | ||
2762 | - arg = pad->pullup == PMIC_GPIO_PULL_UP_30; | ||
2763 | + if (pad->pullup != PMIC_GPIO_PULL_UP_30) | ||
2764 | + return -EINVAL; | ||
2765 | + arg = 1; | ||
2766 | break; | ||
2767 | case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: | ||
2768 | - arg = !pad->is_enabled; | ||
2769 | + if (pad->is_enabled) | ||
2770 | + return -EINVAL; | ||
2771 | + arg = 1; | ||
2772 | break; | ||
2773 | case PIN_CONFIG_POWER_SOURCE: | ||
2774 | arg = pad->power_source; | ||
2775 | break; | ||
2776 | case PIN_CONFIG_INPUT_ENABLE: | ||
2777 | - arg = pad->input_enabled; | ||
2778 | + if (!pad->input_enabled) | ||
2779 | + return -EINVAL; | ||
2780 | + arg = 1; | ||
2781 | break; | ||
2782 | case PIN_CONFIG_OUTPUT: | ||
2783 | arg = pad->out_value; | ||
2784 | diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c | ||
2785 | index bb1dcd7fbdeb..8221e000c8c2 100644 | ||
2786 | --- a/drivers/platform/x86/toshiba_acpi.c | ||
2787 | +++ b/drivers/platform/x86/toshiba_acpi.c | ||
2788 | @@ -34,6 +34,7 @@ | ||
2789 | #define TOSHIBA_ACPI_VERSION "0.24" | ||
2790 | #define PROC_INTERFACE_VERSION 1 | ||
2791 | |||
2792 | +#include <linux/compiler.h> | ||
2793 | #include <linux/kernel.h> | ||
2794 | #include <linux/module.h> | ||
2795 | #include <linux/moduleparam.h> | ||
2796 | @@ -1682,7 +1683,7 @@ static const struct file_operations keys_proc_fops = { | ||
2797 | .write = keys_proc_write, | ||
2798 | }; | ||
2799 | |||
2800 | -static int version_proc_show(struct seq_file *m, void *v) | ||
2801 | +static int __maybe_unused version_proc_show(struct seq_file *m, void *v) | ||
2802 | { | ||
2803 | seq_printf(m, "driver: %s\n", TOSHIBA_ACPI_VERSION); | ||
2804 | seq_printf(m, "proc_interface: %d\n", PROC_INTERFACE_VERSION); | ||
2805 | diff --git a/drivers/reset/reset-imx7.c b/drivers/reset/reset-imx7.c | ||
2806 | index 4db177bc89bc..fdeac1946429 100644 | ||
2807 | --- a/drivers/reset/reset-imx7.c | ||
2808 | +++ b/drivers/reset/reset-imx7.c | ||
2809 | @@ -80,7 +80,7 @@ static int imx7_reset_set(struct reset_controller_dev *rcdev, | ||
2810 | { | ||
2811 | struct imx7_src *imx7src = to_imx7_src(rcdev); | ||
2812 | const struct imx7_src_signal *signal = &imx7_src_signals[id]; | ||
2813 | - unsigned int value = 0; | ||
2814 | + unsigned int value = assert ? signal->bit : 0; | ||
2815 | |||
2816 | switch (id) { | ||
2817 | case IMX7_RESET_PCIEPHY: | ||
2818 | diff --git a/drivers/rtc/rtc-bq4802.c b/drivers/rtc/rtc-bq4802.c | ||
2819 | index bd170cb3361c..5747a54cbd42 100644 | ||
2820 | --- a/drivers/rtc/rtc-bq4802.c | ||
2821 | +++ b/drivers/rtc/rtc-bq4802.c | ||
2822 | @@ -164,6 +164,10 @@ static int bq4802_probe(struct platform_device *pdev) | ||
2823 | } else if (p->r->flags & IORESOURCE_MEM) { | ||
2824 | p->regs = devm_ioremap(&pdev->dev, p->r->start, | ||
2825 | resource_size(p->r)); | ||
2826 | + if (!p->regs){ | ||
2827 | + err = -ENOMEM; | ||
2828 | + goto out; | ||
2829 | + } | ||
2830 | p->read = bq4802_read_mem; | ||
2831 | p->write = bq4802_write_mem; | ||
2832 | } else { | ||
2833 | diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c | ||
2834 | index 939b5b5e97ef..0a6afd4b283d 100644 | ||
2835 | --- a/drivers/s390/net/qeth_core_main.c | ||
2836 | +++ b/drivers/s390/net/qeth_core_main.c | ||
2837 | @@ -3507,13 +3507,14 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index, | ||
2838 | qdio_flags = QDIO_FLAG_SYNC_OUTPUT; | ||
2839 | if (atomic_read(&queue->set_pci_flags_count)) | ||
2840 | qdio_flags |= QDIO_FLAG_PCI_OUT; | ||
2841 | + atomic_add(count, &queue->used_buffers); | ||
2842 | + | ||
2843 | rc = do_QDIO(CARD_DDEV(queue->card), qdio_flags, | ||
2844 | queue->queue_no, index, count); | ||
2845 | if (queue->card->options.performance_stats) | ||
2846 | queue->card->perf_stats.outbound_do_qdio_time += | ||
2847 | qeth_get_micros() - | ||
2848 | queue->card->perf_stats.outbound_do_qdio_start_time; | ||
2849 | - atomic_add(count, &queue->used_buffers); | ||
2850 | if (rc) { | ||
2851 | queue->card->stats.tx_errors += count; | ||
2852 | /* ignore temporary SIGA errors without busy condition */ | ||
2853 | diff --git a/drivers/s390/net/qeth_core_sys.c b/drivers/s390/net/qeth_core_sys.c | ||
2854 | index d1ee9e30c68b..21e91fbb2860 100644 | ||
2855 | --- a/drivers/s390/net/qeth_core_sys.c | ||
2856 | +++ b/drivers/s390/net/qeth_core_sys.c | ||
2857 | @@ -423,6 +423,7 @@ static ssize_t qeth_dev_layer2_store(struct device *dev, | ||
2858 | if (card->discipline) { | ||
2859 | card->discipline->remove(card->gdev); | ||
2860 | qeth_core_free_discipline(card); | ||
2861 | + card->options.layer2 = -1; | ||
2862 | } | ||
2863 | |||
2864 | rc = qeth_core_load_discipline(card, newdis); | ||
2865 | diff --git a/drivers/scsi/libfc/fc_disc.c b/drivers/scsi/libfc/fc_disc.c | ||
2866 | index 8660f923ace0..bb9c1c016643 100644 | ||
2867 | --- a/drivers/scsi/libfc/fc_disc.c | ||
2868 | +++ b/drivers/scsi/libfc/fc_disc.c | ||
2869 | @@ -294,9 +294,11 @@ static void fc_disc_done(struct fc_disc *disc, enum fc_disc_event event) | ||
2870 | * discovery, reverify or log them in. Otherwise, log them out. | ||
2871 | * Skip ports which were never discovered. These are the dNS port | ||
2872 | * and ports which were created by PLOGI. | ||
2873 | + * | ||
2874 | + * We don't need to use the _rcu variant here as the rport list | ||
2875 | + * is protected by the disc mutex which is already held on entry. | ||
2876 | */ | ||
2877 | - rcu_read_lock(); | ||
2878 | - list_for_each_entry_rcu(rdata, &disc->rports, peers) { | ||
2879 | + list_for_each_entry(rdata, &disc->rports, peers) { | ||
2880 | if (!kref_get_unless_zero(&rdata->kref)) | ||
2881 | continue; | ||
2882 | if (rdata->disc_id) { | ||
2883 | @@ -307,7 +309,6 @@ static void fc_disc_done(struct fc_disc *disc, enum fc_disc_event event) | ||
2884 | } | ||
2885 | kref_put(&rdata->kref, fc_rport_destroy); | ||
2886 | } | ||
2887 | - rcu_read_unlock(); | ||
2888 | mutex_unlock(&disc->disc_mutex); | ||
2889 | disc->disc_callback(lport, event); | ||
2890 | mutex_lock(&disc->disc_mutex); | ||
2891 | diff --git a/drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c b/drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c | ||
2892 | index 4be864dbd41c..9eb3b625a1b1 100644 | ||
2893 | --- a/drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c | ||
2894 | +++ b/drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c | ||
2895 | @@ -442,16 +442,16 @@ int bcm2835_audio_open(struct bcm2835_alsa_stream *alsa_stream) | ||
2896 | my_workqueue_init(alsa_stream); | ||
2897 | |||
2898 | ret = bcm2835_audio_open_connection(alsa_stream); | ||
2899 | - if (ret) { | ||
2900 | - ret = -1; | ||
2901 | - goto exit; | ||
2902 | - } | ||
2903 | + if (ret) | ||
2904 | + goto free_wq; | ||
2905 | + | ||
2906 | instance = alsa_stream->instance; | ||
2907 | LOG_DBG(" instance (%p)\n", instance); | ||
2908 | |||
2909 | if (mutex_lock_interruptible(&instance->vchi_mutex)) { | ||
2910 | LOG_DBG("Interrupted whilst waiting for lock on (%d)\n", instance->num_connections); | ||
2911 | - return -EINTR; | ||
2912 | + ret = -EINTR; | ||
2913 | + goto free_wq; | ||
2914 | } | ||
2915 | vchi_service_use(instance->vchi_handle[0]); | ||
2916 | |||
2917 | @@ -474,7 +474,11 @@ int bcm2835_audio_open(struct bcm2835_alsa_stream *alsa_stream) | ||
2918 | unlock: | ||
2919 | vchi_service_release(instance->vchi_handle[0]); | ||
2920 | mutex_unlock(&instance->vchi_mutex); | ||
2921 | -exit: | ||
2922 | + | ||
2923 | +free_wq: | ||
2924 | + if (ret) | ||
2925 | + destroy_workqueue(alsa_stream->my_wq); | ||
2926 | + | ||
2927 | return ret; | ||
2928 | } | ||
2929 | |||
2930 | diff --git a/drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c b/drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c | ||
2931 | index be936b8fe317..377da037f31c 100644 | ||
2932 | --- a/drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c | ||
2933 | +++ b/drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c | ||
2934 | @@ -580,6 +580,7 @@ static int start_streaming(struct vb2_queue *vq, unsigned int count) | ||
2935 | static void stop_streaming(struct vb2_queue *vq) | ||
2936 | { | ||
2937 | int ret; | ||
2938 | + unsigned long timeout; | ||
2939 | struct bm2835_mmal_dev *dev = vb2_get_drv_priv(vq); | ||
2940 | |||
2941 | v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev, "%s: dev:%p\n", | ||
2942 | @@ -605,10 +606,10 @@ static void stop_streaming(struct vb2_queue *vq) | ||
2943 | sizeof(dev->capture.frame_count)); | ||
2944 | |||
2945 | /* wait for last frame to complete */ | ||
2946 | - ret = wait_for_completion_timeout(&dev->capture.frame_cmplt, HZ); | ||
2947 | - if (ret <= 0) | ||
2948 | + timeout = wait_for_completion_timeout(&dev->capture.frame_cmplt, HZ); | ||
2949 | + if (timeout == 0) | ||
2950 | v4l2_err(&dev->v4l2_dev, | ||
2951 | - "error %d waiting for frame completion\n", ret); | ||
2952 | + "timed out waiting for frame completion\n"); | ||
2953 | |||
2954 | v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev, | ||
2955 | "disabling connection\n"); | ||
2956 | diff --git a/drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c b/drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c | ||
2957 | index 4360db6d4392..b3176f42c820 100644 | ||
2958 | --- a/drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c | ||
2959 | +++ b/drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c | ||
2960 | @@ -834,6 +834,7 @@ static int send_synchronous_mmal_msg(struct vchiq_mmal_instance *instance, | ||
2961 | { | ||
2962 | struct mmal_msg_context *msg_context; | ||
2963 | int ret; | ||
2964 | + unsigned long timeout; | ||
2965 | |||
2966 | /* payload size must not cause message to exceed max size */ | ||
2967 | if (payload_len > | ||
2968 | @@ -872,11 +873,11 @@ static int send_synchronous_mmal_msg(struct vchiq_mmal_instance *instance, | ||
2969 | return ret; | ||
2970 | } | ||
2971 | |||
2972 | - ret = wait_for_completion_timeout(&msg_context->u.sync.cmplt, 3 * HZ); | ||
2973 | - if (ret <= 0) { | ||
2974 | - pr_err("error %d waiting for sync completion\n", ret); | ||
2975 | - if (ret == 0) | ||
2976 | - ret = -ETIME; | ||
2977 | + timeout = wait_for_completion_timeout(&msg_context->u.sync.cmplt, | ||
2978 | + 3 * HZ); | ||
2979 | + if (timeout == 0) { | ||
2980 | + pr_err("timed out waiting for sync completion\n"); | ||
2981 | + ret = -ETIME; | ||
2982 | /* todo: what happens if the message arrives after aborting */ | ||
2983 | release_msg_context(msg_context); | ||
2984 | return ret; | ||
2985 | diff --git a/drivers/tty/serial/earlycon.c b/drivers/tty/serial/earlycon.c | ||
2986 | index ac667b47f199..7b0a3a1688e8 100644 | ||
2987 | --- a/drivers/tty/serial/earlycon.c | ||
2988 | +++ b/drivers/tty/serial/earlycon.c | ||
2989 | @@ -254,7 +254,6 @@ int __init of_setup_earlycon(const struct earlycon_id *match, | ||
2990 | return -ENXIO; | ||
2991 | } | ||
2992 | port->mapbase = addr; | ||
2993 | - port->uartclk = BASE_BAUD * 16; | ||
2994 | |||
2995 | val = of_get_flat_dt_prop(node, "reg-offset", NULL); | ||
2996 | if (val) | ||
2997 | @@ -289,6 +288,10 @@ int __init of_setup_earlycon(const struct earlycon_id *match, | ||
2998 | if (val) | ||
2999 | early_console_dev.baud = be32_to_cpu(*val); | ||
3000 | |||
3001 | + val = of_get_flat_dt_prop(node, "clock-frequency", NULL); | ||
3002 | + if (val) | ||
3003 | + port->uartclk = be32_to_cpu(*val); | ||
3004 | + | ||
3005 | if (options) { | ||
3006 | early_console_dev.baud = simple_strtoul(options, NULL, 0); | ||
3007 | strlcpy(early_console_dev.options, options, | ||
3008 | diff --git a/drivers/tty/tty_baudrate.c b/drivers/tty/tty_baudrate.c | ||
3009 | index 5c33fd25676d..ebc797fc1afd 100644 | ||
3010 | --- a/drivers/tty/tty_baudrate.c | ||
3011 | +++ b/drivers/tty/tty_baudrate.c | ||
3012 | @@ -156,18 +156,25 @@ void tty_termios_encode_baud_rate(struct ktermios *termios, | ||
3013 | termios->c_ospeed = obaud; | ||
3014 | |||
3015 | #ifdef BOTHER | ||
3016 | + if ((termios->c_cflag >> IBSHIFT) & CBAUD) | ||
3017 | + ibinput = 1; /* An input speed was specified */ | ||
3018 | + | ||
3019 | /* If the user asked for a precise weird speed give a precise weird | ||
3020 | answer. If they asked for a Bfoo speed they may have problems | ||
3021 | digesting non-exact replies so fuzz a bit */ | ||
3022 | |||
3023 | - if ((termios->c_cflag & CBAUD) == BOTHER) | ||
3024 | + if ((termios->c_cflag & CBAUD) == BOTHER) { | ||
3025 | oclose = 0; | ||
3026 | + if (!ibinput) | ||
3027 | + iclose = 0; | ||
3028 | + } | ||
3029 | if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER) | ||
3030 | iclose = 0; | ||
3031 | - if ((termios->c_cflag >> IBSHIFT) & CBAUD) | ||
3032 | - ibinput = 1; /* An input speed was specified */ | ||
3033 | #endif | ||
3034 | termios->c_cflag &= ~CBAUD; | ||
3035 | +#ifdef IBSHIFT | ||
3036 | + termios->c_cflag &= ~(CBAUD << IBSHIFT); | ||
3037 | +#endif | ||
3038 | |||
3039 | /* | ||
3040 | * Our goal is to find a close match to the standard baud rate | ||
3041 | diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c | ||
3042 | index f2f31fc16f29..feaa0d8f830a 100644 | ||
3043 | --- a/drivers/usb/class/cdc-acm.c | ||
3044 | +++ b/drivers/usb/class/cdc-acm.c | ||
3045 | @@ -792,20 +792,9 @@ static int acm_tty_write(struct tty_struct *tty, | ||
3046 | } | ||
3047 | |||
3048 | if (acm->susp_count) { | ||
3049 | - if (acm->putbuffer) { | ||
3050 | - /* now to preserve order */ | ||
3051 | - usb_anchor_urb(acm->putbuffer->urb, &acm->delayed); | ||
3052 | - acm->putbuffer = NULL; | ||
3053 | - } | ||
3054 | usb_anchor_urb(wb->urb, &acm->delayed); | ||
3055 | spin_unlock_irqrestore(&acm->write_lock, flags); | ||
3056 | return count; | ||
3057 | - } else { | ||
3058 | - if (acm->putbuffer) { | ||
3059 | - /* at this point there is no good way to handle errors */ | ||
3060 | - acm_start_wb(acm, acm->putbuffer); | ||
3061 | - acm->putbuffer = NULL; | ||
3062 | - } | ||
3063 | } | ||
3064 | |||
3065 | stat = acm_start_wb(acm, wb); | ||
3066 | @@ -816,66 +805,6 @@ static int acm_tty_write(struct tty_struct *tty, | ||
3067 | return count; | ||
3068 | } | ||
3069 | |||
3070 | -static void acm_tty_flush_chars(struct tty_struct *tty) | ||
3071 | -{ | ||
3072 | - struct acm *acm = tty->driver_data; | ||
3073 | - struct acm_wb *cur; | ||
3074 | - int err; | ||
3075 | - unsigned long flags; | ||
3076 | - | ||
3077 | - spin_lock_irqsave(&acm->write_lock, flags); | ||
3078 | - | ||
3079 | - cur = acm->putbuffer; | ||
3080 | - if (!cur) /* nothing to do */ | ||
3081 | - goto out; | ||
3082 | - | ||
3083 | - acm->putbuffer = NULL; | ||
3084 | - err = usb_autopm_get_interface_async(acm->control); | ||
3085 | - if (err < 0) { | ||
3086 | - cur->use = 0; | ||
3087 | - acm->putbuffer = cur; | ||
3088 | - goto out; | ||
3089 | - } | ||
3090 | - | ||
3091 | - if (acm->susp_count) | ||
3092 | - usb_anchor_urb(cur->urb, &acm->delayed); | ||
3093 | - else | ||
3094 | - acm_start_wb(acm, cur); | ||
3095 | -out: | ||
3096 | - spin_unlock_irqrestore(&acm->write_lock, flags); | ||
3097 | - return; | ||
3098 | -} | ||
3099 | - | ||
3100 | -static int acm_tty_put_char(struct tty_struct *tty, unsigned char ch) | ||
3101 | -{ | ||
3102 | - struct acm *acm = tty->driver_data; | ||
3103 | - struct acm_wb *cur; | ||
3104 | - int wbn; | ||
3105 | - unsigned long flags; | ||
3106 | - | ||
3107 | -overflow: | ||
3108 | - cur = acm->putbuffer; | ||
3109 | - if (!cur) { | ||
3110 | - spin_lock_irqsave(&acm->write_lock, flags); | ||
3111 | - wbn = acm_wb_alloc(acm); | ||
3112 | - if (wbn >= 0) { | ||
3113 | - cur = &acm->wb[wbn]; | ||
3114 | - acm->putbuffer = cur; | ||
3115 | - } | ||
3116 | - spin_unlock_irqrestore(&acm->write_lock, flags); | ||
3117 | - if (!cur) | ||
3118 | - return 0; | ||
3119 | - } | ||
3120 | - | ||
3121 | - if (cur->len == acm->writesize) { | ||
3122 | - acm_tty_flush_chars(tty); | ||
3123 | - goto overflow; | ||
3124 | - } | ||
3125 | - | ||
3126 | - cur->buf[cur->len++] = ch; | ||
3127 | - return 1; | ||
3128 | -} | ||
3129 | - | ||
3130 | static int acm_tty_write_room(struct tty_struct *tty) | ||
3131 | { | ||
3132 | struct acm *acm = tty->driver_data; | ||
3133 | @@ -2000,8 +1929,6 @@ static const struct tty_operations acm_ops = { | ||
3134 | .cleanup = acm_tty_cleanup, | ||
3135 | .hangup = acm_tty_hangup, | ||
3136 | .write = acm_tty_write, | ||
3137 | - .put_char = acm_tty_put_char, | ||
3138 | - .flush_chars = acm_tty_flush_chars, | ||
3139 | .write_room = acm_tty_write_room, | ||
3140 | .ioctl = acm_tty_ioctl, | ||
3141 | .throttle = acm_tty_throttle, | ||
3142 | diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h | ||
3143 | index eacc116e83da..ca06b20d7af9 100644 | ||
3144 | --- a/drivers/usb/class/cdc-acm.h | ||
3145 | +++ b/drivers/usb/class/cdc-acm.h | ||
3146 | @@ -96,7 +96,6 @@ struct acm { | ||
3147 | unsigned long read_urbs_free; | ||
3148 | struct urb *read_urbs[ACM_NR]; | ||
3149 | struct acm_rb read_buffers[ACM_NR]; | ||
3150 | - struct acm_wb *putbuffer; /* for acm_tty_put_char() */ | ||
3151 | int rx_buflimit; | ||
3152 | spinlock_t read_lock; | ||
3153 | u8 *notification_buffer; /* to reassemble fragmented notifications */ | ||
3154 | diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c | ||
3155 | index 3e865dbf878c..a9509ecccedb 100644 | ||
3156 | --- a/drivers/usb/class/cdc-wdm.c | ||
3157 | +++ b/drivers/usb/class/cdc-wdm.c | ||
3158 | @@ -457,7 +457,7 @@ static int service_outstanding_interrupt(struct wdm_device *desc) | ||
3159 | |||
3160 | set_bit(WDM_RESPONDING, &desc->flags); | ||
3161 | spin_unlock_irq(&desc->iuspin); | ||
3162 | - rv = usb_submit_urb(desc->response, GFP_KERNEL); | ||
3163 | + rv = usb_submit_urb(desc->response, GFP_ATOMIC); | ||
3164 | spin_lock_irq(&desc->iuspin); | ||
3165 | if (rv) { | ||
3166 | dev_err(&desc->intf->dev, | ||
3167 | diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c | ||
3168 | index ea829ad798c0..5340d433cdf0 100644 | ||
3169 | --- a/drivers/usb/core/hcd-pci.c | ||
3170 | +++ b/drivers/usb/core/hcd-pci.c | ||
3171 | @@ -528,8 +528,6 @@ static int resume_common(struct device *dev, int event) | ||
3172 | event == PM_EVENT_RESTORE); | ||
3173 | if (retval) { | ||
3174 | dev_err(dev, "PCI post-resume error %d!\n", retval); | ||
3175 | - if (hcd->shared_hcd) | ||
3176 | - usb_hc_died(hcd->shared_hcd); | ||
3177 | usb_hc_died(hcd); | ||
3178 | } | ||
3179 | } | ||
3180 | diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c | ||
3181 | index dd29e6ec1c43..833ddd228e3a 100644 | ||
3182 | --- a/drivers/usb/core/message.c | ||
3183 | +++ b/drivers/usb/core/message.c | ||
3184 | @@ -1280,6 +1280,11 @@ void usb_enable_interface(struct usb_device *dev, | ||
3185 | * is submitted that needs that bandwidth. Some other operating systems | ||
3186 | * allocate bandwidth early, when a configuration is chosen. | ||
3187 | * | ||
3188 | + * xHCI reserves bandwidth and configures the alternate setting in | ||
3189 | + * usb_hcd_alloc_bandwidth(). If it fails the original interface altsetting | ||
3190 | + * may be disabled. Drivers cannot rely on any particular alternate | ||
3191 | + * setting being in effect after a failure. | ||
3192 | + * | ||
3193 | * This call is synchronous, and may not be used in an interrupt context. | ||
3194 | * Also, drivers must not change altsettings while urbs are scheduled for | ||
3195 | * endpoints in that interface; all such urbs must first be completed | ||
3196 | @@ -1315,6 +1320,12 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate) | ||
3197 | alternate); | ||
3198 | return -EINVAL; | ||
3199 | } | ||
3200 | + /* | ||
3201 | + * usb3 hosts configure the interface in usb_hcd_alloc_bandwidth, | ||
3202 | + * including freeing dropped endpoint ring buffers. | ||
3203 | + * Make sure the interface endpoints are flushed before that | ||
3204 | + */ | ||
3205 | + usb_disable_interface(dev, iface, false); | ||
3206 | |||
3207 | /* Make sure we have enough bandwidth for this alternate interface. | ||
3208 | * Remove the current alt setting and add the new alt setting. | ||
3209 | diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c | ||
3210 | index 99f67764765f..37a5e07b3488 100644 | ||
3211 | --- a/drivers/usb/core/quirks.c | ||
3212 | +++ b/drivers/usb/core/quirks.c | ||
3213 | @@ -37,6 +37,10 @@ static const struct usb_device_id usb_quirk_list[] = { | ||
3214 | /* CBM - Flash disk */ | ||
3215 | { USB_DEVICE(0x0204, 0x6025), .driver_info = USB_QUIRK_RESET_RESUME }, | ||
3216 | |||
3217 | + /* WORLDE Controller KS49 or Prodipe MIDI 49C USB controller */ | ||
3218 | + { USB_DEVICE(0x0218, 0x0201), .driver_info = | ||
3219 | + USB_QUIRK_CONFIG_INTF_STRINGS }, | ||
3220 | + | ||
3221 | /* WORLDE easy key (easykey.25) MIDI controller */ | ||
3222 | { USB_DEVICE(0x0218, 0x0401), .driver_info = | ||
3223 | USB_QUIRK_CONFIG_INTF_STRINGS }, | ||
3224 | @@ -259,6 +263,9 @@ static const struct usb_device_id usb_quirk_list[] = { | ||
3225 | { USB_DEVICE(0x2040, 0x7200), .driver_info = | ||
3226 | USB_QUIRK_CONFIG_INTF_STRINGS }, | ||
3227 | |||
3228 | + /* DJI CineSSD */ | ||
3229 | + { USB_DEVICE(0x2ca3, 0x0031), .driver_info = USB_QUIRK_NO_LPM }, | ||
3230 | + | ||
3231 | /* INTEL VALUE SSD */ | ||
3232 | { USB_DEVICE(0x8086, 0xf1a5), .driver_info = USB_QUIRK_RESET_RESUME }, | ||
3233 | |||
3234 | diff --git a/drivers/usb/dwc3/gadget.h b/drivers/usb/dwc3/gadget.h | ||
3235 | index 4a3227543255..5cc9fd730656 100644 | ||
3236 | --- a/drivers/usb/dwc3/gadget.h | ||
3237 | +++ b/drivers/usb/dwc3/gadget.h | ||
3238 | @@ -33,7 +33,7 @@ struct dwc3; | ||
3239 | #define DWC3_DEPCFG_XFER_IN_PROGRESS_EN BIT(9) | ||
3240 | #define DWC3_DEPCFG_XFER_NOT_READY_EN BIT(10) | ||
3241 | #define DWC3_DEPCFG_FIFO_ERROR_EN BIT(11) | ||
3242 | -#define DWC3_DEPCFG_STREAM_EVENT_EN BIT(12) | ||
3243 | +#define DWC3_DEPCFG_STREAM_EVENT_EN BIT(13) | ||
3244 | #define DWC3_DEPCFG_BINTERVAL_M1(n) (((n) & 0xff) << 16) | ||
3245 | #define DWC3_DEPCFG_STREAM_CAPABLE BIT(24) | ||
3246 | #define DWC3_DEPCFG_EP_NUMBER(n) (((n) & 0x1f) << 25) | ||
3247 | diff --git a/drivers/usb/gadget/udc/net2280.c b/drivers/usb/gadget/udc/net2280.c | ||
3248 | index f608c1f85e61..9cbb061582a7 100644 | ||
3249 | --- a/drivers/usb/gadget/udc/net2280.c | ||
3250 | +++ b/drivers/usb/gadget/udc/net2280.c | ||
3251 | @@ -1549,11 +1549,14 @@ static int net2280_pullup(struct usb_gadget *_gadget, int is_on) | ||
3252 | writel(tmp | BIT(USB_DETECT_ENABLE), &dev->usb->usbctl); | ||
3253 | } else { | ||
3254 | writel(tmp & ~BIT(USB_DETECT_ENABLE), &dev->usb->usbctl); | ||
3255 | - stop_activity(dev, dev->driver); | ||
3256 | + stop_activity(dev, NULL); | ||
3257 | } | ||
3258 | |||
3259 | spin_unlock_irqrestore(&dev->lock, flags); | ||
3260 | |||
3261 | + if (!is_on && dev->driver) | ||
3262 | + dev->driver->disconnect(&dev->gadget); | ||
3263 | + | ||
3264 | return 0; | ||
3265 | } | ||
3266 | |||
3267 | @@ -2470,8 +2473,11 @@ static void stop_activity(struct net2280 *dev, struct usb_gadget_driver *driver) | ||
3268 | nuke(&dev->ep[i]); | ||
3269 | |||
3270 | /* report disconnect; the driver is already quiesced */ | ||
3271 | - if (driver) | ||
3272 | + if (driver) { | ||
3273 | + spin_unlock(&dev->lock); | ||
3274 | driver->disconnect(&dev->gadget); | ||
3275 | + spin_lock(&dev->lock); | ||
3276 | + } | ||
3277 | |||
3278 | usb_reinit(dev); | ||
3279 | } | ||
3280 | @@ -3345,6 +3351,8 @@ next_endpoints: | ||
3281 | BIT(PCI_RETRY_ABORT_INTERRUPT)) | ||
3282 | |||
3283 | static void handle_stat1_irqs(struct net2280 *dev, u32 stat) | ||
3284 | +__releases(dev->lock) | ||
3285 | +__acquires(dev->lock) | ||
3286 | { | ||
3287 | struct net2280_ep *ep; | ||
3288 | u32 tmp, num, mask, scratch; | ||
3289 | @@ -3385,12 +3393,14 @@ static void handle_stat1_irqs(struct net2280 *dev, u32 stat) | ||
3290 | if (disconnect || reset) { | ||
3291 | stop_activity(dev, dev->driver); | ||
3292 | ep0_start(dev); | ||
3293 | + spin_unlock(&dev->lock); | ||
3294 | if (reset) | ||
3295 | usb_gadget_udc_reset | ||
3296 | (&dev->gadget, dev->driver); | ||
3297 | else | ||
3298 | (dev->driver->disconnect) | ||
3299 | (&dev->gadget); | ||
3300 | + spin_lock(&dev->lock); | ||
3301 | return; | ||
3302 | } | ||
3303 | } | ||
3304 | @@ -3409,6 +3419,7 @@ static void handle_stat1_irqs(struct net2280 *dev, u32 stat) | ||
3305 | tmp = BIT(SUSPEND_REQUEST_CHANGE_INTERRUPT); | ||
3306 | if (stat & tmp) { | ||
3307 | writel(tmp, &dev->regs->irqstat1); | ||
3308 | + spin_unlock(&dev->lock); | ||
3309 | if (stat & BIT(SUSPEND_REQUEST_INTERRUPT)) { | ||
3310 | if (dev->driver->suspend) | ||
3311 | dev->driver->suspend(&dev->gadget); | ||
3312 | @@ -3419,6 +3430,7 @@ static void handle_stat1_irqs(struct net2280 *dev, u32 stat) | ||
3313 | dev->driver->resume(&dev->gadget); | ||
3314 | /* at high speed, note erratum 0133 */ | ||
3315 | } | ||
3316 | + spin_lock(&dev->lock); | ||
3317 | stat &= ~tmp; | ||
3318 | } | ||
3319 | |||
3320 | diff --git a/drivers/usb/gadget/udc/renesas_usb3.c b/drivers/usb/gadget/udc/renesas_usb3.c | ||
3321 | index c12a1a6554ba..36a706f475d2 100644 | ||
3322 | --- a/drivers/usb/gadget/udc/renesas_usb3.c | ||
3323 | +++ b/drivers/usb/gadget/udc/renesas_usb3.c | ||
3324 | @@ -788,12 +788,15 @@ static void usb3_irq_epc_int_1_speed(struct renesas_usb3 *usb3) | ||
3325 | switch (speed) { | ||
3326 | case USB_STA_SPEED_SS: | ||
3327 | usb3->gadget.speed = USB_SPEED_SUPER; | ||
3328 | + usb3->gadget.ep0->maxpacket = USB3_EP0_SS_MAX_PACKET_SIZE; | ||
3329 | break; | ||
3330 | case USB_STA_SPEED_HS: | ||
3331 | usb3->gadget.speed = USB_SPEED_HIGH; | ||
3332 | + usb3->gadget.ep0->maxpacket = USB3_EP0_HSFS_MAX_PACKET_SIZE; | ||
3333 | break; | ||
3334 | case USB_STA_SPEED_FS: | ||
3335 | usb3->gadget.speed = USB_SPEED_FULL; | ||
3336 | + usb3->gadget.ep0->maxpacket = USB3_EP0_HSFS_MAX_PACKET_SIZE; | ||
3337 | break; | ||
3338 | default: | ||
3339 | usb3->gadget.speed = USB_SPEED_UNKNOWN; | ||
3340 | @@ -2458,7 +2461,7 @@ static int renesas_usb3_init_ep(struct renesas_usb3 *usb3, struct device *dev, | ||
3341 | /* for control pipe */ | ||
3342 | usb3->gadget.ep0 = &usb3_ep->ep; | ||
3343 | usb_ep_set_maxpacket_limit(&usb3_ep->ep, | ||
3344 | - USB3_EP0_HSFS_MAX_PACKET_SIZE); | ||
3345 | + USB3_EP0_SS_MAX_PACKET_SIZE); | ||
3346 | usb3_ep->ep.caps.type_control = true; | ||
3347 | usb3_ep->ep.caps.dir_in = true; | ||
3348 | usb3_ep->ep.caps.dir_out = true; | ||
3349 | diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c | ||
3350 | index c38855aed62c..65c0086e25ae 100644 | ||
3351 | --- a/drivers/usb/host/u132-hcd.c | ||
3352 | +++ b/drivers/usb/host/u132-hcd.c | ||
3353 | @@ -2559,7 +2559,7 @@ static int u132_get_frame(struct usb_hcd *hcd) | ||
3354 | } else { | ||
3355 | int frame = 0; | ||
3356 | dev_err(&u132->platform_dev->dev, "TODO: u132_get_frame\n"); | ||
3357 | - msleep(100); | ||
3358 | + mdelay(100); | ||
3359 | return frame; | ||
3360 | } | ||
3361 | } | ||
3362 | diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c | ||
3363 | index 6b11fd9d8efe..64ddba3f79a9 100644 | ||
3364 | --- a/drivers/usb/host/xhci.c | ||
3365 | +++ b/drivers/usb/host/xhci.c | ||
3366 | @@ -47,6 +47,21 @@ static unsigned int quirks; | ||
3367 | module_param(quirks, uint, S_IRUGO); | ||
3368 | MODULE_PARM_DESC(quirks, "Bit flags for quirks to be enabled as default"); | ||
3369 | |||
3370 | +static bool td_on_ring(struct xhci_td *td, struct xhci_ring *ring) | ||
3371 | +{ | ||
3372 | + struct xhci_segment *seg = ring->first_seg; | ||
3373 | + | ||
3374 | + if (!td || !td->start_seg) | ||
3375 | + return false; | ||
3376 | + do { | ||
3377 | + if (seg == td->start_seg) | ||
3378 | + return true; | ||
3379 | + seg = seg->next; | ||
3380 | + } while (seg && seg != ring->first_seg); | ||
3381 | + | ||
3382 | + return false; | ||
3383 | +} | ||
3384 | + | ||
3385 | /* TODO: copied from ehci-hcd.c - can this be refactored? */ | ||
3386 | /* | ||
3387 | * xhci_handshake - spin reading hc until handshake completes or fails | ||
3388 | @@ -1511,6 +1526,21 @@ static int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) | ||
3389 | goto done; | ||
3390 | } | ||
3391 | |||
3392 | + /* | ||
3393 | + * check ring is not re-allocated since URB was enqueued. If it is, then | ||
3394 | + * make sure none of the ring related pointers in this URB private data | ||
3395 | + * are touched, such as td_list, otherwise we overwrite freed data | ||
3396 | + */ | ||
3397 | + if (!td_on_ring(&urb_priv->td[0], ep_ring)) { | ||
3398 | + xhci_err(xhci, "Canceled URB td not found on endpoint ring"); | ||
3399 | + for (i = urb_priv->num_tds_done; i < urb_priv->num_tds; i++) { | ||
3400 | + td = &urb_priv->td[i]; | ||
3401 | + if (!list_empty(&td->cancelled_td_list)) | ||
3402 | + list_del_init(&td->cancelled_td_list); | ||
3403 | + } | ||
3404 | + goto err_giveback; | ||
3405 | + } | ||
3406 | + | ||
3407 | if (xhci->xhc_state & XHCI_STATE_HALTED) { | ||
3408 | xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb, | ||
3409 | "HC halted, freeing TD manually."); | ||
3410 | diff --git a/drivers/usb/misc/uss720.c b/drivers/usb/misc/uss720.c | ||
3411 | index 8a13b2fcf3e1..03152f98108c 100644 | ||
3412 | --- a/drivers/usb/misc/uss720.c | ||
3413 | +++ b/drivers/usb/misc/uss720.c | ||
3414 | @@ -382,7 +382,7 @@ static unsigned char parport_uss720_frob_control(struct parport *pp, unsigned ch | ||
3415 | mask &= 0x0f; | ||
3416 | val &= 0x0f; | ||
3417 | d = (priv->reg[1] & (~mask)) ^ val; | ||
3418 | - if (set_1284_register(pp, 2, d, GFP_KERNEL)) | ||
3419 | + if (set_1284_register(pp, 2, d, GFP_ATOMIC)) | ||
3420 | return 0; | ||
3421 | priv->reg[1] = d; | ||
3422 | return d & 0xf; | ||
3423 | @@ -392,7 +392,7 @@ static unsigned char parport_uss720_read_status(struct parport *pp) | ||
3424 | { | ||
3425 | unsigned char ret; | ||
3426 | |||
3427 | - if (get_1284_register(pp, 1, &ret, GFP_KERNEL)) | ||
3428 | + if (get_1284_register(pp, 1, &ret, GFP_ATOMIC)) | ||
3429 | return 0; | ||
3430 | return ret & 0xf8; | ||
3431 | } | ||
3432 | diff --git a/drivers/usb/misc/yurex.c b/drivers/usb/misc/yurex.c | ||
3433 | index 47763311a42e..0673f286afbd 100644 | ||
3434 | --- a/drivers/usb/misc/yurex.c | ||
3435 | +++ b/drivers/usb/misc/yurex.c | ||
3436 | @@ -425,13 +425,13 @@ static ssize_t yurex_write(struct file *file, const char __user *user_buffer, | ||
3437 | { | ||
3438 | struct usb_yurex *dev; | ||
3439 | int i, set = 0, retval = 0; | ||
3440 | - char buffer[16]; | ||
3441 | + char buffer[16 + 1]; | ||
3442 | char *data = buffer; | ||
3443 | unsigned long long c, c2 = 0; | ||
3444 | signed long timeout = 0; | ||
3445 | DEFINE_WAIT(wait); | ||
3446 | |||
3447 | - count = min(sizeof(buffer), count); | ||
3448 | + count = min(sizeof(buffer) - 1, count); | ||
3449 | dev = file->private_data; | ||
3450 | |||
3451 | /* verify that we actually have some data to write */ | ||
3452 | @@ -450,6 +450,7 @@ static ssize_t yurex_write(struct file *file, const char __user *user_buffer, | ||
3453 | retval = -EFAULT; | ||
3454 | goto error; | ||
3455 | } | ||
3456 | + buffer[count] = 0; | ||
3457 | memset(dev->cntl_buffer, CMD_PADDING, YUREX_BUF_SIZE); | ||
3458 | |||
3459 | switch (buffer[0]) { | ||
3460 | diff --git a/drivers/usb/serial/io_ti.h b/drivers/usb/serial/io_ti.h | ||
3461 | index 1bd67b24f916..bc9ff5ebd67c 100644 | ||
3462 | --- a/drivers/usb/serial/io_ti.h | ||
3463 | +++ b/drivers/usb/serial/io_ti.h | ||
3464 | @@ -178,7 +178,7 @@ struct ump_interrupt { | ||
3465 | } __attribute__((packed)); | ||
3466 | |||
3467 | |||
3468 | -#define TIUMP_GET_PORT_FROM_CODE(c) (((c) >> 4) - 3) | ||
3469 | +#define TIUMP_GET_PORT_FROM_CODE(c) (((c) >> 6) & 0x01) | ||
3470 | #define TIUMP_GET_FUNC_FROM_CODE(c) ((c) & 0x0f) | ||
3471 | #define TIUMP_INTERRUPT_CODE_LSR 0x03 | ||
3472 | #define TIUMP_INTERRUPT_CODE_MSR 0x04 | ||
3473 | diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c | ||
3474 | index 8fc3854e5e69..57e9f6617084 100644 | ||
3475 | --- a/drivers/usb/serial/ti_usb_3410_5052.c | ||
3476 | +++ b/drivers/usb/serial/ti_usb_3410_5052.c | ||
3477 | @@ -1123,7 +1123,7 @@ static void ti_break(struct tty_struct *tty, int break_state) | ||
3478 | |||
3479 | static int ti_get_port_from_code(unsigned char code) | ||
3480 | { | ||
3481 | - return (code >> 4) - 3; | ||
3482 | + return (code >> 6) & 0x01; | ||
3483 | } | ||
3484 | |||
3485 | static int ti_get_func_from_code(unsigned char code) | ||
3486 | diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c | ||
3487 | index 8cd2926fb1fe..344ec8631481 100644 | ||
3488 | --- a/drivers/usb/storage/scsiglue.c | ||
3489 | +++ b/drivers/usb/storage/scsiglue.c | ||
3490 | @@ -392,6 +392,15 @@ static int queuecommand_lck(struct scsi_cmnd *srb, | ||
3491 | return 0; | ||
3492 | } | ||
3493 | |||
3494 | + if ((us->fflags & US_FL_NO_ATA_1X) && | ||
3495 | + (srb->cmnd[0] == ATA_12 || srb->cmnd[0] == ATA_16)) { | ||
3496 | + memcpy(srb->sense_buffer, usb_stor_sense_invalidCDB, | ||
3497 | + sizeof(usb_stor_sense_invalidCDB)); | ||
3498 | + srb->result = SAM_STAT_CHECK_CONDITION; | ||
3499 | + done(srb); | ||
3500 | + return 0; | ||
3501 | + } | ||
3502 | + | ||
3503 | /* enqueue the command and wake up the control thread */ | ||
3504 | srb->scsi_done = done; | ||
3505 | us->srb = srb; | ||
3506 | diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c | ||
3507 | index 33a6d624c843..24de9c00d8e2 100644 | ||
3508 | --- a/drivers/usb/storage/uas.c | ||
3509 | +++ b/drivers/usb/storage/uas.c | ||
3510 | @@ -842,6 +842,27 @@ static int uas_slave_configure(struct scsi_device *sdev) | ||
3511 | sdev->skip_ms_page_8 = 1; | ||
3512 | sdev->wce_default_on = 1; | ||
3513 | } | ||
3514 | + | ||
3515 | + /* | ||
3516 | + * Some disks return the total number of blocks in response | ||
3517 | + * to READ CAPACITY rather than the highest block number. | ||
3518 | + * If this device makes that mistake, tell the sd driver. | ||
3519 | + */ | ||
3520 | + if (devinfo->flags & US_FL_FIX_CAPACITY) | ||
3521 | + sdev->fix_capacity = 1; | ||
3522 | + | ||
3523 | + /* | ||
3524 | + * Some devices don't like MODE SENSE with page=0x3f, | ||
3525 | + * which is the command used for checking if a device | ||
3526 | + * is write-protected. Now that we tell the sd driver | ||
3527 | + * to do a 192-byte transfer with this command the | ||
3528 | + * majority of devices work fine, but a few still can't | ||
3529 | + * handle it. The sd driver will simply assume those | ||
3530 | + * devices are write-enabled. | ||
3531 | + */ | ||
3532 | + if (devinfo->flags & US_FL_NO_WP_DETECT) | ||
3533 | + sdev->skip_ms_page_3f = 1; | ||
3534 | + | ||
3535 | scsi_change_queue_depth(sdev, devinfo->qdepth - 2); | ||
3536 | return 0; | ||
3537 | } | ||
3538 | diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h | ||
3539 | index d100290628bd..5e9b35a91431 100644 | ||
3540 | --- a/drivers/usb/storage/unusual_devs.h | ||
3541 | +++ b/drivers/usb/storage/unusual_devs.h | ||
3542 | @@ -2307,6 +2307,13 @@ UNUSUAL_DEV( 0x2735, 0x100b, 0x0000, 0x9999, | ||
3543 | USB_SC_DEVICE, USB_PR_DEVICE, NULL, | ||
3544 | US_FL_GO_SLOW ), | ||
3545 | |||
3546 | +/* Reported-by: Tim Anderson <tsa@biglakesoftware.com> */ | ||
3547 | +UNUSUAL_DEV( 0x2ca3, 0x0031, 0x0000, 0x9999, | ||
3548 | + "DJI", | ||
3549 | + "CineSSD", | ||
3550 | + USB_SC_DEVICE, USB_PR_DEVICE, NULL, | ||
3551 | + US_FL_NO_ATA_1X), | ||
3552 | + | ||
3553 | /* | ||
3554 | * Reported by Frederic Marchal <frederic.marchal@wowcompany.com> | ||
3555 | * Mio Moov 330 | ||
3556 | diff --git a/drivers/video/fbdev/core/modedb.c b/drivers/video/fbdev/core/modedb.c | ||
3557 | index 2510fa728d77..de119f11b78f 100644 | ||
3558 | --- a/drivers/video/fbdev/core/modedb.c | ||
3559 | +++ b/drivers/video/fbdev/core/modedb.c | ||
3560 | @@ -644,7 +644,7 @@ static int fb_try_mode(struct fb_var_screeninfo *var, struct fb_info *info, | ||
3561 | * | ||
3562 | * Valid mode specifiers for @mode_option: | ||
3563 | * | ||
3564 | - * <xres>x<yres>[M][R][-<bpp>][@<refresh>][i][m] or | ||
3565 | + * <xres>x<yres>[M][R][-<bpp>][@<refresh>][i][p][m] or | ||
3566 | * <name>[-<bpp>][@<refresh>] | ||
3567 | * | ||
3568 | * with <xres>, <yres>, <bpp> and <refresh> decimal numbers and | ||
3569 | @@ -653,10 +653,10 @@ static int fb_try_mode(struct fb_var_screeninfo *var, struct fb_info *info, | ||
3570 | * If 'M' is present after yres (and before refresh/bpp if present), | ||
3571 | * the function will compute the timings using VESA(tm) Coordinated | ||
3572 | * Video Timings (CVT). If 'R' is present after 'M', will compute with | ||
3573 | - * reduced blanking (for flatpanels). If 'i' is present, compute | ||
3574 | - * interlaced mode. If 'm' is present, add margins equal to 1.8% | ||
3575 | - * of xres rounded down to 8 pixels, and 1.8% of yres. The char | ||
3576 | - * 'i' and 'm' must be after 'M' and 'R'. Example: | ||
3577 | + * reduced blanking (for flatpanels). If 'i' or 'p' are present, compute | ||
3578 | + * interlaced or progressive mode. If 'm' is present, add margins equal | ||
3579 | + * to 1.8% of xres rounded down to 8 pixels, and 1.8% of yres. The chars | ||
3580 | + * 'i', 'p' and 'm' must be after 'M' and 'R'. Example: | ||
3581 | * | ||
3582 | * 1024x768MR-8@60m - Reduced blank with margins at 60Hz. | ||
3583 | * | ||
3584 | @@ -697,7 +697,8 @@ int fb_find_mode(struct fb_var_screeninfo *var, | ||
3585 | unsigned int namelen = strlen(name); | ||
3586 | int res_specified = 0, bpp_specified = 0, refresh_specified = 0; | ||
3587 | unsigned int xres = 0, yres = 0, bpp = default_bpp, refresh = 0; | ||
3588 | - int yres_specified = 0, cvt = 0, rb = 0, interlace = 0; | ||
3589 | + int yres_specified = 0, cvt = 0, rb = 0; | ||
3590 | + int interlace_specified = 0, interlace = 0; | ||
3591 | int margins = 0; | ||
3592 | u32 best, diff, tdiff; | ||
3593 | |||
3594 | @@ -748,9 +749,17 @@ int fb_find_mode(struct fb_var_screeninfo *var, | ||
3595 | if (!cvt) | ||
3596 | margins = 1; | ||
3597 | break; | ||
3598 | + case 'p': | ||
3599 | + if (!cvt) { | ||
3600 | + interlace = 0; | ||
3601 | + interlace_specified = 1; | ||
3602 | + } | ||
3603 | + break; | ||
3604 | case 'i': | ||
3605 | - if (!cvt) | ||
3606 | + if (!cvt) { | ||
3607 | interlace = 1; | ||
3608 | + interlace_specified = 1; | ||
3609 | + } | ||
3610 | break; | ||
3611 | default: | ||
3612 | goto done; | ||
3613 | @@ -819,11 +828,21 @@ done: | ||
3614 | if ((name_matches(db[i], name, namelen) || | ||
3615 | (res_specified && res_matches(db[i], xres, yres))) && | ||
3616 | !fb_try_mode(var, info, &db[i], bpp)) { | ||
3617 | - if (refresh_specified && db[i].refresh == refresh) | ||
3618 | - return 1; | ||
3619 | + const int db_interlace = (db[i].vmode & | ||
3620 | + FB_VMODE_INTERLACED ? 1 : 0); | ||
3621 | + int score = abs(db[i].refresh - refresh); | ||
3622 | + | ||
3623 | + if (interlace_specified) | ||
3624 | + score += abs(db_interlace - interlace); | ||
3625 | + | ||
3626 | + if (!interlace_specified || | ||
3627 | + db_interlace == interlace) | ||
3628 | + if (refresh_specified && | ||
3629 | + db[i].refresh == refresh) | ||
3630 | + return 1; | ||
3631 | |||
3632 | - if (abs(db[i].refresh - refresh) < diff) { | ||
3633 | - diff = abs(db[i].refresh - refresh); | ||
3634 | + if (score < diff) { | ||
3635 | + diff = score; | ||
3636 | best = i; | ||
3637 | } | ||
3638 | } | ||
3639 | diff --git a/drivers/video/fbdev/goldfishfb.c b/drivers/video/fbdev/goldfishfb.c | ||
3640 | index 7f6c9e6cfc6c..14a93cb21310 100644 | ||
3641 | --- a/drivers/video/fbdev/goldfishfb.c | ||
3642 | +++ b/drivers/video/fbdev/goldfishfb.c | ||
3643 | @@ -301,6 +301,7 @@ static int goldfish_fb_remove(struct platform_device *pdev) | ||
3644 | dma_free_coherent(&pdev->dev, framesize, (void *)fb->fb.screen_base, | ||
3645 | fb->fb.fix.smem_start); | ||
3646 | iounmap(fb->reg_base); | ||
3647 | + kfree(fb); | ||
3648 | return 0; | ||
3649 | } | ||
3650 | |||
3651 | diff --git a/drivers/video/fbdev/omap/omapfb_main.c b/drivers/video/fbdev/omap/omapfb_main.c | ||
3652 | index 3479a47a3082..0eee8a29d28d 100644 | ||
3653 | --- a/drivers/video/fbdev/omap/omapfb_main.c | ||
3654 | +++ b/drivers/video/fbdev/omap/omapfb_main.c | ||
3655 | @@ -958,7 +958,7 @@ int omapfb_register_client(struct omapfb_notifier_block *omapfb_nb, | ||
3656 | { | ||
3657 | int r; | ||
3658 | |||
3659 | - if ((unsigned)omapfb_nb->plane_idx > OMAPFB_PLANE_NUM) | ||
3660 | + if ((unsigned)omapfb_nb->plane_idx >= OMAPFB_PLANE_NUM) | ||
3661 | return -EINVAL; | ||
3662 | |||
3663 | if (!notifier_inited) { | ||
3664 | diff --git a/drivers/video/fbdev/pxafb.c b/drivers/video/fbdev/pxafb.c | ||
3665 | index c3d49e13643c..29f00eccdd01 100644 | ||
3666 | --- a/drivers/video/fbdev/pxafb.c | ||
3667 | +++ b/drivers/video/fbdev/pxafb.c | ||
3668 | @@ -2130,8 +2130,8 @@ static int of_get_pxafb_display(struct device *dev, struct device_node *disp, | ||
3669 | return -EINVAL; | ||
3670 | |||
3671 | ret = -ENOMEM; | ||
3672 | - info->modes = kmalloc_array(timings->num_timings, | ||
3673 | - sizeof(info->modes[0]), GFP_KERNEL); | ||
3674 | + info->modes = kcalloc(timings->num_timings, sizeof(info->modes[0]), | ||
3675 | + GFP_KERNEL); | ||
3676 | if (!info->modes) | ||
3677 | goto out; | ||
3678 | info->num_modes = timings->num_timings; | ||
3679 | diff --git a/drivers/video/fbdev/via/viafbdev.c b/drivers/video/fbdev/via/viafbdev.c | ||
3680 | index badee04ef496..71b5dca95bdb 100644 | ||
3681 | --- a/drivers/video/fbdev/via/viafbdev.c | ||
3682 | +++ b/drivers/video/fbdev/via/viafbdev.c | ||
3683 | @@ -19,6 +19,7 @@ | ||
3684 | * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
3685 | */ | ||
3686 | |||
3687 | +#include <linux/compiler.h> | ||
3688 | #include <linux/module.h> | ||
3689 | #include <linux/seq_file.h> | ||
3690 | #include <linux/slab.h> | ||
3691 | @@ -1468,7 +1469,7 @@ static const struct file_operations viafb_vt1636_proc_fops = { | ||
3692 | |||
3693 | #endif /* CONFIG_FB_VIA_DIRECT_PROCFS */ | ||
3694 | |||
3695 | -static int viafb_sup_odev_proc_show(struct seq_file *m, void *v) | ||
3696 | +static int __maybe_unused viafb_sup_odev_proc_show(struct seq_file *m, void *v) | ||
3697 | { | ||
3698 | via_odev_to_seq(m, supported_odev_map[ | ||
3699 | viaparinfo->shared->chip_info.gfx_chip_name]); | ||
3700 | diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c | ||
3701 | index c0e3f91e28e9..469666df91da 100644 | ||
3702 | --- a/fs/binfmt_elf.c | ||
3703 | +++ b/fs/binfmt_elf.c | ||
3704 | @@ -1725,7 +1725,7 @@ static int fill_thread_core_info(struct elf_thread_core_info *t, | ||
3705 | const struct user_regset *regset = &view->regsets[i]; | ||
3706 | do_thread_regset_writeback(t->task, regset); | ||
3707 | if (regset->core_note_type && regset->get && | ||
3708 | - (!regset->active || regset->active(t->task, regset))) { | ||
3709 | + (!regset->active || regset->active(t->task, regset) > 0)) { | ||
3710 | int ret; | ||
3711 | size_t size = regset->n * regset->size; | ||
3712 | void *data = kmalloc(size, GFP_KERNEL); | ||
3713 | diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c | ||
3714 | index a27fc8791551..ef24b4527459 100644 | ||
3715 | --- a/fs/cifs/readdir.c | ||
3716 | +++ b/fs/cifs/readdir.c | ||
3717 | @@ -376,8 +376,15 @@ static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level) | ||
3718 | |||
3719 | new_entry = old_entry + sizeof(FIND_FILE_STANDARD_INFO) + | ||
3720 | pfData->FileNameLength; | ||
3721 | - } else | ||
3722 | - new_entry = old_entry + le32_to_cpu(pDirInfo->NextEntryOffset); | ||
3723 | + } else { | ||
3724 | + u32 next_offset = le32_to_cpu(pDirInfo->NextEntryOffset); | ||
3725 | + | ||
3726 | + if (old_entry + next_offset < old_entry) { | ||
3727 | + cifs_dbg(VFS, "invalid offset %u\n", next_offset); | ||
3728 | + return NULL; | ||
3729 | + } | ||
3730 | + new_entry = old_entry + next_offset; | ||
3731 | + } | ||
3732 | cifs_dbg(FYI, "new entry %p old entry %p\n", new_entry, old_entry); | ||
3733 | /* validate that new_entry is not past end of SMB */ | ||
3734 | if (new_entry >= end_of_smb) { | ||
3735 | diff --git a/fs/cifs/smb2pdu.c b/fs/cifs/smb2pdu.c | ||
3736 | index 078ec705a5cc..69309538ffb8 100644 | ||
3737 | --- a/fs/cifs/smb2pdu.c | ||
3738 | +++ b/fs/cifs/smb2pdu.c | ||
3739 | @@ -2939,33 +2939,38 @@ num_entries(char *bufstart, char *end_of_buf, char **lastentry, size_t size) | ||
3740 | int len; | ||
3741 | unsigned int entrycount = 0; | ||
3742 | unsigned int next_offset = 0; | ||
3743 | - FILE_DIRECTORY_INFO *entryptr; | ||
3744 | + char *entryptr; | ||
3745 | + FILE_DIRECTORY_INFO *dir_info; | ||
3746 | |||
3747 | if (bufstart == NULL) | ||
3748 | return 0; | ||
3749 | |||
3750 | - entryptr = (FILE_DIRECTORY_INFO *)bufstart; | ||
3751 | + entryptr = bufstart; | ||
3752 | |||
3753 | while (1) { | ||
3754 | - entryptr = (FILE_DIRECTORY_INFO *) | ||
3755 | - ((char *)entryptr + next_offset); | ||
3756 | - | ||
3757 | - if ((char *)entryptr + size > end_of_buf) { | ||
3758 | + if (entryptr + next_offset < entryptr || | ||
3759 | + entryptr + next_offset > end_of_buf || | ||
3760 | + entryptr + next_offset + size > end_of_buf) { | ||
3761 | cifs_dbg(VFS, "malformed search entry would overflow\n"); | ||
3762 | break; | ||
3763 | } | ||
3764 | |||
3765 | - len = le32_to_cpu(entryptr->FileNameLength); | ||
3766 | - if ((char *)entryptr + len + size > end_of_buf) { | ||
3767 | + entryptr = entryptr + next_offset; | ||
3768 | + dir_info = (FILE_DIRECTORY_INFO *)entryptr; | ||
3769 | + | ||
3770 | + len = le32_to_cpu(dir_info->FileNameLength); | ||
3771 | + if (entryptr + len < entryptr || | ||
3772 | + entryptr + len > end_of_buf || | ||
3773 | + entryptr + len + size > end_of_buf) { | ||
3774 | cifs_dbg(VFS, "directory entry name would overflow frame end of buf %p\n", | ||
3775 | end_of_buf); | ||
3776 | break; | ||
3777 | } | ||
3778 | |||
3779 | - *lastentry = (char *)entryptr; | ||
3780 | + *lastentry = entryptr; | ||
3781 | entrycount++; | ||
3782 | |||
3783 | - next_offset = le32_to_cpu(entryptr->NextEntryOffset); | ||
3784 | + next_offset = le32_to_cpu(dir_info->NextEntryOffset); | ||
3785 | if (!next_offset) | ||
3786 | break; | ||
3787 | } | ||
3788 | diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c | ||
3789 | index 56fb26127fef..d2a1a79fa324 100644 | ||
3790 | --- a/fs/configfs/dir.c | ||
3791 | +++ b/fs/configfs/dir.c | ||
3792 | @@ -1777,6 +1777,16 @@ void configfs_unregister_group(struct config_group *group) | ||
3793 | struct dentry *dentry = group->cg_item.ci_dentry; | ||
3794 | struct dentry *parent = group->cg_item.ci_parent->ci_dentry; | ||
3795 | |||
3796 | + mutex_lock(&subsys->su_mutex); | ||
3797 | + if (!group->cg_item.ci_parent->ci_group) { | ||
3798 | + /* | ||
3799 | + * The parent has already been unlinked and detached | ||
3800 | + * due to a rmdir. | ||
3801 | + */ | ||
3802 | + goto unlink_group; | ||
3803 | + } | ||
3804 | + mutex_unlock(&subsys->su_mutex); | ||
3805 | + | ||
3806 | inode_lock_nested(d_inode(parent), I_MUTEX_PARENT); | ||
3807 | spin_lock(&configfs_dirent_lock); | ||
3808 | configfs_detach_prep(dentry, NULL); | ||
3809 | @@ -1791,6 +1801,7 @@ void configfs_unregister_group(struct config_group *group) | ||
3810 | dput(dentry); | ||
3811 | |||
3812 | mutex_lock(&subsys->su_mutex); | ||
3813 | +unlink_group: | ||
3814 | unlink_group(group); | ||
3815 | mutex_unlock(&subsys->su_mutex); | ||
3816 | } | ||
3817 | diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c | ||
3818 | index 3dd0cceefa43..bc8787718feb 100644 | ||
3819 | --- a/fs/gfs2/bmap.c | ||
3820 | +++ b/fs/gfs2/bmap.c | ||
3821 | @@ -1680,7 +1680,7 @@ int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset, | ||
3822 | end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift; | ||
3823 | lblock = offset >> shift; | ||
3824 | lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift; | ||
3825 | - if (lblock_stop > end_of_file) | ||
3826 | + if (lblock_stop > end_of_file && ip != GFS2_I(sdp->sd_rindex)) | ||
3827 | return 1; | ||
3828 | |||
3829 | size = (lblock_stop - lblock) << shift; | ||
3830 | diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c | ||
3831 | index 95b2a57ded33..5fe033131f03 100644 | ||
3832 | --- a/fs/gfs2/rgrp.c | ||
3833 | +++ b/fs/gfs2/rgrp.c | ||
3834 | @@ -1665,7 +1665,8 @@ static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext, | ||
3835 | |||
3836 | while(1) { | ||
3837 | bi = rbm_bi(rbm); | ||
3838 | - if (test_bit(GBF_FULL, &bi->bi_flags) && | ||
3839 | + if ((ip == NULL || !gfs2_rs_active(&ip->i_res)) && | ||
3840 | + test_bit(GBF_FULL, &bi->bi_flags) && | ||
3841 | (state == GFS2_BLKST_FREE)) | ||
3842 | goto next_bitmap; | ||
3843 | |||
3844 | diff --git a/fs/namespace.c b/fs/namespace.c | ||
3845 | index 9dc146e7b5e0..3ee3ee5819bc 100644 | ||
3846 | --- a/fs/namespace.c | ||
3847 | +++ b/fs/namespace.c | ||
3848 | @@ -446,10 +446,10 @@ int mnt_want_write_file_path(struct file *file) | ||
3849 | { | ||
3850 | int ret; | ||
3851 | |||
3852 | - sb_start_write(file->f_path.mnt->mnt_sb); | ||
3853 | + sb_start_write(file_inode(file)->i_sb); | ||
3854 | ret = __mnt_want_write_file(file); | ||
3855 | if (ret) | ||
3856 | - sb_end_write(file->f_path.mnt->mnt_sb); | ||
3857 | + sb_end_write(file_inode(file)->i_sb); | ||
3858 | return ret; | ||
3859 | } | ||
3860 | |||
3861 | @@ -540,7 +540,8 @@ void __mnt_drop_write_file(struct file *file) | ||
3862 | |||
3863 | void mnt_drop_write_file_path(struct file *file) | ||
3864 | { | ||
3865 | - mnt_drop_write(file->f_path.mnt); | ||
3866 | + __mnt_drop_write_file(file); | ||
3867 | + sb_end_write(file_inode(file)->i_sb); | ||
3868 | } | ||
3869 | |||
3870 | void mnt_drop_write_file(struct file *file) | ||
3871 | diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c | ||
3872 | index 77c7d29fcd3b..a3b67d3b1dfb 100644 | ||
3873 | --- a/fs/nfs/nfs4proc.c | ||
3874 | +++ b/fs/nfs/nfs4proc.c | ||
3875 | @@ -2533,14 +2533,18 @@ static void nfs41_check_delegation_stateid(struct nfs4_state *state) | ||
3876 | } | ||
3877 | |||
3878 | nfs4_stateid_copy(&stateid, &delegation->stateid); | ||
3879 | - if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) || | ||
3880 | - !test_and_clear_bit(NFS_DELEGATION_TEST_EXPIRED, | ||
3881 | - &delegation->flags)) { | ||
3882 | + if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { | ||
3883 | rcu_read_unlock(); | ||
3884 | nfs_finish_clear_delegation_stateid(state, &stateid); | ||
3885 | return; | ||
3886 | } | ||
3887 | |||
3888 | + if (!test_and_clear_bit(NFS_DELEGATION_TEST_EXPIRED, | ||
3889 | + &delegation->flags)) { | ||
3890 | + rcu_read_unlock(); | ||
3891 | + return; | ||
3892 | + } | ||
3893 | + | ||
3894 | cred = get_rpccred(delegation->cred); | ||
3895 | rcu_read_unlock(); | ||
3896 | status = nfs41_test_and_free_expired_stateid(server, &stateid, cred); | ||
3897 | diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c | ||
3898 | index 45873ed92057..e1d88bca815e 100644 | ||
3899 | --- a/fs/nfs/nfs4state.c | ||
3900 | +++ b/fs/nfs/nfs4state.c | ||
3901 | @@ -1354,6 +1354,8 @@ int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_ | ||
3902 | |||
3903 | if (!nfs4_state_mark_reclaim_nograce(clp, state)) | ||
3904 | return -EBADF; | ||
3905 | + nfs_inode_find_delegation_state_and_recover(state->inode, | ||
3906 | + &state->stateid); | ||
3907 | dprintk("%s: scheduling stateid recovery for server %s\n", __func__, | ||
3908 | clp->cl_hostname); | ||
3909 | nfs4_schedule_state_manager(clp); | ||
3910 | diff --git a/fs/pstore/ram_core.c b/fs/pstore/ram_core.c | ||
3911 | index e11672aa4575..ecdb3baa1283 100644 | ||
3912 | --- a/fs/pstore/ram_core.c | ||
3913 | +++ b/fs/pstore/ram_core.c | ||
3914 | @@ -421,7 +421,12 @@ static void *persistent_ram_vmap(phys_addr_t start, size_t size, | ||
3915 | vaddr = vmap(pages, page_count, VM_MAP, prot); | ||
3916 | kfree(pages); | ||
3917 | |||
3918 | - return vaddr; | ||
3919 | + /* | ||
3920 | + * Since vmap() uses page granularity, we must add the offset | ||
3921 | + * into the page here, to get the byte granularity address | ||
3922 | + * into the mapping to represent the actual "start" location. | ||
3923 | + */ | ||
3924 | + return vaddr + offset_in_page(start); | ||
3925 | } | ||
3926 | |||
3927 | static void *persistent_ram_iomap(phys_addr_t start, size_t size, | ||
3928 | @@ -440,6 +445,11 @@ static void *persistent_ram_iomap(phys_addr_t start, size_t size, | ||
3929 | else | ||
3930 | va = ioremap_wc(start, size); | ||
3931 | |||
3932 | + /* | ||
3933 | + * Since request_mem_region() and ioremap() are byte-granularity | ||
3934 | + * there is no need handle anything special like we do when the | ||
3935 | + * vmap() case in persistent_ram_vmap() above. | ||
3936 | + */ | ||
3937 | return va; | ||
3938 | } | ||
3939 | |||
3940 | @@ -460,7 +470,7 @@ static int persistent_ram_buffer_map(phys_addr_t start, phys_addr_t size, | ||
3941 | return -ENOMEM; | ||
3942 | } | ||
3943 | |||
3944 | - prz->buffer = prz->vaddr + offset_in_page(start); | ||
3945 | + prz->buffer = prz->vaddr; | ||
3946 | prz->buffer_size = size - sizeof(struct persistent_ram_buffer); | ||
3947 | |||
3948 | return 0; | ||
3949 | @@ -507,7 +517,8 @@ void persistent_ram_free(struct persistent_ram_zone *prz) | ||
3950 | |||
3951 | if (prz->vaddr) { | ||
3952 | if (pfn_valid(prz->paddr >> PAGE_SHIFT)) { | ||
3953 | - vunmap(prz->vaddr); | ||
3954 | + /* We must vunmap() at page-granularity. */ | ||
3955 | + vunmap(prz->vaddr - offset_in_page(prz->paddr)); | ||
3956 | } else { | ||
3957 | iounmap(prz->vaddr); | ||
3958 | release_mem_region(prz->paddr, prz->size); | ||
3959 | diff --git a/include/linux/crypto.h b/include/linux/crypto.h | ||
3960 | index cc36484d29e1..de96913306cb 100644 | ||
3961 | --- a/include/linux/crypto.h | ||
3962 | +++ b/include/linux/crypto.h | ||
3963 | @@ -111,6 +111,11 @@ | ||
3964 | */ | ||
3965 | #define CRYPTO_ALG_OPTIONAL_KEY 0x00004000 | ||
3966 | |||
3967 | +/* | ||
3968 | + * Don't trigger module loading | ||
3969 | + */ | ||
3970 | +#define CRYPTO_NOLOAD 0x00008000 | ||
3971 | + | ||
3972 | /* | ||
3973 | * Transform masks and values (for crt_flags). | ||
3974 | */ | ||
3975 | diff --git a/include/linux/mlx5/driver.h b/include/linux/mlx5/driver.h | ||
3976 | index f2f9e957bf1b..c4d19e77fea8 100644 | ||
3977 | --- a/include/linux/mlx5/driver.h | ||
3978 | +++ b/include/linux/mlx5/driver.h | ||
3979 | @@ -950,7 +950,7 @@ int mlx5_cmd_free_uar(struct mlx5_core_dev *dev, u32 uarn); | ||
3980 | void mlx5_health_cleanup(struct mlx5_core_dev *dev); | ||
3981 | int mlx5_health_init(struct mlx5_core_dev *dev); | ||
3982 | void mlx5_start_health_poll(struct mlx5_core_dev *dev); | ||
3983 | -void mlx5_stop_health_poll(struct mlx5_core_dev *dev); | ||
3984 | +void mlx5_stop_health_poll(struct mlx5_core_dev *dev, bool disable_health); | ||
3985 | void mlx5_drain_health_wq(struct mlx5_core_dev *dev); | ||
3986 | void mlx5_trigger_health_work(struct mlx5_core_dev *dev); | ||
3987 | void mlx5_drain_health_recovery(struct mlx5_core_dev *dev); | ||
3988 | diff --git a/kernel/audit_watch.c b/kernel/audit_watch.c | ||
3989 | index 9eb8b3511636..4a98f6e314a9 100644 | ||
3990 | --- a/kernel/audit_watch.c | ||
3991 | +++ b/kernel/audit_watch.c | ||
3992 | @@ -419,6 +419,13 @@ int audit_add_watch(struct audit_krule *krule, struct list_head **list) | ||
3993 | struct path parent_path; | ||
3994 | int h, ret = 0; | ||
3995 | |||
3996 | + /* | ||
3997 | + * When we will be calling audit_add_to_parent, krule->watch might have | ||
3998 | + * been updated and watch might have been freed. | ||
3999 | + * So we need to keep a reference of watch. | ||
4000 | + */ | ||
4001 | + audit_get_watch(watch); | ||
4002 | + | ||
4003 | mutex_unlock(&audit_filter_mutex); | ||
4004 | |||
4005 | /* Avoid calling path_lookup under audit_filter_mutex. */ | ||
4006 | @@ -427,8 +434,10 @@ int audit_add_watch(struct audit_krule *krule, struct list_head **list) | ||
4007 | /* caller expects mutex locked */ | ||
4008 | mutex_lock(&audit_filter_mutex); | ||
4009 | |||
4010 | - if (ret) | ||
4011 | + if (ret) { | ||
4012 | + audit_put_watch(watch); | ||
4013 | return ret; | ||
4014 | + } | ||
4015 | |||
4016 | /* either find an old parent or attach a new one */ | ||
4017 | parent = audit_find_parent(d_backing_inode(parent_path.dentry)); | ||
4018 | @@ -446,6 +455,7 @@ int audit_add_watch(struct audit_krule *krule, struct list_head **list) | ||
4019 | *list = &audit_inode_hash[h]; | ||
4020 | error: | ||
4021 | path_put(&parent_path); | ||
4022 | + audit_put_watch(watch); | ||
4023 | return ret; | ||
4024 | } | ||
4025 | |||
4026 | diff --git a/kernel/events/core.c b/kernel/events/core.c | ||
4027 | index 7c394ddf1ce6..812ebf1cbb87 100644 | ||
4028 | --- a/kernel/events/core.c | ||
4029 | +++ b/kernel/events/core.c | ||
4030 | @@ -5700,6 +5700,7 @@ perf_output_sample_ustack(struct perf_output_handle *handle, u64 dump_size, | ||
4031 | unsigned long sp; | ||
4032 | unsigned int rem; | ||
4033 | u64 dyn_size; | ||
4034 | + mm_segment_t fs; | ||
4035 | |||
4036 | /* | ||
4037 | * We dump: | ||
4038 | @@ -5717,7 +5718,10 @@ perf_output_sample_ustack(struct perf_output_handle *handle, u64 dump_size, | ||
4039 | |||
4040 | /* Data. */ | ||
4041 | sp = perf_user_stack_pointer(regs); | ||
4042 | + fs = get_fs(); | ||
4043 | + set_fs(USER_DS); | ||
4044 | rem = __output_copy_user(handle, (void *) sp, dump_size); | ||
4045 | + set_fs(fs); | ||
4046 | dyn_size = dump_size - rem; | ||
4047 | |||
4048 | perf_output_skip(handle, rem); | ||
4049 | diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c | ||
4050 | index 0cc7098c6dfd..a5e20ceb0b5a 100644 | ||
4051 | --- a/kernel/sched/fair.c | ||
4052 | +++ b/kernel/sched/fair.c | ||
4053 | @@ -757,11 +757,12 @@ static void attach_entity_cfs_rq(struct sched_entity *se); | ||
4054 | * To solve this problem, we also cap the util_avg of successive tasks to | ||
4055 | * only 1/2 of the left utilization budget: | ||
4056 | * | ||
4057 | - * util_avg_cap = (1024 - cfs_rq->avg.util_avg) / 2^n | ||
4058 | + * util_avg_cap = (cpu_scale - cfs_rq->avg.util_avg) / 2^n | ||
4059 | * | ||
4060 | - * where n denotes the nth task. | ||
4061 | + * where n denotes the nth task and cpu_scale the CPU capacity. | ||
4062 | * | ||
4063 | - * For example, a simplest series from the beginning would be like: | ||
4064 | + * For example, for a CPU with 1024 of capacity, a simplest series from | ||
4065 | + * the beginning would be like: | ||
4066 | * | ||
4067 | * task util_avg: 512, 256, 128, 64, 32, 16, 8, ... | ||
4068 | * cfs_rq util_avg: 512, 768, 896, 960, 992, 1008, 1016, ... | ||
4069 | @@ -773,7 +774,8 @@ void post_init_entity_util_avg(struct sched_entity *se) | ||
4070 | { | ||
4071 | struct cfs_rq *cfs_rq = cfs_rq_of(se); | ||
4072 | struct sched_avg *sa = &se->avg; | ||
4073 | - long cap = (long)(SCHED_CAPACITY_SCALE - cfs_rq->avg.util_avg) / 2; | ||
4074 | + long cpu_scale = arch_scale_cpu_capacity(NULL, cpu_of(rq_of(cfs_rq))); | ||
4075 | + long cap = (long)(cpu_scale - cfs_rq->avg.util_avg) / 2; | ||
4076 | |||
4077 | if (cap > 0) { | ||
4078 | if (cfs_rq->avg.util_avg != 0) { | ||
4079 | diff --git a/kernel/sched/wait.c b/kernel/sched/wait.c | ||
4080 | index 929ecb7d6b78..e29608464382 100644 | ||
4081 | --- a/kernel/sched/wait.c | ||
4082 | +++ b/kernel/sched/wait.c | ||
4083 | @@ -395,35 +395,36 @@ static inline bool is_kthread_should_stop(void) | ||
4084 | * if (condition) | ||
4085 | * break; | ||
4086 | * | ||
4087 | - * p->state = mode; condition = true; | ||
4088 | - * smp_mb(); // A smp_wmb(); // C | ||
4089 | - * if (!wq_entry->flags & WQ_FLAG_WOKEN) wq_entry->flags |= WQ_FLAG_WOKEN; | ||
4090 | - * schedule() try_to_wake_up(); | ||
4091 | - * p->state = TASK_RUNNING; ~~~~~~~~~~~~~~~~~~ | ||
4092 | - * wq_entry->flags &= ~WQ_FLAG_WOKEN; condition = true; | ||
4093 | - * smp_mb() // B smp_wmb(); // C | ||
4094 | - * wq_entry->flags |= WQ_FLAG_WOKEN; | ||
4095 | - * } | ||
4096 | - * remove_wait_queue(&wq_head, &wait); | ||
4097 | + * // in wait_woken() // in woken_wake_function() | ||
4098 | * | ||
4099 | + * p->state = mode; wq_entry->flags |= WQ_FLAG_WOKEN; | ||
4100 | + * smp_mb(); // A try_to_wake_up(): | ||
4101 | + * if (!(wq_entry->flags & WQ_FLAG_WOKEN)) <full barrier> | ||
4102 | + * schedule() if (p->state & mode) | ||
4103 | + * p->state = TASK_RUNNING; p->state = TASK_RUNNING; | ||
4104 | + * wq_entry->flags &= ~WQ_FLAG_WOKEN; ~~~~~~~~~~~~~~~~~~ | ||
4105 | + * smp_mb(); // B condition = true; | ||
4106 | + * } smp_mb(); // C | ||
4107 | + * remove_wait_queue(&wq_head, &wait); wq_entry->flags |= WQ_FLAG_WOKEN; | ||
4108 | */ | ||
4109 | long wait_woken(struct wait_queue_entry *wq_entry, unsigned mode, long timeout) | ||
4110 | { | ||
4111 | - set_current_state(mode); /* A */ | ||
4112 | /* | ||
4113 | - * The above implies an smp_mb(), which matches with the smp_wmb() from | ||
4114 | - * woken_wake_function() such that if we observe WQ_FLAG_WOKEN we must | ||
4115 | - * also observe all state before the wakeup. | ||
4116 | + * The below executes an smp_mb(), which matches with the full barrier | ||
4117 | + * executed by the try_to_wake_up() in woken_wake_function() such that | ||
4118 | + * either we see the store to wq_entry->flags in woken_wake_function() | ||
4119 | + * or woken_wake_function() sees our store to current->state. | ||
4120 | */ | ||
4121 | + set_current_state(mode); /* A */ | ||
4122 | if (!(wq_entry->flags & WQ_FLAG_WOKEN) && !is_kthread_should_stop()) | ||
4123 | timeout = schedule_timeout(timeout); | ||
4124 | __set_current_state(TASK_RUNNING); | ||
4125 | |||
4126 | /* | ||
4127 | - * The below implies an smp_mb(), it too pairs with the smp_wmb() from | ||
4128 | - * woken_wake_function() such that we must either observe the wait | ||
4129 | - * condition being true _OR_ WQ_FLAG_WOKEN such that we will not miss | ||
4130 | - * an event. | ||
4131 | + * The below executes an smp_mb(), which matches with the smp_mb() (C) | ||
4132 | + * in woken_wake_function() such that either we see the wait condition | ||
4133 | + * being true or the store to wq_entry->flags in woken_wake_function() | ||
4134 | + * follows ours in the coherence order. | ||
4135 | */ | ||
4136 | smp_store_mb(wq_entry->flags, wq_entry->flags & ~WQ_FLAG_WOKEN); /* B */ | ||
4137 | |||
4138 | @@ -433,14 +434,8 @@ EXPORT_SYMBOL(wait_woken); | ||
4139 | |||
4140 | int woken_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key) | ||
4141 | { | ||
4142 | - /* | ||
4143 | - * Although this function is called under waitqueue lock, LOCK | ||
4144 | - * doesn't imply write barrier and the users expects write | ||
4145 | - * barrier semantics on wakeup functions. The following | ||
4146 | - * smp_wmb() is equivalent to smp_wmb() in try_to_wake_up() | ||
4147 | - * and is paired with smp_store_mb() in wait_woken(). | ||
4148 | - */ | ||
4149 | - smp_wmb(); /* C */ | ||
4150 | + /* Pairs with the smp_store_mb() in wait_woken(). */ | ||
4151 | + smp_mb(); /* C */ | ||
4152 | wq_entry->flags |= WQ_FLAG_WOKEN; | ||
4153 | |||
4154 | return default_wake_function(wq_entry, mode, sync, key); | ||
4155 | diff --git a/net/bluetooth/af_bluetooth.c b/net/bluetooth/af_bluetooth.c | ||
4156 | index 91e3ba280706..583951e82cee 100644 | ||
4157 | --- a/net/bluetooth/af_bluetooth.c | ||
4158 | +++ b/net/bluetooth/af_bluetooth.c | ||
4159 | @@ -159,7 +159,7 @@ void bt_accept_enqueue(struct sock *parent, struct sock *sk) | ||
4160 | BT_DBG("parent %p, sk %p", parent, sk); | ||
4161 | |||
4162 | sock_hold(sk); | ||
4163 | - lock_sock(sk); | ||
4164 | + lock_sock_nested(sk, SINGLE_DEPTH_NESTING); | ||
4165 | list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q); | ||
4166 | bt_sk(sk)->parent = parent; | ||
4167 | release_sock(sk); | ||
4168 | diff --git a/net/core/skbuff.c b/net/core/skbuff.c | ||
4169 | index 168a3e8883d4..9f80b947f53b 100644 | ||
4170 | --- a/net/core/skbuff.c | ||
4171 | +++ b/net/core/skbuff.c | ||
4172 | @@ -937,9 +937,6 @@ struct ubuf_info *sock_zerocopy_alloc(struct sock *sk, size_t size) | ||
4173 | |||
4174 | WARN_ON_ONCE(!in_task()); | ||
4175 | |||
4176 | - if (!sock_flag(sk, SOCK_ZEROCOPY)) | ||
4177 | - return NULL; | ||
4178 | - | ||
4179 | skb = sock_omalloc(sk, 0, GFP_KERNEL); | ||
4180 | if (!skb) | ||
4181 | return NULL; | ||
4182 | diff --git a/net/ipv4/ip_gre.c b/net/ipv4/ip_gre.c | ||
4183 | index 2459e9cc22a6..dd3bcf22fe8b 100644 | ||
4184 | --- a/net/ipv4/ip_gre.c | ||
4185 | +++ b/net/ipv4/ip_gre.c | ||
4186 | @@ -177,6 +177,8 @@ static void ipgre_err(struct sk_buff *skb, u32 info, | ||
4187 | |||
4188 | if (tpi->proto == htons(ETH_P_TEB)) | ||
4189 | itn = net_generic(net, gre_tap_net_id); | ||
4190 | + else if (tpi->proto == htons(ETH_P_ERSPAN)) | ||
4191 | + itn = net_generic(net, erspan_net_id); | ||
4192 | else | ||
4193 | itn = net_generic(net, ipgre_net_id); | ||
4194 | |||
4195 | @@ -320,6 +322,8 @@ static int erspan_rcv(struct sk_buff *skb, struct tnl_ptk_info *tpi, | ||
4196 | ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error); | ||
4197 | return PACKET_RCVD; | ||
4198 | } | ||
4199 | + return PACKET_REJECT; | ||
4200 | + | ||
4201 | drop: | ||
4202 | kfree_skb(skb); | ||
4203 | return PACKET_RCVD; | ||
4204 | diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c | ||
4205 | index 7462ec7587ce..f9c985460faa 100644 | ||
4206 | --- a/net/ipv4/tcp.c | ||
4207 | +++ b/net/ipv4/tcp.c | ||
4208 | @@ -1177,7 +1177,7 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size) | ||
4209 | |||
4210 | flags = msg->msg_flags; | ||
4211 | |||
4212 | - if (flags & MSG_ZEROCOPY && size) { | ||
4213 | + if (flags & MSG_ZEROCOPY && size && sock_flag(sk, SOCK_ZEROCOPY)) { | ||
4214 | if (sk->sk_state != TCP_ESTABLISHED) { | ||
4215 | err = -EINVAL; | ||
4216 | goto out_err; | ||
4217 | diff --git a/net/ipv6/route.c b/net/ipv6/route.c | ||
4218 | index 60efd326014b..30204bc2fc48 100644 | ||
4219 | --- a/net/ipv6/route.c | ||
4220 | +++ b/net/ipv6/route.c | ||
4221 | @@ -3239,11 +3239,16 @@ static int ip6_route_multipath_add(struct fib6_config *cfg, | ||
4222 | |||
4223 | err_nh = NULL; | ||
4224 | list_for_each_entry(nh, &rt6_nh_list, next) { | ||
4225 | - rt_last = nh->rt6_info; | ||
4226 | err = __ip6_ins_rt(nh->rt6_info, info, &nh->mxc, extack); | ||
4227 | - /* save reference to first route for notification */ | ||
4228 | - if (!rt_notif && !err) | ||
4229 | - rt_notif = nh->rt6_info; | ||
4230 | + | ||
4231 | + if (!err) { | ||
4232 | + /* save reference to last route successfully inserted */ | ||
4233 | + rt_last = nh->rt6_info; | ||
4234 | + | ||
4235 | + /* save reference to first route for notification */ | ||
4236 | + if (!rt_notif) | ||
4237 | + rt_notif = nh->rt6_info; | ||
4238 | + } | ||
4239 | |||
4240 | /* nh->rt6_info is used or freed at this point, reset to NULL*/ | ||
4241 | nh->rt6_info = NULL; | ||
4242 | diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c | ||
4243 | index 288640471c2f..b456b882a6ea 100644 | ||
4244 | --- a/net/mac80211/cfg.c | ||
4245 | +++ b/net/mac80211/cfg.c | ||
4246 | @@ -494,7 +494,7 @@ static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev, | ||
4247 | goto out_unlock; | ||
4248 | } | ||
4249 | |||
4250 | - ieee80211_key_free(key, true); | ||
4251 | + ieee80211_key_free(key, sdata->vif.type == NL80211_IFTYPE_STATION); | ||
4252 | |||
4253 | ret = 0; | ||
4254 | out_unlock: | ||
4255 | diff --git a/net/mac80211/key.c b/net/mac80211/key.c | ||
4256 | index 938049395f90..fa10c6142244 100644 | ||
4257 | --- a/net/mac80211/key.c | ||
4258 | +++ b/net/mac80211/key.c | ||
4259 | @@ -649,11 +649,15 @@ int ieee80211_key_link(struct ieee80211_key *key, | ||
4260 | { | ||
4261 | struct ieee80211_local *local = sdata->local; | ||
4262 | struct ieee80211_key *old_key; | ||
4263 | - int idx, ret; | ||
4264 | - bool pairwise; | ||
4265 | - | ||
4266 | - pairwise = key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE; | ||
4267 | - idx = key->conf.keyidx; | ||
4268 | + int idx = key->conf.keyidx; | ||
4269 | + bool pairwise = key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE; | ||
4270 | + /* | ||
4271 | + * We want to delay tailroom updates only for station - in that | ||
4272 | + * case it helps roaming speed, but in other cases it hurts and | ||
4273 | + * can cause warnings to appear. | ||
4274 | + */ | ||
4275 | + bool delay_tailroom = sdata->vif.type == NL80211_IFTYPE_STATION; | ||
4276 | + int ret; | ||
4277 | |||
4278 | mutex_lock(&sdata->local->key_mtx); | ||
4279 | |||
4280 | @@ -681,14 +685,14 @@ int ieee80211_key_link(struct ieee80211_key *key, | ||
4281 | increment_tailroom_need_count(sdata); | ||
4282 | |||
4283 | ieee80211_key_replace(sdata, sta, pairwise, old_key, key); | ||
4284 | - ieee80211_key_destroy(old_key, true); | ||
4285 | + ieee80211_key_destroy(old_key, delay_tailroom); | ||
4286 | |||
4287 | ieee80211_debugfs_key_add(key); | ||
4288 | |||
4289 | if (!local->wowlan) { | ||
4290 | ret = ieee80211_key_enable_hw_accel(key); | ||
4291 | if (ret) | ||
4292 | - ieee80211_key_free(key, true); | ||
4293 | + ieee80211_key_free(key, delay_tailroom); | ||
4294 | } else { | ||
4295 | ret = 0; | ||
4296 | } | ||
4297 | @@ -923,7 +927,8 @@ void ieee80211_free_sta_keys(struct ieee80211_local *local, | ||
4298 | ieee80211_key_replace(key->sdata, key->sta, | ||
4299 | key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE, | ||
4300 | key, NULL); | ||
4301 | - __ieee80211_key_destroy(key, true); | ||
4302 | + __ieee80211_key_destroy(key, key->sdata->vif.type == | ||
4303 | + NL80211_IFTYPE_STATION); | ||
4304 | } | ||
4305 | |||
4306 | for (i = 0; i < NUM_DEFAULT_KEYS; i++) { | ||
4307 | @@ -933,7 +938,8 @@ void ieee80211_free_sta_keys(struct ieee80211_local *local, | ||
4308 | ieee80211_key_replace(key->sdata, key->sta, | ||
4309 | key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE, | ||
4310 | key, NULL); | ||
4311 | - __ieee80211_key_destroy(key, true); | ||
4312 | + __ieee80211_key_destroy(key, key->sdata->vif.type == | ||
4313 | + NL80211_IFTYPE_STATION); | ||
4314 | } | ||
4315 | |||
4316 | mutex_unlock(&local->key_mtx); | ||
4317 | diff --git a/net/rds/bind.c b/net/rds/bind.c | ||
4318 | index 5aa3a64aa4f0..48257d3a4201 100644 | ||
4319 | --- a/net/rds/bind.c | ||
4320 | +++ b/net/rds/bind.c | ||
4321 | @@ -60,11 +60,13 @@ struct rds_sock *rds_find_bound(__be32 addr, __be16 port) | ||
4322 | u64 key = ((u64)addr << 32) | port; | ||
4323 | struct rds_sock *rs; | ||
4324 | |||
4325 | - rs = rhashtable_lookup_fast(&bind_hash_table, &key, ht_parms); | ||
4326 | + rcu_read_lock(); | ||
4327 | + rs = rhashtable_lookup(&bind_hash_table, &key, ht_parms); | ||
4328 | if (rs && !sock_flag(rds_rs_to_sk(rs), SOCK_DEAD)) | ||
4329 | rds_sock_addref(rs); | ||
4330 | else | ||
4331 | rs = NULL; | ||
4332 | + rcu_read_unlock(); | ||
4333 | |||
4334 | rdsdebug("returning rs %p for %pI4:%u\n", rs, &addr, | ||
4335 | ntohs(port)); | ||
4336 | @@ -157,6 +159,7 @@ int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) | ||
4337 | goto out; | ||
4338 | } | ||
4339 | |||
4340 | + sock_set_flag(sk, SOCK_RCU_FREE); | ||
4341 | ret = rds_add_bound(rs, sin->sin_addr.s_addr, &sin->sin_port); | ||
4342 | if (ret) | ||
4343 | goto out; | ||
4344 | diff --git a/net/tls/tls_sw.c b/net/tls/tls_sw.c | ||
4345 | index fb79caf56d0e..b81aa6d7dc45 100644 | ||
4346 | --- a/net/tls/tls_sw.c | ||
4347 | +++ b/net/tls/tls_sw.c | ||
4348 | @@ -170,6 +170,9 @@ static int alloc_encrypted_sg(struct sock *sk, int len) | ||
4349 | rc = alloc_sg(sk, len, ctx->sg_encrypted_data, | ||
4350 | &ctx->sg_encrypted_num_elem, &ctx->sg_encrypted_size, 0); | ||
4351 | |||
4352 | + if (rc == -ENOSPC) | ||
4353 | + ctx->sg_encrypted_num_elem = ARRAY_SIZE(ctx->sg_encrypted_data); | ||
4354 | + | ||
4355 | return rc; | ||
4356 | } | ||
4357 | |||
4358 | @@ -183,6 +186,9 @@ static int alloc_plaintext_sg(struct sock *sk, int len) | ||
4359 | &ctx->sg_plaintext_num_elem, &ctx->sg_plaintext_size, | ||
4360 | tls_ctx->pending_open_record_frags); | ||
4361 | |||
4362 | + if (rc == -ENOSPC) | ||
4363 | + ctx->sg_plaintext_num_elem = ARRAY_SIZE(ctx->sg_plaintext_data); | ||
4364 | + | ||
4365 | return rc; | ||
4366 | } | ||
4367 | |||
4368 | diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c | ||
4369 | index a6c0027cadb5..2fb7a78308e1 100644 | ||
4370 | --- a/net/xfrm/xfrm_policy.c | ||
4371 | +++ b/net/xfrm/xfrm_policy.c | ||
4372 | @@ -1831,7 +1831,10 @@ xfrm_resolve_and_create_bundle(struct xfrm_policy **pols, int num_pols, | ||
4373 | /* Try to instantiate a bundle */ | ||
4374 | err = xfrm_tmpl_resolve(pols, num_pols, fl, xfrm, family); | ||
4375 | if (err <= 0) { | ||
4376 | - if (err != 0 && err != -EAGAIN) | ||
4377 | + if (err == 0) | ||
4378 | + return NULL; | ||
4379 | + | ||
4380 | + if (err != -EAGAIN) | ||
4381 | XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTPOLERROR); | ||
4382 | return ERR_PTR(err); | ||
4383 | } | ||
4384 | diff --git a/scripts/Kbuild.include b/scripts/Kbuild.include | ||
4385 | index fcbbecf92395..a0ad87e869f9 100644 | ||
4386 | --- a/scripts/Kbuild.include | ||
4387 | +++ b/scripts/Kbuild.include | ||
4388 | @@ -403,3 +403,6 @@ endif | ||
4389 | endef | ||
4390 | # | ||
4391 | ############################################################################### | ||
4392 | + | ||
4393 | +# delete partially updated (i.e. corrupted) files on error | ||
4394 | +.DELETE_ON_ERROR: | ||
4395 | diff --git a/security/integrity/evm/evm_crypto.c b/security/integrity/evm/evm_crypto.c | ||
4396 | index 1d32cd20009a..ee9c3de5065a 100644 | ||
4397 | --- a/security/integrity/evm/evm_crypto.c | ||
4398 | +++ b/security/integrity/evm/evm_crypto.c | ||
4399 | @@ -94,7 +94,8 @@ static struct shash_desc *init_desc(char type) | ||
4400 | mutex_lock(&mutex); | ||
4401 | if (*tfm) | ||
4402 | goto out; | ||
4403 | - *tfm = crypto_alloc_shash(algo, 0, CRYPTO_ALG_ASYNC); | ||
4404 | + *tfm = crypto_alloc_shash(algo, 0, | ||
4405 | + CRYPTO_ALG_ASYNC | CRYPTO_NOLOAD); | ||
4406 | if (IS_ERR(*tfm)) { | ||
4407 | rc = PTR_ERR(*tfm); | ||
4408 | pr_err("Can not allocate %s (reason: %ld)\n", algo, rc); | ||
4409 | diff --git a/security/security.c b/security/security.c | ||
4410 | index 4bf0f571b4ef..95a1a0f52880 100644 | ||
4411 | --- a/security/security.c | ||
4412 | +++ b/security/security.c | ||
4413 | @@ -111,6 +111,8 @@ static int lsm_append(char *new, char **result) | ||
4414 | |||
4415 | if (*result == NULL) { | ||
4416 | *result = kstrdup(new, GFP_KERNEL); | ||
4417 | + if (*result == NULL) | ||
4418 | + return -ENOMEM; | ||
4419 | } else { | ||
4420 | /* Check if it is the last registered name */ | ||
4421 | if (match_last_lsm(*result, new)) | ||
4422 | diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c | ||
4423 | index fdf01bfd1b07..c8fd5c10b7c6 100644 | ||
4424 | --- a/security/smack/smack_lsm.c | ||
4425 | +++ b/security/smack/smack_lsm.c | ||
4426 | @@ -3960,15 +3960,19 @@ static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb) | ||
4427 | struct smack_known *skp = NULL; | ||
4428 | int rc = 0; | ||
4429 | struct smk_audit_info ad; | ||
4430 | + u16 family = sk->sk_family; | ||
4431 | #ifdef CONFIG_AUDIT | ||
4432 | struct lsm_network_audit net; | ||
4433 | #endif | ||
4434 | #if IS_ENABLED(CONFIG_IPV6) | ||
4435 | struct sockaddr_in6 sadd; | ||
4436 | int proto; | ||
4437 | + | ||
4438 | + if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP)) | ||
4439 | + family = PF_INET; | ||
4440 | #endif /* CONFIG_IPV6 */ | ||
4441 | |||
4442 | - switch (sk->sk_family) { | ||
4443 | + switch (family) { | ||
4444 | case PF_INET: | ||
4445 | #ifdef CONFIG_SECURITY_SMACK_NETFILTER | ||
4446 | /* | ||
4447 | @@ -3986,7 +3990,7 @@ static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb) | ||
4448 | */ | ||
4449 | netlbl_secattr_init(&secattr); | ||
4450 | |||
4451 | - rc = netlbl_skbuff_getattr(skb, sk->sk_family, &secattr); | ||
4452 | + rc = netlbl_skbuff_getattr(skb, family, &secattr); | ||
4453 | if (rc == 0) | ||
4454 | skp = smack_from_secattr(&secattr, ssp); | ||
4455 | else | ||
4456 | @@ -3999,7 +4003,7 @@ access_check: | ||
4457 | #endif | ||
4458 | #ifdef CONFIG_AUDIT | ||
4459 | smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net); | ||
4460 | - ad.a.u.net->family = sk->sk_family; | ||
4461 | + ad.a.u.net->family = family; | ||
4462 | ad.a.u.net->netif = skb->skb_iif; | ||
4463 | ipv4_skb_to_auditdata(skb, &ad.a, NULL); | ||
4464 | #endif | ||
4465 | @@ -4013,7 +4017,7 @@ access_check: | ||
4466 | rc = smk_bu_note("IPv4 delivery", skp, ssp->smk_in, | ||
4467 | MAY_WRITE, rc); | ||
4468 | if (rc != 0) | ||
4469 | - netlbl_skbuff_err(skb, sk->sk_family, rc, 0); | ||
4470 | + netlbl_skbuff_err(skb, family, rc, 0); | ||
4471 | break; | ||
4472 | #if IS_ENABLED(CONFIG_IPV6) | ||
4473 | case PF_INET6: | ||
4474 | @@ -4029,7 +4033,7 @@ access_check: | ||
4475 | skp = smack_net_ambient; | ||
4476 | #ifdef CONFIG_AUDIT | ||
4477 | smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net); | ||
4478 | - ad.a.u.net->family = sk->sk_family; | ||
4479 | + ad.a.u.net->family = family; | ||
4480 | ad.a.u.net->netif = skb->skb_iif; | ||
4481 | ipv6_skb_to_auditdata(skb, &ad.a, NULL); | ||
4482 | #endif /* CONFIG_AUDIT */ | ||
4483 | diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c | ||
4484 | index faa67861cbc1..729a85a6211d 100644 | ||
4485 | --- a/sound/core/pcm_lib.c | ||
4486 | +++ b/sound/core/pcm_lib.c | ||
4487 | @@ -629,27 +629,33 @@ EXPORT_SYMBOL(snd_interval_refine); | ||
4488 | |||
4489 | static int snd_interval_refine_first(struct snd_interval *i) | ||
4490 | { | ||
4491 | + const unsigned int last_max = i->max; | ||
4492 | + | ||
4493 | if (snd_BUG_ON(snd_interval_empty(i))) | ||
4494 | return -EINVAL; | ||
4495 | if (snd_interval_single(i)) | ||
4496 | return 0; | ||
4497 | i->max = i->min; | ||
4498 | - i->openmax = i->openmin; | ||
4499 | - if (i->openmax) | ||
4500 | + if (i->openmin) | ||
4501 | i->max++; | ||
4502 | + /* only exclude max value if also excluded before refine */ | ||
4503 | + i->openmax = (i->openmax && i->max >= last_max); | ||
4504 | return 1; | ||
4505 | } | ||
4506 | |||
4507 | static int snd_interval_refine_last(struct snd_interval *i) | ||
4508 | { | ||
4509 | + const unsigned int last_min = i->min; | ||
4510 | + | ||
4511 | if (snd_BUG_ON(snd_interval_empty(i))) | ||
4512 | return -EINVAL; | ||
4513 | if (snd_interval_single(i)) | ||
4514 | return 0; | ||
4515 | i->min = i->max; | ||
4516 | - i->openmin = i->openmax; | ||
4517 | - if (i->openmin) | ||
4518 | + if (i->openmax) | ||
4519 | i->min--; | ||
4520 | + /* only exclude min value if also excluded before refine */ | ||
4521 | + i->openmin = (i->openmin && i->min <= last_min); | ||
4522 | return 1; | ||
4523 | } | ||
4524 | |||
4525 | diff --git a/sound/isa/msnd/msnd_pinnacle.c b/sound/isa/msnd/msnd_pinnacle.c | ||
4526 | index 45e561c425bf..a3cf837c0ffd 100644 | ||
4527 | --- a/sound/isa/msnd/msnd_pinnacle.c | ||
4528 | +++ b/sound/isa/msnd/msnd_pinnacle.c | ||
4529 | @@ -82,10 +82,10 @@ | ||
4530 | |||
4531 | static void set_default_audio_parameters(struct snd_msnd *chip) | ||
4532 | { | ||
4533 | - chip->play_sample_size = DEFSAMPLESIZE; | ||
4534 | + chip->play_sample_size = snd_pcm_format_width(DEFSAMPLESIZE); | ||
4535 | chip->play_sample_rate = DEFSAMPLERATE; | ||
4536 | chip->play_channels = DEFCHANNELS; | ||
4537 | - chip->capture_sample_size = DEFSAMPLESIZE; | ||
4538 | + chip->capture_sample_size = snd_pcm_format_width(DEFSAMPLESIZE); | ||
4539 | chip->capture_sample_rate = DEFSAMPLERATE; | ||
4540 | chip->capture_channels = DEFCHANNELS; | ||
4541 | } | ||
4542 | diff --git a/sound/soc/codecs/rt5514.c b/sound/soc/codecs/rt5514.c | ||
4543 | index e52e68b56238..1bfc8db1826a 100644 | ||
4544 | --- a/sound/soc/codecs/rt5514.c | ||
4545 | +++ b/sound/soc/codecs/rt5514.c | ||
4546 | @@ -64,8 +64,8 @@ static const struct reg_sequence rt5514_patch[] = { | ||
4547 | {RT5514_ANA_CTRL_LDO10, 0x00028604}, | ||
4548 | {RT5514_ANA_CTRL_ADCFED, 0x00000800}, | ||
4549 | {RT5514_ASRC_IN_CTRL1, 0x00000003}, | ||
4550 | - {RT5514_DOWNFILTER0_CTRL3, 0x10000362}, | ||
4551 | - {RT5514_DOWNFILTER1_CTRL3, 0x10000362}, | ||
4552 | + {RT5514_DOWNFILTER0_CTRL3, 0x10000352}, | ||
4553 | + {RT5514_DOWNFILTER1_CTRL3, 0x10000352}, | ||
4554 | }; | ||
4555 | |||
4556 | static const struct reg_default rt5514_reg[] = { | ||
4557 | @@ -92,10 +92,10 @@ static const struct reg_default rt5514_reg[] = { | ||
4558 | {RT5514_ASRC_IN_CTRL1, 0x00000003}, | ||
4559 | {RT5514_DOWNFILTER0_CTRL1, 0x00020c2f}, | ||
4560 | {RT5514_DOWNFILTER0_CTRL2, 0x00020c2f}, | ||
4561 | - {RT5514_DOWNFILTER0_CTRL3, 0x10000362}, | ||
4562 | + {RT5514_DOWNFILTER0_CTRL3, 0x10000352}, | ||
4563 | {RT5514_DOWNFILTER1_CTRL1, 0x00020c2f}, | ||
4564 | {RT5514_DOWNFILTER1_CTRL2, 0x00020c2f}, | ||
4565 | - {RT5514_DOWNFILTER1_CTRL3, 0x10000362}, | ||
4566 | + {RT5514_DOWNFILTER1_CTRL3, 0x10000352}, | ||
4567 | {RT5514_ANA_CTRL_LDO10, 0x00028604}, | ||
4568 | {RT5514_ANA_CTRL_LDO18_16, 0x02000345}, | ||
4569 | {RT5514_ANA_CTRL_ADC12, 0x0000a2a8}, | ||
4570 | diff --git a/sound/soc/samsung/i2s.c b/sound/soc/samsung/i2s.c | ||
4571 | index f058f2bdd519..33b4d14af2b3 100644 | ||
4572 | --- a/sound/soc/samsung/i2s.c | ||
4573 | +++ b/sound/soc/samsung/i2s.c | ||
4574 | @@ -552,8 +552,11 @@ static int i2s_set_sysclk(struct snd_soc_dai *dai, | ||
4575 | } | ||
4576 | |||
4577 | ret = clk_prepare_enable(i2s->op_clk); | ||
4578 | - if (ret) | ||
4579 | + if (ret) { | ||
4580 | + clk_put(i2s->op_clk); | ||
4581 | + i2s->op_clk = NULL; | ||
4582 | goto err; | ||
4583 | + } | ||
4584 | i2s->rclk_srcrate = clk_get_rate(i2s->op_clk); | ||
4585 | |||
4586 | /* Over-ride the other's */ | ||
4587 | diff --git a/sound/soc/samsung/tm2_wm5110.c b/sound/soc/samsung/tm2_wm5110.c | ||
4588 | index 68698f3d72f9..52e2fbe446d1 100644 | ||
4589 | --- a/sound/soc/samsung/tm2_wm5110.c | ||
4590 | +++ b/sound/soc/samsung/tm2_wm5110.c | ||
4591 | @@ -436,8 +436,7 @@ static int tm2_probe(struct platform_device *pdev) | ||
4592 | snd_soc_card_set_drvdata(card, priv); | ||
4593 | card->dev = dev; | ||
4594 | |||
4595 | - priv->gpio_mic_bias = devm_gpiod_get(dev, "mic-bias", | ||
4596 | - GPIOF_OUT_INIT_LOW); | ||
4597 | + priv->gpio_mic_bias = devm_gpiod_get(dev, "mic-bias", GPIOD_OUT_HIGH); | ||
4598 | if (IS_ERR(priv->gpio_mic_bias)) { | ||
4599 | dev_err(dev, "Failed to get mic bias gpio\n"); | ||
4600 | return PTR_ERR(priv->gpio_mic_bias); | ||
4601 | diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h | ||
4602 | index 69bf5cf1e91e..15cbe2565703 100644 | ||
4603 | --- a/sound/usb/quirks-table.h | ||
4604 | +++ b/sound/usb/quirks-table.h | ||
4605 | @@ -2875,7 +2875,8 @@ YAMAHA_DEVICE(0x7010, "UB99"), | ||
4606 | */ | ||
4607 | |||
4608 | #define AU0828_DEVICE(vid, pid, vname, pname) { \ | ||
4609 | - USB_DEVICE_VENDOR_SPEC(vid, pid), \ | ||
4610 | + .idVendor = vid, \ | ||
4611 | + .idProduct = pid, \ | ||
4612 | .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \ | ||
4613 | USB_DEVICE_ID_MATCH_INT_CLASS | \ | ||
4614 | USB_DEVICE_ID_MATCH_INT_SUBCLASS, \ | ||
4615 | diff --git a/tools/hv/hv_kvp_daemon.c b/tools/hv/hv_kvp_daemon.c | ||
4616 | index 4c99c57736ce..3965186b375a 100644 | ||
4617 | --- a/tools/hv/hv_kvp_daemon.c | ||
4618 | +++ b/tools/hv/hv_kvp_daemon.c | ||
4619 | @@ -286,7 +286,7 @@ static int kvp_key_delete(int pool, const __u8 *key, int key_size) | ||
4620 | * Found a match; just move the remaining | ||
4621 | * entries up. | ||
4622 | */ | ||
4623 | - if (i == num_records) { | ||
4624 | + if (i == (num_records - 1)) { | ||
4625 | kvp_file_info[pool].num_records--; | ||
4626 | kvp_update_file(pool); | ||
4627 | return 0; | ||
4628 | diff --git a/tools/perf/arch/powerpc/util/skip-callchain-idx.c b/tools/perf/arch/powerpc/util/skip-callchain-idx.c | ||
4629 | index bd630c222e65..9a53f6e9ef43 100644 | ||
4630 | --- a/tools/perf/arch/powerpc/util/skip-callchain-idx.c | ||
4631 | +++ b/tools/perf/arch/powerpc/util/skip-callchain-idx.c | ||
4632 | @@ -58,9 +58,13 @@ static int check_return_reg(int ra_regno, Dwarf_Frame *frame) | ||
4633 | } | ||
4634 | |||
4635 | /* | ||
4636 | - * Check if return address is on the stack. | ||
4637 | + * Check if return address is on the stack. If return address | ||
4638 | + * is in a register (typically R0), it is yet to be saved on | ||
4639 | + * the stack. | ||
4640 | */ | ||
4641 | - if (nops != 0 || ops != NULL) | ||
4642 | + if ((nops != 0 || ops != NULL) && | ||
4643 | + !(nops == 1 && ops[0].atom == DW_OP_regx && | ||
4644 | + ops[0].number2 == 0 && ops[0].offset == 0)) | ||
4645 | return 0; | ||
4646 | |||
4647 | /* | ||
4648 | @@ -246,7 +250,7 @@ int arch_skip_callchain_idx(struct thread *thread, struct ip_callchain *chain) | ||
4649 | if (!chain || chain->nr < 3) | ||
4650 | return skip_slot; | ||
4651 | |||
4652 | - ip = chain->ips[2]; | ||
4653 | + ip = chain->ips[1]; | ||
4654 | |||
4655 | thread__find_addr_location(thread, PERF_RECORD_MISC_USER, | ||
4656 | MAP__FUNCTION, ip, &al); | ||
4657 | diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c | ||
4658 | index 53d06f37406a..5966f1f9b160 100644 | ||
4659 | --- a/tools/perf/tests/builtin-test.c | ||
4660 | +++ b/tools/perf/tests/builtin-test.c | ||
4661 | @@ -589,7 +589,7 @@ static int __cmd_test(int argc, const char *argv[], struct intlist *skiplist) | ||
4662 | for (subi = 0; subi < subn; subi++) { | ||
4663 | pr_info("%2d.%1d: %-*s:", i, subi + 1, subw, | ||
4664 | t->subtest.get_desc(subi)); | ||
4665 | - err = test_and_print(t, skip, subi); | ||
4666 | + err = test_and_print(t, skip, subi + 1); | ||
4667 | if (err != TEST_OK && t->subtest.skip_if_fail) | ||
4668 | skip = true; | ||
4669 | } | ||
4670 | diff --git a/tools/perf/util/comm.c b/tools/perf/util/comm.c | ||
4671 | index 8808570f8e9c..327e01cb1aa2 100644 | ||
4672 | --- a/tools/perf/util/comm.c | ||
4673 | +++ b/tools/perf/util/comm.c | ||
4674 | @@ -18,9 +18,10 @@ static struct rb_root comm_str_root; | ||
4675 | |||
4676 | static struct comm_str *comm_str__get(struct comm_str *cs) | ||
4677 | { | ||
4678 | - if (cs) | ||
4679 | - refcount_inc(&cs->refcnt); | ||
4680 | - return cs; | ||
4681 | + if (cs && refcount_inc_not_zero(&cs->refcnt)) | ||
4682 | + return cs; | ||
4683 | + | ||
4684 | + return NULL; | ||
4685 | } | ||
4686 | |||
4687 | static void comm_str__put(struct comm_str *cs) | ||
4688 | @@ -62,9 +63,14 @@ static struct comm_str *comm_str__findnew(const char *str, struct rb_root *root) | ||
4689 | parent = *p; | ||
4690 | iter = rb_entry(parent, struct comm_str, rb_node); | ||
4691 | |||
4692 | + /* | ||
4693 | + * If we race with comm_str__put, iter->refcnt is 0 | ||
4694 | + * and it will be removed within comm_str__put call | ||
4695 | + * shortly, ignore it in this search. | ||
4696 | + */ | ||
4697 | cmp = strcmp(str, iter->str); | ||
4698 | - if (!cmp) | ||
4699 | - return comm_str__get(iter); | ||
4700 | + if (!cmp && comm_str__get(iter)) | ||
4701 | + return iter; | ||
4702 | |||
4703 | if (cmp < 0) | ||
4704 | p = &(*p)->rb_left; | ||
4705 | diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c | ||
4706 | index 8a678a3d5a2a..1ceb332575bd 100644 | ||
4707 | --- a/tools/perf/util/header.c | ||
4708 | +++ b/tools/perf/util/header.c | ||
4709 | @@ -2209,7 +2209,7 @@ static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = { | ||
4710 | FEAT_OPR(NUMA_TOPOLOGY, numa_topology, true), | ||
4711 | FEAT_OPN(BRANCH_STACK, branch_stack, false), | ||
4712 | FEAT_OPR(PMU_MAPPINGS, pmu_mappings, false), | ||
4713 | - FEAT_OPN(GROUP_DESC, group_desc, false), | ||
4714 | + FEAT_OPR(GROUP_DESC, group_desc, false), | ||
4715 | FEAT_OPN(AUXTRACE, auxtrace, false), | ||
4716 | FEAT_OPN(STAT, stat, false), | ||
4717 | FEAT_OPN(CACHE, cache, true), | ||
4718 | diff --git a/tools/testing/selftests/timers/raw_skew.c b/tools/testing/selftests/timers/raw_skew.c | ||
4719 | index ca6cd146aafe..dcf73c5dab6e 100644 | ||
4720 | --- a/tools/testing/selftests/timers/raw_skew.c | ||
4721 | +++ b/tools/testing/selftests/timers/raw_skew.c | ||
4722 | @@ -134,6 +134,11 @@ int main(int argv, char **argc) | ||
4723 | printf(" %lld.%i(act)", ppm/1000, abs((int)(ppm%1000))); | ||
4724 | |||
4725 | if (llabs(eppm - ppm) > 1000) { | ||
4726 | + if (tx1.offset || tx2.offset || | ||
4727 | + tx1.freq != tx2.freq || tx1.tick != tx2.tick) { | ||
4728 | + printf(" [SKIP]\n"); | ||
4729 | + return ksft_exit_skip("The clock was adjusted externally. Shutdown NTPd or other time sync daemons\n"); | ||
4730 | + } | ||
4731 | printf(" [FAILED]\n"); | ||
4732 | return ksft_exit_fail(); | ||
4733 | } | ||
4734 | diff --git a/virt/kvm/arm/vgic/vgic-init.c b/virt/kvm/arm/vgic/vgic-init.c | ||
4735 | index 5801261f3add..6f7f26ae72b4 100644 | ||
4736 | --- a/virt/kvm/arm/vgic/vgic-init.c | ||
4737 | +++ b/virt/kvm/arm/vgic/vgic-init.c | ||
4738 | @@ -277,6 +277,10 @@ int vgic_init(struct kvm *kvm) | ||
4739 | if (vgic_initialized(kvm)) | ||
4740 | return 0; | ||
4741 | |||
4742 | + /* Are we also in the middle of creating a VCPU? */ | ||
4743 | + if (kvm->created_vcpus != atomic_read(&kvm->online_vcpus)) | ||
4744 | + return -EBUSY; | ||
4745 | + | ||
4746 | /* freeze the number of spis */ | ||
4747 | if (!dist->nr_spis) | ||
4748 | dist->nr_spis = VGIC_NR_IRQS_LEGACY - VGIC_NR_PRIVATE_IRQS; | ||
4749 | diff --git a/virt/kvm/arm/vgic/vgic-mmio-v2.c b/virt/kvm/arm/vgic/vgic-mmio-v2.c | ||
4750 | index af003268bf3e..7ea5928244fa 100644 | ||
4751 | --- a/virt/kvm/arm/vgic/vgic-mmio-v2.c | ||
4752 | +++ b/virt/kvm/arm/vgic/vgic-mmio-v2.c | ||
4753 | @@ -348,6 +348,9 @@ static void vgic_mmio_write_apr(struct kvm_vcpu *vcpu, | ||
4754 | |||
4755 | if (n > vgic_v3_max_apr_idx(vcpu)) | ||
4756 | return; | ||
4757 | + | ||
4758 | + n = array_index_nospec(n, 4); | ||
4759 | + | ||
4760 | /* GICv3 only uses ICH_AP1Rn for memory mapped (GICv2) guests */ | ||
4761 | vgicv3->vgic_ap1r[n] = val; | ||
4762 | } |