Annotation of /trunk/kernel-alx/patches-3.18/0117-3.18.18-all-fixes.patch
Parent Directory | Revision Log
Revision 2618 -
(hide annotations)
(download)
Mon Jul 13 08:29:10 2015 UTC (9 years, 2 months ago) by niro
File size: 249176 byte(s)
Mon Jul 13 08:29:10 2015 UTC (9 years, 2 months ago) by niro
File size: 249176 byte(s)
-linux-3.18.18
1 | niro | 2618 | diff --git a/Documentation/devicetree/bindings/net/marvell-armada-370-neta.txt b/Documentation/devicetree/bindings/net/marvell-armada-370-neta.txt |
2 | index 750d577e8083..f5a8ca29aff0 100644 | ||
3 | --- a/Documentation/devicetree/bindings/net/marvell-armada-370-neta.txt | ||
4 | +++ b/Documentation/devicetree/bindings/net/marvell-armada-370-neta.txt | ||
5 | @@ -1,7 +1,7 @@ | ||
6 | * Marvell Armada 370 / Armada XP Ethernet Controller (NETA) | ||
7 | |||
8 | Required properties: | ||
9 | -- compatible: should be "marvell,armada-370-neta". | ||
10 | +- compatible: "marvell,armada-370-neta" or "marvell,armada-xp-neta". | ||
11 | - reg: address and length of the register set for the device. | ||
12 | - interrupts: interrupt for the device | ||
13 | - phy: See ethernet.txt file in the same directory. | ||
14 | diff --git a/Documentation/devicetree/bindings/pinctrl/marvell,armada-370-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/marvell,armada-370-pinctrl.txt | ||
15 | index adda2a8d1d52..e357b020861d 100644 | ||
16 | --- a/Documentation/devicetree/bindings/pinctrl/marvell,armada-370-pinctrl.txt | ||
17 | +++ b/Documentation/devicetree/bindings/pinctrl/marvell,armada-370-pinctrl.txt | ||
18 | @@ -92,5 +92,5 @@ mpp61 61 gpo, dev(wen1), uart1(txd), audio(rclk) | ||
19 | mpp62 62 gpio, dev(a2), uart1(cts), tdm(drx), pcie(clkreq0), | ||
20 | audio(mclk), uart0(cts) | ||
21 | mpp63 63 gpo, spi0(sck), tclk | ||
22 | -mpp64 64 gpio, spi0(miso), spi0-1(cs1) | ||
23 | -mpp65 65 gpio, spi0(mosi), spi0-1(cs2) | ||
24 | +mpp64 64 gpio, spi0(miso), spi0(cs1) | ||
25 | +mpp65 65 gpio, spi0(mosi), spi0(cs2) | ||
26 | diff --git a/Documentation/devicetree/bindings/pinctrl/marvell,armada-375-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/marvell,armada-375-pinctrl.txt | ||
27 | index 7de0cda4a379..bedbe42c8c0a 100644 | ||
28 | --- a/Documentation/devicetree/bindings/pinctrl/marvell,armada-375-pinctrl.txt | ||
29 | +++ b/Documentation/devicetree/bindings/pinctrl/marvell,armada-375-pinctrl.txt | ||
30 | @@ -22,8 +22,8 @@ mpp5 5 gpio, dev(ad7), spi0(cs2), spi1(cs2) | ||
31 | mpp6 6 gpio, dev(ad0), led(p1), audio(rclk) | ||
32 | mpp7 7 gpio, dev(ad1), ptp(clk), led(p2), audio(extclk) | ||
33 | mpp8 8 gpio, dev (bootcs), spi0(cs0), spi1(cs0) | ||
34 | -mpp9 9 gpio, nf(wen), spi0(sck), spi1(sck) | ||
35 | -mpp10 10 gpio, nf(ren), dram(vttctrl), led(c1) | ||
36 | +mpp9 9 gpio, spi0(sck), spi1(sck), nand(we) | ||
37 | +mpp10 10 gpio, dram(vttctrl), led(c1), nand(re) | ||
38 | mpp11 11 gpio, dev(a0), led(c2), audio(sdo) | ||
39 | mpp12 12 gpio, dev(a1), audio(bclk) | ||
40 | mpp13 13 gpio, dev(readyn), pcie0(rstoutn), pcie1(rstoutn) | ||
41 | diff --git a/Documentation/devicetree/bindings/pinctrl/marvell,armada-38x-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/marvell,armada-38x-pinctrl.txt | ||
42 | index b17c96849fc9..4ac138aaaf87 100644 | ||
43 | --- a/Documentation/devicetree/bindings/pinctrl/marvell,armada-38x-pinctrl.txt | ||
44 | +++ b/Documentation/devicetree/bindings/pinctrl/marvell,armada-38x-pinctrl.txt | ||
45 | @@ -27,15 +27,15 @@ mpp8 8 gpio, ge0(txd1), dev(ad10) | ||
46 | mpp9 9 gpio, ge0(txd2), dev(ad11) | ||
47 | mpp10 10 gpio, ge0(txd3), dev(ad12) | ||
48 | mpp11 11 gpio, ge0(txctl), dev(ad13) | ||
49 | -mpp12 12 gpio, ge0(rxd0), pcie0(rstout), pcie1(rstout) [1], spi0(cs1), dev(ad14) | ||
50 | -mpp13 13 gpio, ge0(rxd1), pcie0(clkreq), pcie1(clkreq) [1], spi0(cs2), dev(ad15) | ||
51 | -mpp14 14 gpio, ge0(rxd2), ptp(clk), m(vtt_ctrl), spi0(cs3), dev(wen1) | ||
52 | -mpp15 15 gpio, ge0(rxd3), ge(mdc slave), pcie0(rstout), spi0(mosi), pcie1(rstout) [1] | ||
53 | -mpp16 16 gpio, ge0(rxctl), ge(mdio slave), m(decc_err), spi0(miso), pcie0(clkreq) | ||
54 | +mpp12 12 gpio, ge0(rxd0), pcie0(rstout), spi0(cs1), dev(ad14), pcie3(clkreq) | ||
55 | +mpp13 13 gpio, ge0(rxd1), pcie0(clkreq), pcie1(clkreq) [1], spi0(cs2), dev(ad15), pcie2(clkreq) | ||
56 | +mpp14 14 gpio, ge0(rxd2), ptp(clk), m(vtt_ctrl), spi0(cs3), dev(wen1), pcie3(clkreq) | ||
57 | +mpp15 15 gpio, ge0(rxd3), ge(mdc slave), pcie0(rstout), spi0(mosi) | ||
58 | +mpp16 16 gpio, ge0(rxctl), ge(mdio slave), m(decc_err), spi0(miso), pcie0(clkreq), pcie1(clkreq) [1] | ||
59 | mpp17 17 gpio, ge0(rxclk), ptp(clk), ua1(rxd), spi0(sck), sata1(prsnt) | ||
60 | -mpp18 18 gpio, ge0(rxerr), ptp(trig_gen), ua1(txd), spi0(cs0), pcie1(rstout) [1] | ||
61 | -mpp19 19 gpio, ge0(col), ptp(event_req), pcie0(clkreq), sata1(prsnt), ua0(cts) | ||
62 | -mpp20 20 gpio, ge0(txclk), ptp(clk), pcie1(rstout) [1], sata0(prsnt), ua0(rts) | ||
63 | +mpp18 18 gpio, ge0(rxerr), ptp(trig_gen), ua1(txd), spi0(cs0) | ||
64 | +mpp19 19 gpio, ge0(col), ptp(event_req), ge0(txerr), sata1(prsnt), ua0(cts) | ||
65 | +mpp20 20 gpio, ge0(txclk), ptp(clk), sata0(prsnt), ua0(rts) | ||
66 | mpp21 21 gpio, spi0(cs1), ge1(rxd0), sata0(prsnt), sd0(cmd), dev(bootcs) | ||
67 | mpp22 22 gpio, spi0(mosi), dev(ad0) | ||
68 | mpp23 23 gpio, spi0(sck), dev(ad2) | ||
69 | @@ -58,23 +58,23 @@ mpp39 39 gpio, i2c1(sck), ge1(rxd2), ua0(cts), sd0(d1), dev(a2) | ||
70 | mpp40 40 gpio, i2c1(sda), ge1(rxd3), ua0(rts), sd0(d2), dev(ad6) | ||
71 | mpp41 41 gpio, ua1(rxd), ge1(rxctl), ua0(cts), spi1(cs3), dev(burst/last) | ||
72 | mpp42 42 gpio, ua1(txd), ua0(rts), dev(ad7) | ||
73 | -mpp43 43 gpio, pcie0(clkreq), m(vtt_ctrl), m(decc_err), pcie0(rstout), dev(clkout) | ||
74 | -mpp44 44 gpio, sata0(prsnt), sata1(prsnt), sata2(prsnt) [2], sata3(prsnt) [3], pcie0(rstout) | ||
75 | -mpp45 45 gpio, ref(clk_out0), pcie0(rstout), pcie1(rstout) [1], pcie2(rstout), pcie3(rstout) | ||
76 | -mpp46 46 gpio, ref(clk_out1), pcie0(rstout), pcie1(rstout) [1], pcie2(rstout), pcie3(rstout) | ||
77 | -mpp47 47 gpio, sata0(prsnt), sata1(prsnt), sata2(prsnt) [2], spi1(cs2), sata3(prsnt) [2] | ||
78 | -mpp48 48 gpio, sata0(prsnt), m(vtt_ctrl), tdm2c(pclk), audio(mclk), sd0(d4) | ||
79 | -mpp49 49 gpio, sata2(prsnt) [2], sata3(prsnt) [2], tdm2c(fsync), audio(lrclk), sd0(d5) | ||
80 | -mpp50 50 gpio, pcie0(rstout), pcie1(rstout) [1], tdm2c(drx), audio(extclk), sd0(cmd) | ||
81 | +mpp43 43 gpio, pcie0(clkreq), m(vtt_ctrl), m(decc_err), spi1(cs2), dev(clkout) | ||
82 | +mpp44 44 gpio, sata0(prsnt), sata1(prsnt), sata2(prsnt) [2], sata3(prsnt) [3] | ||
83 | +mpp45 45 gpio, ref(clk_out0), pcie0(rstout) | ||
84 | +mpp46 46 gpio, ref(clk_out1), pcie0(rstout) | ||
85 | +mpp47 47 gpio, sata0(prsnt), sata1(prsnt), sata2(prsnt) [2], sata3(prsnt) [2] | ||
86 | +mpp48 48 gpio, sata0(prsnt), m(vtt_ctrl), tdm2c(pclk), audio(mclk), sd0(d4), pcie0(clkreq) | ||
87 | +mpp49 49 gpio, sata2(prsnt) [2], sata3(prsnt) [2], tdm2c(fsync), audio(lrclk), sd0(d5), pcie1(clkreq) | ||
88 | +mpp50 50 gpio, pcie0(rstout), tdm2c(drx), audio(extclk), sd0(cmd) | ||
89 | mpp51 51 gpio, tdm2c(dtx), audio(sdo), m(decc_err) | ||
90 | -mpp52 52 gpio, pcie0(rstout), pcie1(rstout) [1], tdm2c(intn), audio(sdi), sd0(d6) | ||
91 | +mpp52 52 gpio, pcie0(rstout), tdm2c(intn), audio(sdi), sd0(d6) | ||
92 | mpp53 53 gpio, sata1(prsnt), sata0(prsnt), tdm2c(rstn), audio(bclk), sd0(d7) | ||
93 | -mpp54 54 gpio, sata0(prsnt), sata1(prsnt), pcie0(rstout), pcie1(rstout) [1], sd0(d3) | ||
94 | +mpp54 54 gpio, sata0(prsnt), sata1(prsnt), pcie0(rstout), ge0(txerr), sd0(d3) | ||
95 | mpp55 55 gpio, ua1(cts), ge(mdio), pcie1(clkreq) [1], spi1(cs1), sd0(d0) | ||
96 | mpp56 56 gpio, ua1(rts), ge(mdc), m(decc_err), spi1(mosi) | ||
97 | mpp57 57 gpio, spi1(sck), sd0(clk) | ||
98 | mpp58 58 gpio, pcie1(clkreq) [1], i2c1(sck), pcie2(clkreq), spi1(miso), sd0(d1) | ||
99 | -mpp59 59 gpio, pcie0(rstout), i2c1(sda), pcie1(rstout) [1], spi1(cs0), sd0(d2) | ||
100 | +mpp59 59 gpio, pcie0(rstout), i2c1(sda), spi1(cs0), sd0(d2) | ||
101 | |||
102 | [1]: only available on 88F6820 and 88F6828 | ||
103 | [2]: only available on 88F6828 | ||
104 | diff --git a/Documentation/devicetree/bindings/pinctrl/marvell,armada-xp-pinctrl.txt b/Documentation/devicetree/bindings/pinctrl/marvell,armada-xp-pinctrl.txt | ||
105 | index 373dbccd7ab0..96e7744cab84 100644 | ||
106 | --- a/Documentation/devicetree/bindings/pinctrl/marvell,armada-xp-pinctrl.txt | ||
107 | +++ b/Documentation/devicetree/bindings/pinctrl/marvell,armada-xp-pinctrl.txt | ||
108 | @@ -42,15 +42,15 @@ mpp20 20 gpio, ge0(rxd4), ge1(rxd2), lcd(d20), ptp(clk) | ||
109 | mpp21 21 gpio, ge0(rxd5), ge1(rxd3), lcd(d21), mem(bat) | ||
110 | mpp22 22 gpio, ge0(rxd6), ge1(rxctl), lcd(d22), sata0(prsnt) | ||
111 | mpp23 23 gpio, ge0(rxd7), ge1(rxclk), lcd(d23), sata1(prsnt) | ||
112 | -mpp24 24 gpio, lcd(hsync), sata1(prsnt), nf(bootcs-re), tdm(rst) | ||
113 | -mpp25 25 gpio, lcd(vsync), sata0(prsnt), nf(bootcs-we), tdm(pclk) | ||
114 | -mpp26 26 gpio, lcd(clk), tdm(fsync), vdd(cpu1-pd) | ||
115 | +mpp24 24 gpio, lcd(hsync), sata1(prsnt), tdm(rst) | ||
116 | +mpp25 25 gpio, lcd(vsync), sata0(prsnt), tdm(pclk) | ||
117 | +mpp26 26 gpio, lcd(clk), tdm(fsync) | ||
118 | mpp27 27 gpio, lcd(e), tdm(dtx), ptp(trig) | ||
119 | mpp28 28 gpio, lcd(pwm), tdm(drx), ptp(evreq) | ||
120 | -mpp29 29 gpio, lcd(ref-clk), tdm(int0), ptp(clk), vdd(cpu0-pd) | ||
121 | +mpp29 29 gpio, lcd(ref-clk), tdm(int0), ptp(clk) | ||
122 | mpp30 30 gpio, tdm(int1), sd0(clk) | ||
123 | -mpp31 31 gpio, tdm(int2), sd0(cmd), vdd(cpu0-pd) | ||
124 | -mpp32 32 gpio, tdm(int3), sd0(d0), vdd(cpu1-pd) | ||
125 | +mpp31 31 gpio, tdm(int2), sd0(cmd) | ||
126 | +mpp32 32 gpio, tdm(int3), sd0(d0) | ||
127 | mpp33 33 gpio, tdm(int4), sd0(d1), mem(bat) | ||
128 | mpp34 34 gpio, tdm(int5), sd0(d2), sata0(prsnt) | ||
129 | mpp35 35 gpio, tdm(int6), sd0(d3), sata1(prsnt) | ||
130 | @@ -58,21 +58,18 @@ mpp36 36 gpio, spi(mosi) | ||
131 | mpp37 37 gpio, spi(miso) | ||
132 | mpp38 38 gpio, spi(sck) | ||
133 | mpp39 39 gpio, spi(cs0) | ||
134 | -mpp40 40 gpio, spi(cs1), uart2(cts), lcd(vga-hsync), vdd(cpu1-pd), | ||
135 | - pcie(clkreq0) | ||
136 | +mpp40 40 gpio, spi(cs1), uart2(cts), lcd(vga-hsync), pcie(clkreq0) | ||
137 | mpp41 41 gpio, spi(cs2), uart2(rts), lcd(vga-vsync), sata1(prsnt), | ||
138 | pcie(clkreq1) | ||
139 | -mpp42 42 gpio, uart2(rxd), uart0(cts), tdm(int7), tdm-1(timer), | ||
140 | - vdd(cpu0-pd) | ||
141 | -mpp43 43 gpio, uart2(txd), uart0(rts), spi(cs3), pcie(rstout), | ||
142 | - vdd(cpu2-3-pd){1} | ||
143 | +mpp42 42 gpio, uart2(rxd), uart0(cts), tdm(int7), tdm-1(timer) | ||
144 | +mpp43 43 gpio, uart2(txd), uart0(rts), spi(cs3), pcie(rstout) | ||
145 | mpp44 44 gpio, uart2(cts), uart3(rxd), spi(cs4), pcie(clkreq2), | ||
146 | mem(bat) | ||
147 | mpp45 45 gpio, uart2(rts), uart3(txd), spi(cs5), sata1(prsnt) | ||
148 | mpp46 46 gpio, uart3(rts), uart1(rts), spi(cs6), sata0(prsnt) | ||
149 | mpp47 47 gpio, uart3(cts), uart1(cts), spi(cs7), pcie(clkreq3), | ||
150 | ref(clkout) | ||
151 | -mpp48 48 gpio, tclk, dev(burst/last) | ||
152 | +mpp48 48 gpio, dev(clkout), dev(burst/last) | ||
153 | |||
154 | * Marvell Armada XP (mv78260 and mv78460 only) | ||
155 | |||
156 | @@ -84,9 +81,9 @@ mpp51 51 gpio, dev(ad16) | ||
157 | mpp52 52 gpio, dev(ad17) | ||
158 | mpp53 53 gpio, dev(ad18) | ||
159 | mpp54 54 gpio, dev(ad19) | ||
160 | -mpp55 55 gpio, dev(ad20), vdd(cpu0-pd) | ||
161 | -mpp56 56 gpio, dev(ad21), vdd(cpu1-pd) | ||
162 | -mpp57 57 gpio, dev(ad22), vdd(cpu2-3-pd){1} | ||
163 | +mpp55 55 gpio, dev(ad20) | ||
164 | +mpp56 56 gpio, dev(ad21) | ||
165 | +mpp57 57 gpio, dev(ad22) | ||
166 | mpp58 58 gpio, dev(ad23) | ||
167 | mpp59 59 gpio, dev(ad24) | ||
168 | mpp60 60 gpio, dev(ad25) | ||
169 | @@ -96,6 +93,3 @@ mpp63 63 gpio, dev(ad28) | ||
170 | mpp64 64 gpio, dev(ad29) | ||
171 | mpp65 65 gpio, dev(ad30) | ||
172 | mpp66 66 gpio, dev(ad31) | ||
173 | - | ||
174 | -Notes: | ||
175 | -* {1} vdd(cpu2-3-pd) only available on mv78460. | ||
176 | diff --git a/Documentation/stable_kernel_rules.txt b/Documentation/stable_kernel_rules.txt | ||
177 | index 58d0ac4df946..3049a612291b 100644 | ||
178 | --- a/Documentation/stable_kernel_rules.txt | ||
179 | +++ b/Documentation/stable_kernel_rules.txt | ||
180 | @@ -59,11 +59,20 @@ For all other submissions, choose one of the following procedures: | ||
181 | changelog of your submission, as well as the kernel version you wish | ||
182 | it to be applied to. | ||
183 | |||
184 | -Option 1 is probably the easiest and most common. Options 2 and 3 are more | ||
185 | -useful if the patch isn't deemed worthy at the time it is applied to a public | ||
186 | -git tree (for instance, because it deserves more regression testing first). | ||
187 | -Option 3 is especially useful if the patch needs some special handling to apply | ||
188 | -to an older kernel (e.g., if API's have changed in the meantime). | ||
189 | +Option 1 is *strongly* preferred, is the easiest and most common. Options 2 and | ||
190 | +3 are more useful if the patch isn't deemed worthy at the time it is applied to | ||
191 | +a public git tree (for instance, because it deserves more regression testing | ||
192 | +first). Option 3 is especially useful if the patch needs some special handling | ||
193 | +to apply to an older kernel (e.g., if API's have changed in the meantime). | ||
194 | + | ||
195 | +Note that for Option 3, if the patch deviates from the original upstream patch | ||
196 | +(for example because it had to be backported) this must be very clearly | ||
197 | +documented and justified in the patch description. | ||
198 | + | ||
199 | +The upstream commit ID must be specified with a separate line above the commit | ||
200 | +text, like this: | ||
201 | + | ||
202 | + commit <sha1> upstream. | ||
203 | |||
204 | Additionally, some patches submitted via Option 1 may have additional patch | ||
205 | prerequisites which can be cherry-picked. This can be specified in the following | ||
206 | diff --git a/Makefile b/Makefile | ||
207 | index 95ee52f9432e..35faaf8fb651 100644 | ||
208 | --- a/Makefile | ||
209 | +++ b/Makefile | ||
210 | @@ -1,6 +1,6 @@ | ||
211 | VERSION = 3 | ||
212 | PATCHLEVEL = 18 | ||
213 | -SUBLEVEL = 17 | ||
214 | +SUBLEVEL = 18 | ||
215 | EXTRAVERSION = | ||
216 | NAME = Diseased Newt | ||
217 | |||
218 | diff --git a/arch/arc/include/asm/atomic.h b/arch/arc/include/asm/atomic.h | ||
219 | index 9917a45fc430..20b7dc17979e 100644 | ||
220 | --- a/arch/arc/include/asm/atomic.h | ||
221 | +++ b/arch/arc/include/asm/atomic.h | ||
222 | @@ -43,6 +43,12 @@ static inline int atomic_##op##_return(int i, atomic_t *v) \ | ||
223 | { \ | ||
224 | unsigned int temp; \ | ||
225 | \ | ||
226 | + /* \ | ||
227 | + * Explicit full memory barrier needed before/after as \ | ||
228 | + * LLOCK/SCOND thmeselves don't provide any such semantics \ | ||
229 | + */ \ | ||
230 | + smp_mb(); \ | ||
231 | + \ | ||
232 | __asm__ __volatile__( \ | ||
233 | "1: llock %0, [%1] \n" \ | ||
234 | " " #asm_op " %0, %0, %2 \n" \ | ||
235 | @@ -52,6 +58,8 @@ static inline int atomic_##op##_return(int i, atomic_t *v) \ | ||
236 | : "r"(&v->counter), "ir"(i) \ | ||
237 | : "cc"); \ | ||
238 | \ | ||
239 | + smp_mb(); \ | ||
240 | + \ | ||
241 | return temp; \ | ||
242 | } | ||
243 | |||
244 | @@ -105,6 +113,9 @@ static inline int atomic_##op##_return(int i, atomic_t *v) \ | ||
245 | unsigned long flags; \ | ||
246 | unsigned long temp; \ | ||
247 | \ | ||
248 | + /* \ | ||
249 | + * spin lock/unlock provides the needed smp_mb() before/after \ | ||
250 | + */ \ | ||
251 | atomic_ops_lock(flags); \ | ||
252 | temp = v->counter; \ | ||
253 | temp c_op i; \ | ||
254 | @@ -142,9 +153,19 @@ ATOMIC_OP(and, &=, and) | ||
255 | #define __atomic_add_unless(v, a, u) \ | ||
256 | ({ \ | ||
257 | int c, old; \ | ||
258 | + \ | ||
259 | + /* \ | ||
260 | + * Explicit full memory barrier needed before/after as \ | ||
261 | + * LLOCK/SCOND thmeselves don't provide any such semantics \ | ||
262 | + */ \ | ||
263 | + smp_mb(); \ | ||
264 | + \ | ||
265 | c = atomic_read(v); \ | ||
266 | while (c != (u) && (old = atomic_cmpxchg((v), c, c + (a))) != c)\ | ||
267 | c = old; \ | ||
268 | + \ | ||
269 | + smp_mb(); \ | ||
270 | + \ | ||
271 | c; \ | ||
272 | }) | ||
273 | |||
274 | diff --git a/arch/arc/include/asm/bitops.h b/arch/arc/include/asm/bitops.h | ||
275 | index 1a5bf07eefe2..89fbbb0db51b 100644 | ||
276 | --- a/arch/arc/include/asm/bitops.h | ||
277 | +++ b/arch/arc/include/asm/bitops.h | ||
278 | @@ -103,6 +103,12 @@ static inline int test_and_set_bit(unsigned long nr, volatile unsigned long *m) | ||
279 | if (__builtin_constant_p(nr)) | ||
280 | nr &= 0x1f; | ||
281 | |||
282 | + /* | ||
283 | + * Explicit full memory barrier needed before/after as | ||
284 | + * LLOCK/SCOND themselves don't provide any such semantics | ||
285 | + */ | ||
286 | + smp_mb(); | ||
287 | + | ||
288 | __asm__ __volatile__( | ||
289 | "1: llock %0, [%2] \n" | ||
290 | " bset %1, %0, %3 \n" | ||
291 | @@ -112,6 +118,8 @@ static inline int test_and_set_bit(unsigned long nr, volatile unsigned long *m) | ||
292 | : "r"(m), "ir"(nr) | ||
293 | : "cc"); | ||
294 | |||
295 | + smp_mb(); | ||
296 | + | ||
297 | return (old & (1 << nr)) != 0; | ||
298 | } | ||
299 | |||
300 | @@ -125,6 +133,8 @@ test_and_clear_bit(unsigned long nr, volatile unsigned long *m) | ||
301 | if (__builtin_constant_p(nr)) | ||
302 | nr &= 0x1f; | ||
303 | |||
304 | + smp_mb(); | ||
305 | + | ||
306 | __asm__ __volatile__( | ||
307 | "1: llock %0, [%2] \n" | ||
308 | " bclr %1, %0, %3 \n" | ||
309 | @@ -134,6 +144,8 @@ test_and_clear_bit(unsigned long nr, volatile unsigned long *m) | ||
310 | : "r"(m), "ir"(nr) | ||
311 | : "cc"); | ||
312 | |||
313 | + smp_mb(); | ||
314 | + | ||
315 | return (old & (1 << nr)) != 0; | ||
316 | } | ||
317 | |||
318 | @@ -147,6 +159,8 @@ test_and_change_bit(unsigned long nr, volatile unsigned long *m) | ||
319 | if (__builtin_constant_p(nr)) | ||
320 | nr &= 0x1f; | ||
321 | |||
322 | + smp_mb(); | ||
323 | + | ||
324 | __asm__ __volatile__( | ||
325 | "1: llock %0, [%2] \n" | ||
326 | " bxor %1, %0, %3 \n" | ||
327 | @@ -156,6 +170,8 @@ test_and_change_bit(unsigned long nr, volatile unsigned long *m) | ||
328 | : "r"(m), "ir"(nr) | ||
329 | : "cc"); | ||
330 | |||
331 | + smp_mb(); | ||
332 | + | ||
333 | return (old & (1 << nr)) != 0; | ||
334 | } | ||
335 | |||
336 | @@ -235,6 +251,9 @@ static inline int test_and_set_bit(unsigned long nr, volatile unsigned long *m) | ||
337 | if (__builtin_constant_p(nr)) | ||
338 | nr &= 0x1f; | ||
339 | |||
340 | + /* | ||
341 | + * spin lock/unlock provide the needed smp_mb() before/after | ||
342 | + */ | ||
343 | bitops_lock(flags); | ||
344 | |||
345 | old = *m; | ||
346 | diff --git a/arch/arc/include/asm/cmpxchg.h b/arch/arc/include/asm/cmpxchg.h | ||
347 | index 03cd6894855d..44fd531f4d7b 100644 | ||
348 | --- a/arch/arc/include/asm/cmpxchg.h | ||
349 | +++ b/arch/arc/include/asm/cmpxchg.h | ||
350 | @@ -10,6 +10,8 @@ | ||
351 | #define __ASM_ARC_CMPXCHG_H | ||
352 | |||
353 | #include <linux/types.h> | ||
354 | + | ||
355 | +#include <asm/barrier.h> | ||
356 | #include <asm/smp.h> | ||
357 | |||
358 | #ifdef CONFIG_ARC_HAS_LLSC | ||
359 | @@ -19,16 +21,25 @@ __cmpxchg(volatile void *ptr, unsigned long expected, unsigned long new) | ||
360 | { | ||
361 | unsigned long prev; | ||
362 | |||
363 | + /* | ||
364 | + * Explicit full memory barrier needed before/after as | ||
365 | + * LLOCK/SCOND thmeselves don't provide any such semantics | ||
366 | + */ | ||
367 | + smp_mb(); | ||
368 | + | ||
369 | __asm__ __volatile__( | ||
370 | "1: llock %0, [%1] \n" | ||
371 | " brne %0, %2, 2f \n" | ||
372 | " scond %3, [%1] \n" | ||
373 | " bnz 1b \n" | ||
374 | "2: \n" | ||
375 | - : "=&r"(prev) | ||
376 | - : "r"(ptr), "ir"(expected), | ||
377 | - "r"(new) /* can't be "ir". scond can't take limm for "b" */ | ||
378 | - : "cc"); | ||
379 | + : "=&r"(prev) /* Early clobber, to prevent reg reuse */ | ||
380 | + : "r"(ptr), /* Not "m": llock only supports reg direct addr mode */ | ||
381 | + "ir"(expected), | ||
382 | + "r"(new) /* can't be "ir". scond can't take LIMM for "b" */ | ||
383 | + : "cc", "memory"); /* so that gcc knows memory is being written here */ | ||
384 | + | ||
385 | + smp_mb(); | ||
386 | |||
387 | return prev; | ||
388 | } | ||
389 | @@ -42,6 +53,9 @@ __cmpxchg(volatile void *ptr, unsigned long expected, unsigned long new) | ||
390 | int prev; | ||
391 | volatile unsigned long *p = ptr; | ||
392 | |||
393 | + /* | ||
394 | + * spin lock/unlock provide the needed smp_mb() before/after | ||
395 | + */ | ||
396 | atomic_ops_lock(flags); | ||
397 | prev = *p; | ||
398 | if (prev == expected) | ||
399 | @@ -77,12 +91,16 @@ static inline unsigned long __xchg(unsigned long val, volatile void *ptr, | ||
400 | |||
401 | switch (size) { | ||
402 | case 4: | ||
403 | + smp_mb(); | ||
404 | + | ||
405 | __asm__ __volatile__( | ||
406 | " ex %0, [%1] \n" | ||
407 | : "+r"(val) | ||
408 | : "r"(ptr) | ||
409 | : "memory"); | ||
410 | |||
411 | + smp_mb(); | ||
412 | + | ||
413 | return val; | ||
414 | } | ||
415 | return __xchg_bad_pointer(); | ||
416 | diff --git a/arch/arc/include/asm/spinlock.h b/arch/arc/include/asm/spinlock.h | ||
417 | index b6a8c2dfbe6e..e1651df6a93d 100644 | ||
418 | --- a/arch/arc/include/asm/spinlock.h | ||
419 | +++ b/arch/arc/include/asm/spinlock.h | ||
420 | @@ -22,24 +22,46 @@ static inline void arch_spin_lock(arch_spinlock_t *lock) | ||
421 | { | ||
422 | unsigned int tmp = __ARCH_SPIN_LOCK_LOCKED__; | ||
423 | |||
424 | + /* | ||
425 | + * This smp_mb() is technically superfluous, we only need the one | ||
426 | + * after the lock for providing the ACQUIRE semantics. | ||
427 | + * However doing the "right" thing was regressing hackbench | ||
428 | + * so keeping this, pending further investigation | ||
429 | + */ | ||
430 | + smp_mb(); | ||
431 | + | ||
432 | __asm__ __volatile__( | ||
433 | "1: ex %0, [%1] \n" | ||
434 | " breq %0, %2, 1b \n" | ||
435 | : "+&r" (tmp) | ||
436 | : "r"(&(lock->slock)), "ir"(__ARCH_SPIN_LOCK_LOCKED__) | ||
437 | : "memory"); | ||
438 | + | ||
439 | + /* | ||
440 | + * ACQUIRE barrier to ensure load/store after taking the lock | ||
441 | + * don't "bleed-up" out of the critical section (leak-in is allowed) | ||
442 | + * http://www.spinics.net/lists/kernel/msg2010409.html | ||
443 | + * | ||
444 | + * ARCv2 only has load-load, store-store and all-all barrier | ||
445 | + * thus need the full all-all barrier | ||
446 | + */ | ||
447 | + smp_mb(); | ||
448 | } | ||
449 | |||
450 | static inline int arch_spin_trylock(arch_spinlock_t *lock) | ||
451 | { | ||
452 | unsigned int tmp = __ARCH_SPIN_LOCK_LOCKED__; | ||
453 | |||
454 | + smp_mb(); | ||
455 | + | ||
456 | __asm__ __volatile__( | ||
457 | "1: ex %0, [%1] \n" | ||
458 | : "+r" (tmp) | ||
459 | : "r"(&(lock->slock)) | ||
460 | : "memory"); | ||
461 | |||
462 | + smp_mb(); | ||
463 | + | ||
464 | return (tmp == __ARCH_SPIN_LOCK_UNLOCKED__); | ||
465 | } | ||
466 | |||
467 | @@ -47,12 +69,22 @@ static inline void arch_spin_unlock(arch_spinlock_t *lock) | ||
468 | { | ||
469 | unsigned int tmp = __ARCH_SPIN_LOCK_UNLOCKED__; | ||
470 | |||
471 | + /* | ||
472 | + * RELEASE barrier: given the instructions avail on ARCv2, full barrier | ||
473 | + * is the only option | ||
474 | + */ | ||
475 | + smp_mb(); | ||
476 | + | ||
477 | __asm__ __volatile__( | ||
478 | " ex %0, [%1] \n" | ||
479 | : "+r" (tmp) | ||
480 | : "r"(&(lock->slock)) | ||
481 | : "memory"); | ||
482 | |||
483 | + /* | ||
484 | + * superfluous, but keeping for now - see pairing version in | ||
485 | + * arch_spin_lock above | ||
486 | + */ | ||
487 | smp_mb(); | ||
488 | } | ||
489 | |||
490 | diff --git a/arch/arm/boot/dts/armada-370-xp.dtsi b/arch/arm/boot/dts/armada-370-xp.dtsi | ||
491 | index 83286ec9702c..84366cddaa8e 100644 | ||
492 | --- a/arch/arm/boot/dts/armada-370-xp.dtsi | ||
493 | +++ b/arch/arm/boot/dts/armada-370-xp.dtsi | ||
494 | @@ -225,7 +225,6 @@ | ||
495 | }; | ||
496 | |||
497 | eth0: ethernet@70000 { | ||
498 | - compatible = "marvell,armada-370-neta"; | ||
499 | reg = <0x70000 0x4000>; | ||
500 | interrupts = <8>; | ||
501 | clocks = <&gateclk 4>; | ||
502 | @@ -241,7 +240,6 @@ | ||
503 | }; | ||
504 | |||
505 | eth1: ethernet@74000 { | ||
506 | - compatible = "marvell,armada-370-neta"; | ||
507 | reg = <0x74000 0x4000>; | ||
508 | interrupts = <10>; | ||
509 | clocks = <&gateclk 3>; | ||
510 | diff --git a/arch/arm/boot/dts/armada-370.dtsi b/arch/arm/boot/dts/armada-370.dtsi | ||
511 | index 7513410f7b89..b6e02689c61b 100644 | ||
512 | --- a/arch/arm/boot/dts/armada-370.dtsi | ||
513 | +++ b/arch/arm/boot/dts/armada-370.dtsi | ||
514 | @@ -302,6 +302,14 @@ | ||
515 | dmacap,memset; | ||
516 | }; | ||
517 | }; | ||
518 | + | ||
519 | + ethernet@70000 { | ||
520 | + compatible = "marvell,armada-370-neta"; | ||
521 | + }; | ||
522 | + | ||
523 | + ethernet@74000 { | ||
524 | + compatible = "marvell,armada-370-neta"; | ||
525 | + }; | ||
526 | }; | ||
527 | }; | ||
528 | }; | ||
529 | diff --git a/arch/arm/boot/dts/armada-xp-mv78260.dtsi b/arch/arm/boot/dts/armada-xp-mv78260.dtsi | ||
530 | index 480e237a870f..677160effbb0 100644 | ||
531 | --- a/arch/arm/boot/dts/armada-xp-mv78260.dtsi | ||
532 | +++ b/arch/arm/boot/dts/armada-xp-mv78260.dtsi | ||
533 | @@ -296,7 +296,7 @@ | ||
534 | }; | ||
535 | |||
536 | eth3: ethernet@34000 { | ||
537 | - compatible = "marvell,armada-370-neta"; | ||
538 | + compatible = "marvell,armada-xp-neta"; | ||
539 | reg = <0x34000 0x4000>; | ||
540 | interrupts = <14>; | ||
541 | clocks = <&gateclk 1>; | ||
542 | diff --git a/arch/arm/boot/dts/armada-xp-mv78460.dtsi b/arch/arm/boot/dts/armada-xp-mv78460.dtsi | ||
543 | index 2c7b1fef4703..e143776b78ec 100644 | ||
544 | --- a/arch/arm/boot/dts/armada-xp-mv78460.dtsi | ||
545 | +++ b/arch/arm/boot/dts/armada-xp-mv78460.dtsi | ||
546 | @@ -334,7 +334,7 @@ | ||
547 | }; | ||
548 | |||
549 | eth3: ethernet@34000 { | ||
550 | - compatible = "marvell,armada-370-neta"; | ||
551 | + compatible = "marvell,armada-xp-neta"; | ||
552 | reg = <0x34000 0x4000>; | ||
553 | interrupts = <14>; | ||
554 | clocks = <&gateclk 1>; | ||
555 | diff --git a/arch/arm/boot/dts/armada-xp.dtsi b/arch/arm/boot/dts/armada-xp.dtsi | ||
556 | index bff9f6c18db1..66d25b788067 100644 | ||
557 | --- a/arch/arm/boot/dts/armada-xp.dtsi | ||
558 | +++ b/arch/arm/boot/dts/armada-xp.dtsi | ||
559 | @@ -125,7 +125,7 @@ | ||
560 | }; | ||
561 | |||
562 | eth2: ethernet@30000 { | ||
563 | - compatible = "marvell,armada-370-neta"; | ||
564 | + compatible = "marvell,armada-xp-neta"; | ||
565 | reg = <0x30000 0x4000>; | ||
566 | interrupts = <12>; | ||
567 | clocks = <&gateclk 2>; | ||
568 | @@ -168,6 +168,14 @@ | ||
569 | }; | ||
570 | }; | ||
571 | |||
572 | + ethernet@70000 { | ||
573 | + compatible = "marvell,armada-xp-neta"; | ||
574 | + }; | ||
575 | + | ||
576 | + ethernet@74000 { | ||
577 | + compatible = "marvell,armada-xp-neta"; | ||
578 | + }; | ||
579 | + | ||
580 | xor@f0900 { | ||
581 | compatible = "marvell,orion-xor"; | ||
582 | reg = <0xF0900 0x100 | ||
583 | diff --git a/arch/arm/boot/dts/at91-sama5d4ek.dts b/arch/arm/boot/dts/at91-sama5d4ek.dts | ||
584 | index b5b84006469e..d7f6ae4e5b98 100644 | ||
585 | --- a/arch/arm/boot/dts/at91-sama5d4ek.dts | ||
586 | +++ b/arch/arm/boot/dts/at91-sama5d4ek.dts | ||
587 | @@ -108,8 +108,8 @@ | ||
588 | mmc0: mmc@f8000000 { | ||
589 | pinctrl-names = "default"; | ||
590 | pinctrl-0 = <&pinctrl_mmc0_clk_cmd_dat0 &pinctrl_mmc0_dat1_3 &pinctrl_mmc0_cd>; | ||
591 | - slot@1 { | ||
592 | - reg = <1>; | ||
593 | + slot@0 { | ||
594 | + reg = <0>; | ||
595 | bus-width = <4>; | ||
596 | cd-gpios = <&pioE 5 0>; | ||
597 | }; | ||
598 | diff --git a/arch/arm/kvm/psci.c b/arch/arm/kvm/psci.c | ||
599 | index 58cb3248d277..4d0d89e342f9 100644 | ||
600 | --- a/arch/arm/kvm/psci.c | ||
601 | +++ b/arch/arm/kvm/psci.c | ||
602 | @@ -237,10 +237,6 @@ static int kvm_psci_0_2_call(struct kvm_vcpu *vcpu) | ||
603 | case PSCI_0_2_FN64_AFFINITY_INFO: | ||
604 | val = kvm_psci_vcpu_affinity_info(vcpu); | ||
605 | break; | ||
606 | - case PSCI_0_2_FN_MIGRATE: | ||
607 | - case PSCI_0_2_FN64_MIGRATE: | ||
608 | - val = PSCI_RET_NOT_SUPPORTED; | ||
609 | - break; | ||
610 | case PSCI_0_2_FN_MIGRATE_INFO_TYPE: | ||
611 | /* | ||
612 | * Trusted OS is MP hence does not require migration | ||
613 | @@ -249,10 +245,6 @@ static int kvm_psci_0_2_call(struct kvm_vcpu *vcpu) | ||
614 | */ | ||
615 | val = PSCI_0_2_TOS_MP; | ||
616 | break; | ||
617 | - case PSCI_0_2_FN_MIGRATE_INFO_UP_CPU: | ||
618 | - case PSCI_0_2_FN64_MIGRATE_INFO_UP_CPU: | ||
619 | - val = PSCI_RET_NOT_SUPPORTED; | ||
620 | - break; | ||
621 | case PSCI_0_2_FN_SYSTEM_OFF: | ||
622 | kvm_psci_system_off(vcpu); | ||
623 | /* | ||
624 | @@ -278,7 +270,8 @@ static int kvm_psci_0_2_call(struct kvm_vcpu *vcpu) | ||
625 | ret = 0; | ||
626 | break; | ||
627 | default: | ||
628 | - return -EINVAL; | ||
629 | + val = PSCI_RET_NOT_SUPPORTED; | ||
630 | + break; | ||
631 | } | ||
632 | |||
633 | *vcpu_reg(vcpu, 0) = val; | ||
634 | @@ -298,12 +291,9 @@ static int kvm_psci_0_1_call(struct kvm_vcpu *vcpu) | ||
635 | case KVM_PSCI_FN_CPU_ON: | ||
636 | val = kvm_psci_vcpu_on(vcpu); | ||
637 | break; | ||
638 | - case KVM_PSCI_FN_CPU_SUSPEND: | ||
639 | - case KVM_PSCI_FN_MIGRATE: | ||
640 | + default: | ||
641 | val = PSCI_RET_NOT_SUPPORTED; | ||
642 | break; | ||
643 | - default: | ||
644 | - return -EINVAL; | ||
645 | } | ||
646 | |||
647 | *vcpu_reg(vcpu, 0) = val; | ||
648 | diff --git a/arch/arm/mach-tegra/cpuidle-tegra20.c b/arch/arm/mach-tegra/cpuidle-tegra20.c | ||
649 | index b30bf5cba65b..f209e9c507e2 100644 | ||
650 | --- a/arch/arm/mach-tegra/cpuidle-tegra20.c | ||
651 | +++ b/arch/arm/mach-tegra/cpuidle-tegra20.c | ||
652 | @@ -35,6 +35,7 @@ | ||
653 | #include "iomap.h" | ||
654 | #include "irq.h" | ||
655 | #include "pm.h" | ||
656 | +#include "reset.h" | ||
657 | #include "sleep.h" | ||
658 | |||
659 | #ifdef CONFIG_PM_SLEEP | ||
660 | @@ -72,15 +73,13 @@ static struct cpuidle_driver tegra_idle_driver = { | ||
661 | |||
662 | #ifdef CONFIG_PM_SLEEP | ||
663 | #ifdef CONFIG_SMP | ||
664 | -static void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE); | ||
665 | - | ||
666 | static int tegra20_reset_sleeping_cpu_1(void) | ||
667 | { | ||
668 | int ret = 0; | ||
669 | |||
670 | tegra_pen_lock(); | ||
671 | |||
672 | - if (readl(pmc + PMC_SCRATCH41) == CPU_RESETTABLE) | ||
673 | + if (readb(tegra20_cpu1_resettable_status) == CPU_RESETTABLE) | ||
674 | tegra20_cpu_shutdown(1); | ||
675 | else | ||
676 | ret = -EINVAL; | ||
677 | diff --git a/arch/arm/mach-tegra/reset-handler.S b/arch/arm/mach-tegra/reset-handler.S | ||
678 | index 71be4af5e975..e3070fdab80b 100644 | ||
679 | --- a/arch/arm/mach-tegra/reset-handler.S | ||
680 | +++ b/arch/arm/mach-tegra/reset-handler.S | ||
681 | @@ -169,10 +169,10 @@ after_errata: | ||
682 | cmp r6, #TEGRA20 | ||
683 | bne 1f | ||
684 | /* If not CPU0, don't let CPU0 reset CPU1 now that CPU1 is coming up. */ | ||
685 | - mov32 r5, TEGRA_PMC_BASE | ||
686 | - mov r0, #0 | ||
687 | + mov32 r5, TEGRA_IRAM_BASE + TEGRA_IRAM_RESET_HANDLER_OFFSET | ||
688 | + mov r0, #CPU_NOT_RESETTABLE | ||
689 | cmp r10, #0 | ||
690 | - strne r0, [r5, #PMC_SCRATCH41] | ||
691 | + strneb r0, [r5, #__tegra20_cpu1_resettable_status_offset] | ||
692 | 1: | ||
693 | #endif | ||
694 | |||
695 | @@ -281,6 +281,10 @@ __tegra_cpu_reset_handler_data: | ||
696 | .rept TEGRA_RESET_DATA_SIZE | ||
697 | .long 0 | ||
698 | .endr | ||
699 | + .globl __tegra20_cpu1_resettable_status_offset | ||
700 | + .equ __tegra20_cpu1_resettable_status_offset, \ | ||
701 | + . - __tegra_cpu_reset_handler_start | ||
702 | + .byte 0 | ||
703 | .align L1_CACHE_SHIFT | ||
704 | |||
705 | ENTRY(__tegra_cpu_reset_handler_end) | ||
706 | diff --git a/arch/arm/mach-tegra/reset.h b/arch/arm/mach-tegra/reset.h | ||
707 | index 76a93434c6ee..29c3dec0126a 100644 | ||
708 | --- a/arch/arm/mach-tegra/reset.h | ||
709 | +++ b/arch/arm/mach-tegra/reset.h | ||
710 | @@ -35,6 +35,7 @@ extern unsigned long __tegra_cpu_reset_handler_data[TEGRA_RESET_DATA_SIZE]; | ||
711 | |||
712 | void __tegra_cpu_reset_handler_start(void); | ||
713 | void __tegra_cpu_reset_handler(void); | ||
714 | +void __tegra20_cpu1_resettable_status_offset(void); | ||
715 | void __tegra_cpu_reset_handler_end(void); | ||
716 | void tegra_secondary_startup(void); | ||
717 | |||
718 | @@ -47,6 +48,9 @@ void tegra_secondary_startup(void); | ||
719 | (IO_ADDRESS(TEGRA_IRAM_BASE + TEGRA_IRAM_RESET_HANDLER_OFFSET + \ | ||
720 | ((u32)&__tegra_cpu_reset_handler_data[TEGRA_RESET_MASK_LP2] - \ | ||
721 | (u32)__tegra_cpu_reset_handler_start))) | ||
722 | +#define tegra20_cpu1_resettable_status \ | ||
723 | + (IO_ADDRESS(TEGRA_IRAM_BASE + TEGRA_IRAM_RESET_HANDLER_OFFSET + \ | ||
724 | + (u32)__tegra20_cpu1_resettable_status_offset)) | ||
725 | #endif | ||
726 | |||
727 | #define tegra_cpu_reset_handler_offset \ | ||
728 | diff --git a/arch/arm/mach-tegra/sleep-tegra20.S b/arch/arm/mach-tegra/sleep-tegra20.S | ||
729 | index be4bc5f853f5..e6b684e14322 100644 | ||
730 | --- a/arch/arm/mach-tegra/sleep-tegra20.S | ||
731 | +++ b/arch/arm/mach-tegra/sleep-tegra20.S | ||
732 | @@ -97,9 +97,10 @@ ENDPROC(tegra20_hotplug_shutdown) | ||
733 | ENTRY(tegra20_cpu_shutdown) | ||
734 | cmp r0, #0 | ||
735 | reteq lr @ must not be called for CPU 0 | ||
736 | - mov32 r1, TEGRA_PMC_VIRT + PMC_SCRATCH41 | ||
737 | + mov32 r1, TEGRA_IRAM_RESET_BASE_VIRT | ||
738 | + ldr r2, =__tegra20_cpu1_resettable_status_offset | ||
739 | mov r12, #CPU_RESETTABLE | ||
740 | - str r12, [r1] | ||
741 | + strb r12, [r1, r2] | ||
742 | |||
743 | cpu_to_halt_reg r1, r0 | ||
744 | ldr r3, =TEGRA_FLOW_CTRL_VIRT | ||
745 | @@ -182,38 +183,41 @@ ENDPROC(tegra_pen_unlock) | ||
746 | /* | ||
747 | * tegra20_cpu_clear_resettable(void) | ||
748 | * | ||
749 | - * Called to clear the "resettable soon" flag in PMC_SCRATCH41 when | ||
750 | + * Called to clear the "resettable soon" flag in IRAM variable when | ||
751 | * it is expected that the secondary CPU will be idle soon. | ||
752 | */ | ||
753 | ENTRY(tegra20_cpu_clear_resettable) | ||
754 | - mov32 r1, TEGRA_PMC_VIRT + PMC_SCRATCH41 | ||
755 | + mov32 r1, TEGRA_IRAM_RESET_BASE_VIRT | ||
756 | + ldr r2, =__tegra20_cpu1_resettable_status_offset | ||
757 | mov r12, #CPU_NOT_RESETTABLE | ||
758 | - str r12, [r1] | ||
759 | + strb r12, [r1, r2] | ||
760 | ret lr | ||
761 | ENDPROC(tegra20_cpu_clear_resettable) | ||
762 | |||
763 | /* | ||
764 | * tegra20_cpu_set_resettable_soon(void) | ||
765 | * | ||
766 | - * Called to set the "resettable soon" flag in PMC_SCRATCH41 when | ||
767 | + * Called to set the "resettable soon" flag in IRAM variable when | ||
768 | * it is expected that the secondary CPU will be idle soon. | ||
769 | */ | ||
770 | ENTRY(tegra20_cpu_set_resettable_soon) | ||
771 | - mov32 r1, TEGRA_PMC_VIRT + PMC_SCRATCH41 | ||
772 | + mov32 r1, TEGRA_IRAM_RESET_BASE_VIRT | ||
773 | + ldr r2, =__tegra20_cpu1_resettable_status_offset | ||
774 | mov r12, #CPU_RESETTABLE_SOON | ||
775 | - str r12, [r1] | ||
776 | + strb r12, [r1, r2] | ||
777 | ret lr | ||
778 | ENDPROC(tegra20_cpu_set_resettable_soon) | ||
779 | |||
780 | /* | ||
781 | * tegra20_cpu_is_resettable_soon(void) | ||
782 | * | ||
783 | - * Returns true if the "resettable soon" flag in PMC_SCRATCH41 has been | ||
784 | + * Returns true if the "resettable soon" flag in IRAM variable has been | ||
785 | * set because it is expected that the secondary CPU will be idle soon. | ||
786 | */ | ||
787 | ENTRY(tegra20_cpu_is_resettable_soon) | ||
788 | - mov32 r1, TEGRA_PMC_VIRT + PMC_SCRATCH41 | ||
789 | - ldr r12, [r1] | ||
790 | + mov32 r1, TEGRA_IRAM_RESET_BASE_VIRT | ||
791 | + ldr r2, =__tegra20_cpu1_resettable_status_offset | ||
792 | + ldrb r12, [r1, r2] | ||
793 | cmp r12, #CPU_RESETTABLE_SOON | ||
794 | moveq r0, #1 | ||
795 | movne r0, #0 | ||
796 | @@ -256,9 +260,10 @@ ENTRY(tegra20_sleep_cpu_secondary_finish) | ||
797 | mov r0, #TEGRA_FLUSH_CACHE_LOUIS | ||
798 | bl tegra_disable_clean_inv_dcache | ||
799 | |||
800 | - mov32 r0, TEGRA_PMC_VIRT + PMC_SCRATCH41 | ||
801 | + mov32 r0, TEGRA_IRAM_RESET_BASE_VIRT | ||
802 | + ldr r4, =__tegra20_cpu1_resettable_status_offset | ||
803 | mov r3, #CPU_RESETTABLE | ||
804 | - str r3, [r0] | ||
805 | + strb r3, [r0, r4] | ||
806 | |||
807 | bl tegra_cpu_do_idle | ||
808 | |||
809 | @@ -274,10 +279,10 @@ ENTRY(tegra20_sleep_cpu_secondary_finish) | ||
810 | |||
811 | bl tegra_pen_lock | ||
812 | |||
813 | - mov32 r3, TEGRA_PMC_VIRT | ||
814 | - add r0, r3, #PMC_SCRATCH41 | ||
815 | + mov32 r0, TEGRA_IRAM_RESET_BASE_VIRT | ||
816 | + ldr r4, =__tegra20_cpu1_resettable_status_offset | ||
817 | mov r3, #CPU_NOT_RESETTABLE | ||
818 | - str r3, [r0] | ||
819 | + strb r3, [r0, r4] | ||
820 | |||
821 | bl tegra_pen_unlock | ||
822 | |||
823 | diff --git a/arch/arm/mach-tegra/sleep.h b/arch/arm/mach-tegra/sleep.h | ||
824 | index 92d46ec1361a..0d59360d891d 100644 | ||
825 | --- a/arch/arm/mach-tegra/sleep.h | ||
826 | +++ b/arch/arm/mach-tegra/sleep.h | ||
827 | @@ -18,6 +18,7 @@ | ||
828 | #define __MACH_TEGRA_SLEEP_H | ||
829 | |||
830 | #include "iomap.h" | ||
831 | +#include "irammap.h" | ||
832 | |||
833 | #define TEGRA_ARM_PERIF_VIRT (TEGRA_ARM_PERIF_BASE - IO_CPU_PHYS \ | ||
834 | + IO_CPU_VIRT) | ||
835 | @@ -29,6 +30,9 @@ | ||
836 | + IO_APB_VIRT) | ||
837 | #define TEGRA_PMC_VIRT (TEGRA_PMC_BASE - IO_APB_PHYS + IO_APB_VIRT) | ||
838 | |||
839 | +#define TEGRA_IRAM_RESET_BASE_VIRT (IO_IRAM_VIRT + \ | ||
840 | + TEGRA_IRAM_RESET_HANDLER_OFFSET) | ||
841 | + | ||
842 | /* PMC_SCRATCH37-39 and 41 are used for tegra_pen_lock and idle */ | ||
843 | #define PMC_SCRATCH37 0x130 | ||
844 | #define PMC_SCRATCH38 0x134 | ||
845 | diff --git a/arch/arm64/kernel/entry.S b/arch/arm64/kernel/entry.S | ||
846 | index 2b0f3d5e11c7..6c99b4664b40 100644 | ||
847 | --- a/arch/arm64/kernel/entry.S | ||
848 | +++ b/arch/arm64/kernel/entry.S | ||
849 | @@ -517,6 +517,7 @@ el0_sp_pc: | ||
850 | mrs x26, far_el1 | ||
851 | // enable interrupts before calling the main handler | ||
852 | enable_dbg_and_irq | ||
853 | + ct_user_exit | ||
854 | mov x0, x26 | ||
855 | mov x1, x25 | ||
856 | mov x2, sp | ||
857 | diff --git a/arch/arm64/kernel/vdso/Makefile b/arch/arm64/kernel/vdso/Makefile | ||
858 | index ff3bddea482d..f6fe17d88da5 100644 | ||
859 | --- a/arch/arm64/kernel/vdso/Makefile | ||
860 | +++ b/arch/arm64/kernel/vdso/Makefile | ||
861 | @@ -15,6 +15,10 @@ ccflags-y := -shared -fno-common -fno-builtin | ||
862 | ccflags-y += -nostdlib -Wl,-soname=linux-vdso.so.1 \ | ||
863 | $(call cc-ldoption, -Wl$(comma)--hash-style=sysv) | ||
864 | |||
865 | +# Workaround for bare-metal (ELF) toolchains that neglect to pass -shared | ||
866 | +# down to collect2, resulting in silent corruption of the vDSO image. | ||
867 | +ccflags-y += -Wl,-shared | ||
868 | + | ||
869 | obj-y += vdso.o | ||
870 | extra-y += vdso.lds vdso-offsets.h | ||
871 | CPPFLAGS_vdso.lds += -P -C -U$(ARCH) | ||
872 | diff --git a/arch/arm64/mm/context.c b/arch/arm64/mm/context.c | ||
873 | index baa758d37021..76c1e6cd36fc 100644 | ||
874 | --- a/arch/arm64/mm/context.c | ||
875 | +++ b/arch/arm64/mm/context.c | ||
876 | @@ -92,6 +92,14 @@ static void reset_context(void *info) | ||
877 | unsigned int cpu = smp_processor_id(); | ||
878 | struct mm_struct *mm = current->active_mm; | ||
879 | |||
880 | + /* | ||
881 | + * current->active_mm could be init_mm for the idle thread immediately | ||
882 | + * after secondary CPU boot or hotplug. TTBR0_EL1 is already set to | ||
883 | + * the reserved value, so no need to reset any context. | ||
884 | + */ | ||
885 | + if (mm == &init_mm) | ||
886 | + return; | ||
887 | + | ||
888 | smp_rmb(); | ||
889 | asid = cpu_last_asid + cpu; | ||
890 | |||
891 | diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c | ||
892 | index c95464a33f36..f752943f75d2 100644 | ||
893 | --- a/arch/arm64/mm/init.c | ||
894 | +++ b/arch/arm64/mm/init.c | ||
895 | @@ -238,7 +238,7 @@ static void __init free_unused_memmap(void) | ||
896 | * memmap entries are valid from the bank end aligned to | ||
897 | * MAX_ORDER_NR_PAGES. | ||
898 | */ | ||
899 | - prev_end = ALIGN(start + __phys_to_pfn(reg->size), | ||
900 | + prev_end = ALIGN(__phys_to_pfn(reg->base + reg->size), | ||
901 | MAX_ORDER_NR_PAGES); | ||
902 | } | ||
903 | |||
904 | diff --git a/arch/mips/include/asm/mach-generic/spaces.h b/arch/mips/include/asm/mach-generic/spaces.h | ||
905 | index 9488fa5f8866..afc96ecb9004 100644 | ||
906 | --- a/arch/mips/include/asm/mach-generic/spaces.h | ||
907 | +++ b/arch/mips/include/asm/mach-generic/spaces.h | ||
908 | @@ -94,7 +94,11 @@ | ||
909 | #endif | ||
910 | |||
911 | #ifndef FIXADDR_TOP | ||
912 | +#ifdef CONFIG_KVM_GUEST | ||
913 | +#define FIXADDR_TOP ((unsigned long)(long)(int)0x7ffe0000) | ||
914 | +#else | ||
915 | #define FIXADDR_TOP ((unsigned long)(long)(int)0xfffe0000) | ||
916 | #endif | ||
917 | +#endif | ||
918 | |||
919 | #endif /* __ASM_MACH_GENERIC_SPACES_H */ | ||
920 | diff --git a/arch/mips/kernel/irq.c b/arch/mips/kernel/irq.c | ||
921 | index d2bfbc2e8995..be15e52a47a0 100644 | ||
922 | --- a/arch/mips/kernel/irq.c | ||
923 | +++ b/arch/mips/kernel/irq.c | ||
924 | @@ -109,7 +109,7 @@ void __init init_IRQ(void) | ||
925 | #endif | ||
926 | } | ||
927 | |||
928 | -#ifdef DEBUG_STACKOVERFLOW | ||
929 | +#ifdef CONFIG_DEBUG_STACKOVERFLOW | ||
930 | static inline void check_stack_overflow(void) | ||
931 | { | ||
932 | unsigned long sp; | ||
933 | diff --git a/arch/mips/kvm/mips.c b/arch/mips/kvm/mips.c | ||
934 | index 39074fb83bad..a53eaf50c224 100644 | ||
935 | --- a/arch/mips/kvm/mips.c | ||
936 | +++ b/arch/mips/kvm/mips.c | ||
937 | @@ -784,7 +784,7 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log) | ||
938 | |||
939 | /* If nothing is dirty, don't bother messing with page tables. */ | ||
940 | if (is_dirty) { | ||
941 | - memslot = &kvm->memslots->memslots[log->slot]; | ||
942 | + memslot = id_to_memslot(kvm->memslots, log->slot); | ||
943 | |||
944 | ga = memslot->base_gfn << PAGE_SHIFT; | ||
945 | ga_end = ga + (memslot->npages << PAGE_SHIFT); | ||
946 | diff --git a/arch/powerpc/perf/core-book3s.c b/arch/powerpc/perf/core-book3s.c | ||
947 | index a6995d4e93d4..ffa07eb5fff0 100644 | ||
948 | --- a/arch/powerpc/perf/core-book3s.c | ||
949 | +++ b/arch/powerpc/perf/core-book3s.c | ||
950 | @@ -131,7 +131,16 @@ static void pmao_restore_workaround(bool ebb) { } | ||
951 | |||
952 | static bool regs_use_siar(struct pt_regs *regs) | ||
953 | { | ||
954 | - return !!regs->result; | ||
955 | + /* | ||
956 | + * When we take a performance monitor exception the regs are setup | ||
957 | + * using perf_read_regs() which overloads some fields, in particular | ||
958 | + * regs->result to tell us whether to use SIAR. | ||
959 | + * | ||
960 | + * However if the regs are from another exception, eg. a syscall, then | ||
961 | + * they have not been setup using perf_read_regs() and so regs->result | ||
962 | + * is something random. | ||
963 | + */ | ||
964 | + return ((TRAP(regs) == 0xf00) && regs->result); | ||
965 | } | ||
966 | |||
967 | /* | ||
968 | diff --git a/arch/s390/kernel/crash_dump.c b/arch/s390/kernel/crash_dump.c | ||
969 | index 9f73c8059022..49b74454d7ee 100644 | ||
970 | --- a/arch/s390/kernel/crash_dump.c | ||
971 | +++ b/arch/s390/kernel/crash_dump.c | ||
972 | @@ -415,7 +415,7 @@ static void *nt_s390_vx_low(void *ptr, __vector128 *vx_regs) | ||
973 | ptr += len; | ||
974 | /* Copy lower halves of SIMD registers 0-15 */ | ||
975 | for (i = 0; i < 16; i++) { | ||
976 | - memcpy(ptr, &vx_regs[i], 8); | ||
977 | + memcpy(ptr, &vx_regs[i].u[2], 8); | ||
978 | ptr += 8; | ||
979 | } | ||
980 | return ptr; | ||
981 | diff --git a/arch/sparc/kernel/ldc.c b/arch/sparc/kernel/ldc.c | ||
982 | index 4310332872d4..71762565513e 100644 | ||
983 | --- a/arch/sparc/kernel/ldc.c | ||
984 | +++ b/arch/sparc/kernel/ldc.c | ||
985 | @@ -2307,7 +2307,7 @@ void *ldc_alloc_exp_dring(struct ldc_channel *lp, unsigned int len, | ||
986 | if (len & (8UL - 1)) | ||
987 | return ERR_PTR(-EINVAL); | ||
988 | |||
989 | - buf = kzalloc(len, GFP_KERNEL); | ||
990 | + buf = kzalloc(len, GFP_ATOMIC); | ||
991 | if (!buf) | ||
992 | return ERR_PTR(-ENOMEM); | ||
993 | |||
994 | diff --git a/arch/x86/include/asm/segment.h b/arch/x86/include/asm/segment.h | ||
995 | index 6f1c3a8a33ab..bcc9a2f46c62 100644 | ||
996 | --- a/arch/x86/include/asm/segment.h | ||
997 | +++ b/arch/x86/include/asm/segment.h | ||
998 | @@ -212,10 +212,21 @@ | ||
999 | #define TLS_SIZE (GDT_ENTRY_TLS_ENTRIES * 8) | ||
1000 | |||
1001 | #ifdef __KERNEL__ | ||
1002 | + | ||
1003 | +/* | ||
1004 | + * early_idt_handler_array is an array of entry points referenced in the | ||
1005 | + * early IDT. For simplicity, it's a real array with one entry point | ||
1006 | + * every nine bytes. That leaves room for an optional 'push $0' if the | ||
1007 | + * vector has no error code (two bytes), a 'push $vector_number' (two | ||
1008 | + * bytes), and a jump to the common entry code (up to five bytes). | ||
1009 | + */ | ||
1010 | +#define EARLY_IDT_HANDLER_SIZE 9 | ||
1011 | + | ||
1012 | #ifndef __ASSEMBLY__ | ||
1013 | -extern const char early_idt_handlers[NUM_EXCEPTION_VECTORS][2+2+5]; | ||
1014 | + | ||
1015 | +extern const char early_idt_handler_array[NUM_EXCEPTION_VECTORS][EARLY_IDT_HANDLER_SIZE]; | ||
1016 | #ifdef CONFIG_TRACING | ||
1017 | -#define trace_early_idt_handlers early_idt_handlers | ||
1018 | +# define trace_early_idt_handler_array early_idt_handler_array | ||
1019 | #endif | ||
1020 | |||
1021 | /* | ||
1022 | diff --git a/arch/x86/kernel/head64.c b/arch/x86/kernel/head64.c | ||
1023 | index 3b241f0ca005..957fdb5eb2e3 100644 | ||
1024 | --- a/arch/x86/kernel/head64.c | ||
1025 | +++ b/arch/x86/kernel/head64.c | ||
1026 | @@ -164,7 +164,7 @@ asmlinkage __visible void __init x86_64_start_kernel(char * real_mode_data) | ||
1027 | clear_bss(); | ||
1028 | |||
1029 | for (i = 0; i < NUM_EXCEPTION_VECTORS; i++) | ||
1030 | - set_intr_gate(i, early_idt_handlers[i]); | ||
1031 | + set_intr_gate(i, early_idt_handler_array[i]); | ||
1032 | load_idt((const struct desc_ptr *)&idt_descr); | ||
1033 | |||
1034 | copy_bootdata(__va(real_mode_data)); | ||
1035 | diff --git a/arch/x86/kernel/head_32.S b/arch/x86/kernel/head_32.S | ||
1036 | index f36bd42d6f0c..30a2aa3782fa 100644 | ||
1037 | --- a/arch/x86/kernel/head_32.S | ||
1038 | +++ b/arch/x86/kernel/head_32.S | ||
1039 | @@ -477,21 +477,22 @@ is486: | ||
1040 | __INIT | ||
1041 | setup_once: | ||
1042 | /* | ||
1043 | - * Set up a idt with 256 entries pointing to ignore_int, | ||
1044 | - * interrupt gates. It doesn't actually load idt - that needs | ||
1045 | - * to be done on each CPU. Interrupts are enabled elsewhere, | ||
1046 | - * when we can be relatively sure everything is ok. | ||
1047 | + * Set up a idt with 256 interrupt gates that push zero if there | ||
1048 | + * is no error code and then jump to early_idt_handler_common. | ||
1049 | + * It doesn't actually load the idt - that needs to be done on | ||
1050 | + * each CPU. Interrupts are enabled elsewhere, when we can be | ||
1051 | + * relatively sure everything is ok. | ||
1052 | */ | ||
1053 | |||
1054 | movl $idt_table,%edi | ||
1055 | - movl $early_idt_handlers,%eax | ||
1056 | + movl $early_idt_handler_array,%eax | ||
1057 | movl $NUM_EXCEPTION_VECTORS,%ecx | ||
1058 | 1: | ||
1059 | movl %eax,(%edi) | ||
1060 | movl %eax,4(%edi) | ||
1061 | /* interrupt gate, dpl=0, present */ | ||
1062 | movl $(0x8E000000 + __KERNEL_CS),2(%edi) | ||
1063 | - addl $9,%eax | ||
1064 | + addl $EARLY_IDT_HANDLER_SIZE,%eax | ||
1065 | addl $8,%edi | ||
1066 | loop 1b | ||
1067 | |||
1068 | @@ -523,26 +524,28 @@ setup_once: | ||
1069 | andl $0,setup_once_ref /* Once is enough, thanks */ | ||
1070 | ret | ||
1071 | |||
1072 | -ENTRY(early_idt_handlers) | ||
1073 | +ENTRY(early_idt_handler_array) | ||
1074 | # 36(%esp) %eflags | ||
1075 | # 32(%esp) %cs | ||
1076 | # 28(%esp) %eip | ||
1077 | # 24(%rsp) error code | ||
1078 | i = 0 | ||
1079 | .rept NUM_EXCEPTION_VECTORS | ||
1080 | - .if (EXCEPTION_ERRCODE_MASK >> i) & 1 | ||
1081 | - ASM_NOP2 | ||
1082 | - .else | ||
1083 | + .ifeq (EXCEPTION_ERRCODE_MASK >> i) & 1 | ||
1084 | pushl $0 # Dummy error code, to make stack frame uniform | ||
1085 | .endif | ||
1086 | pushl $i # 20(%esp) Vector number | ||
1087 | - jmp early_idt_handler | ||
1088 | + jmp early_idt_handler_common | ||
1089 | i = i + 1 | ||
1090 | + .fill early_idt_handler_array + i*EARLY_IDT_HANDLER_SIZE - ., 1, 0xcc | ||
1091 | .endr | ||
1092 | -ENDPROC(early_idt_handlers) | ||
1093 | +ENDPROC(early_idt_handler_array) | ||
1094 | |||
1095 | - /* This is global to keep gas from relaxing the jumps */ | ||
1096 | -ENTRY(early_idt_handler) | ||
1097 | +early_idt_handler_common: | ||
1098 | + /* | ||
1099 | + * The stack is the hardware frame, an error code or zero, and the | ||
1100 | + * vector number. | ||
1101 | + */ | ||
1102 | cld | ||
1103 | |||
1104 | cmpl $2,(%esp) # X86_TRAP_NMI | ||
1105 | @@ -602,7 +605,7 @@ ex_entry: | ||
1106 | is_nmi: | ||
1107 | addl $8,%esp /* drop vector number and error code */ | ||
1108 | iret | ||
1109 | -ENDPROC(early_idt_handler) | ||
1110 | +ENDPROC(early_idt_handler_common) | ||
1111 | |||
1112 | /* This is the default interrupt "handler" :-) */ | ||
1113 | ALIGN | ||
1114 | diff --git a/arch/x86/kernel/head_64.S b/arch/x86/kernel/head_64.S | ||
1115 | index a468c0a65c42..a2dc0add72ed 100644 | ||
1116 | --- a/arch/x86/kernel/head_64.S | ||
1117 | +++ b/arch/x86/kernel/head_64.S | ||
1118 | @@ -321,26 +321,28 @@ bad_address: | ||
1119 | jmp bad_address | ||
1120 | |||
1121 | __INIT | ||
1122 | - .globl early_idt_handlers | ||
1123 | -early_idt_handlers: | ||
1124 | +ENTRY(early_idt_handler_array) | ||
1125 | # 104(%rsp) %rflags | ||
1126 | # 96(%rsp) %cs | ||
1127 | # 88(%rsp) %rip | ||
1128 | # 80(%rsp) error code | ||
1129 | i = 0 | ||
1130 | .rept NUM_EXCEPTION_VECTORS | ||
1131 | - .if (EXCEPTION_ERRCODE_MASK >> i) & 1 | ||
1132 | - ASM_NOP2 | ||
1133 | - .else | ||
1134 | + .ifeq (EXCEPTION_ERRCODE_MASK >> i) & 1 | ||
1135 | pushq $0 # Dummy error code, to make stack frame uniform | ||
1136 | .endif | ||
1137 | pushq $i # 72(%rsp) Vector number | ||
1138 | - jmp early_idt_handler | ||
1139 | + jmp early_idt_handler_common | ||
1140 | i = i + 1 | ||
1141 | + .fill early_idt_handler_array + i*EARLY_IDT_HANDLER_SIZE - ., 1, 0xcc | ||
1142 | .endr | ||
1143 | +ENDPROC(early_idt_handler_array) | ||
1144 | |||
1145 | -/* This is global to keep gas from relaxing the jumps */ | ||
1146 | -ENTRY(early_idt_handler) | ||
1147 | +early_idt_handler_common: | ||
1148 | + /* | ||
1149 | + * The stack is the hardware frame, an error code or zero, and the | ||
1150 | + * vector number. | ||
1151 | + */ | ||
1152 | cld | ||
1153 | |||
1154 | cmpl $2,(%rsp) # X86_TRAP_NMI | ||
1155 | @@ -412,7 +414,7 @@ ENTRY(early_idt_handler) | ||
1156 | is_nmi: | ||
1157 | addq $16,%rsp # drop vector number and error code | ||
1158 | INTERRUPT_RETURN | ||
1159 | -ENDPROC(early_idt_handler) | ||
1160 | +ENDPROC(early_idt_handler_common) | ||
1161 | |||
1162 | __INITDATA | ||
1163 | |||
1164 | diff --git a/arch/x86/pci/acpi.c b/arch/x86/pci/acpi.c | ||
1165 | index cfd1b132b8e3..a3e94b4108bf 100644 | ||
1166 | --- a/arch/x86/pci/acpi.c | ||
1167 | +++ b/arch/x86/pci/acpi.c | ||
1168 | @@ -84,6 +84,17 @@ static const struct dmi_system_id pci_crs_quirks[] __initconst = { | ||
1169 | DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"), | ||
1170 | }, | ||
1171 | }, | ||
1172 | + /* https://bugs.launchpad.net/ubuntu/+source/alsa-driver/+bug/931368 */ | ||
1173 | + /* https://bugs.launchpad.net/ubuntu/+source/alsa-driver/+bug/1033299 */ | ||
1174 | + { | ||
1175 | + .callback = set_use_crs, | ||
1176 | + .ident = "Foxconn K8M890-8237A", | ||
1177 | + .matches = { | ||
1178 | + DMI_MATCH(DMI_BOARD_VENDOR, "Foxconn"), | ||
1179 | + DMI_MATCH(DMI_BOARD_NAME, "K8M890-8237A"), | ||
1180 | + DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"), | ||
1181 | + }, | ||
1182 | + }, | ||
1183 | |||
1184 | /* Now for the blacklist.. */ | ||
1185 | |||
1186 | @@ -124,8 +135,10 @@ void __init pci_acpi_crs_quirks(void) | ||
1187 | { | ||
1188 | int year; | ||
1189 | |||
1190 | - if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year < 2008) | ||
1191 | - pci_use_crs = false; | ||
1192 | + if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year < 2008) { | ||
1193 | + if (iomem_resource.end <= 0xffffffff) | ||
1194 | + pci_use_crs = false; | ||
1195 | + } | ||
1196 | |||
1197 | dmi_check_system(pci_crs_quirks); | ||
1198 | |||
1199 | diff --git a/block/genhd.c b/block/genhd.c | ||
1200 | index 0a536dc05f3b..c2fb3f7bdec4 100644 | ||
1201 | --- a/block/genhd.c | ||
1202 | +++ b/block/genhd.c | ||
1203 | @@ -422,9 +422,9 @@ int blk_alloc_devt(struct hd_struct *part, dev_t *devt) | ||
1204 | /* allocate ext devt */ | ||
1205 | idr_preload(GFP_KERNEL); | ||
1206 | |||
1207 | - spin_lock(&ext_devt_lock); | ||
1208 | + spin_lock_bh(&ext_devt_lock); | ||
1209 | idx = idr_alloc(&ext_devt_idr, part, 0, NR_EXT_DEVT, GFP_NOWAIT); | ||
1210 | - spin_unlock(&ext_devt_lock); | ||
1211 | + spin_unlock_bh(&ext_devt_lock); | ||
1212 | |||
1213 | idr_preload_end(); | ||
1214 | if (idx < 0) | ||
1215 | @@ -449,9 +449,9 @@ void blk_free_devt(dev_t devt) | ||
1216 | return; | ||
1217 | |||
1218 | if (MAJOR(devt) == BLOCK_EXT_MAJOR) { | ||
1219 | - spin_lock(&ext_devt_lock); | ||
1220 | + spin_lock_bh(&ext_devt_lock); | ||
1221 | idr_remove(&ext_devt_idr, blk_mangle_minor(MINOR(devt))); | ||
1222 | - spin_unlock(&ext_devt_lock); | ||
1223 | + spin_unlock_bh(&ext_devt_lock); | ||
1224 | } | ||
1225 | } | ||
1226 | |||
1227 | @@ -691,13 +691,13 @@ struct gendisk *get_gendisk(dev_t devt, int *partno) | ||
1228 | } else { | ||
1229 | struct hd_struct *part; | ||
1230 | |||
1231 | - spin_lock(&ext_devt_lock); | ||
1232 | + spin_lock_bh(&ext_devt_lock); | ||
1233 | part = idr_find(&ext_devt_idr, blk_mangle_minor(MINOR(devt))); | ||
1234 | if (part && get_disk(part_to_disk(part))) { | ||
1235 | *partno = part->partno; | ||
1236 | disk = part_to_disk(part); | ||
1237 | } | ||
1238 | - spin_unlock(&ext_devt_lock); | ||
1239 | + spin_unlock_bh(&ext_devt_lock); | ||
1240 | } | ||
1241 | |||
1242 | return disk; | ||
1243 | diff --git a/crypto/asymmetric_keys/asymmetric_keys.h b/crypto/asymmetric_keys/asymmetric_keys.h | ||
1244 | index f97330886d58..3f5b537ab33e 100644 | ||
1245 | --- a/crypto/asymmetric_keys/asymmetric_keys.h | ||
1246 | +++ b/crypto/asymmetric_keys/asymmetric_keys.h | ||
1247 | @@ -11,6 +11,9 @@ | ||
1248 | |||
1249 | extern struct asymmetric_key_id *asymmetric_key_hex_to_key_id(const char *id); | ||
1250 | |||
1251 | +extern int __asymmetric_key_hex_to_key_id(const char *id, | ||
1252 | + struct asymmetric_key_id *match_id, | ||
1253 | + size_t hexlen); | ||
1254 | static inline | ||
1255 | const struct asymmetric_key_ids *asymmetric_key_ids(const struct key *key) | ||
1256 | { | ||
1257 | diff --git a/crypto/asymmetric_keys/asymmetric_type.c b/crypto/asymmetric_keys/asymmetric_type.c | ||
1258 | index bcbbbd794e1d..b0e4ed23d668 100644 | ||
1259 | --- a/crypto/asymmetric_keys/asymmetric_type.c | ||
1260 | +++ b/crypto/asymmetric_keys/asymmetric_type.c | ||
1261 | @@ -104,6 +104,15 @@ static bool asymmetric_match_key_ids( | ||
1262 | return false; | ||
1263 | } | ||
1264 | |||
1265 | +/* helper function can be called directly with pre-allocated memory */ | ||
1266 | +inline int __asymmetric_key_hex_to_key_id(const char *id, | ||
1267 | + struct asymmetric_key_id *match_id, | ||
1268 | + size_t hexlen) | ||
1269 | +{ | ||
1270 | + match_id->len = hexlen; | ||
1271 | + return hex2bin(match_id->data, id, hexlen); | ||
1272 | +} | ||
1273 | + | ||
1274 | /** | ||
1275 | * asymmetric_key_hex_to_key_id - Convert a hex string into a key ID. | ||
1276 | * @id: The ID as a hex string. | ||
1277 | @@ -111,21 +120,20 @@ static bool asymmetric_match_key_ids( | ||
1278 | struct asymmetric_key_id *asymmetric_key_hex_to_key_id(const char *id) | ||
1279 | { | ||
1280 | struct asymmetric_key_id *match_id; | ||
1281 | - size_t hexlen; | ||
1282 | + size_t asciihexlen; | ||
1283 | int ret; | ||
1284 | |||
1285 | if (!*id) | ||
1286 | return ERR_PTR(-EINVAL); | ||
1287 | - hexlen = strlen(id); | ||
1288 | - if (hexlen & 1) | ||
1289 | + asciihexlen = strlen(id); | ||
1290 | + if (asciihexlen & 1) | ||
1291 | return ERR_PTR(-EINVAL); | ||
1292 | |||
1293 | - match_id = kmalloc(sizeof(struct asymmetric_key_id) + hexlen / 2, | ||
1294 | + match_id = kmalloc(sizeof(struct asymmetric_key_id) + asciihexlen / 2, | ||
1295 | GFP_KERNEL); | ||
1296 | if (!match_id) | ||
1297 | return ERR_PTR(-ENOMEM); | ||
1298 | - match_id->len = hexlen / 2; | ||
1299 | - ret = hex2bin(match_id->data, id, hexlen / 2); | ||
1300 | + ret = __asymmetric_key_hex_to_key_id(id, match_id, asciihexlen / 2); | ||
1301 | if (ret < 0) { | ||
1302 | kfree(match_id); | ||
1303 | return ERR_PTR(-EINVAL); | ||
1304 | diff --git a/crypto/asymmetric_keys/x509_public_key.c b/crypto/asymmetric_keys/x509_public_key.c | ||
1305 | index a6c42031628e..24f17e6c5904 100644 | ||
1306 | --- a/crypto/asymmetric_keys/x509_public_key.c | ||
1307 | +++ b/crypto/asymmetric_keys/x509_public_key.c | ||
1308 | @@ -28,17 +28,30 @@ static bool use_builtin_keys; | ||
1309 | static struct asymmetric_key_id *ca_keyid; | ||
1310 | |||
1311 | #ifndef MODULE | ||
1312 | +static struct { | ||
1313 | + struct asymmetric_key_id id; | ||
1314 | + unsigned char data[10]; | ||
1315 | +} cakey; | ||
1316 | + | ||
1317 | static int __init ca_keys_setup(char *str) | ||
1318 | { | ||
1319 | if (!str) /* default system keyring */ | ||
1320 | return 1; | ||
1321 | |||
1322 | if (strncmp(str, "id:", 3) == 0) { | ||
1323 | - struct asymmetric_key_id *p; | ||
1324 | - p = asymmetric_key_hex_to_key_id(str + 3); | ||
1325 | - if (p == ERR_PTR(-EINVAL)) | ||
1326 | - pr_err("Unparsable hex string in ca_keys\n"); | ||
1327 | - else if (!IS_ERR(p)) | ||
1328 | + struct asymmetric_key_id *p = &cakey.id; | ||
1329 | + size_t hexlen = (strlen(str) - 3) / 2; | ||
1330 | + int ret; | ||
1331 | + | ||
1332 | + if (hexlen == 0 || hexlen > sizeof(cakey.data)) { | ||
1333 | + pr_err("Missing or invalid ca_keys id\n"); | ||
1334 | + return 1; | ||
1335 | + } | ||
1336 | + | ||
1337 | + ret = __asymmetric_key_hex_to_key_id(str + 3, p, hexlen); | ||
1338 | + if (ret < 0) | ||
1339 | + pr_err("Unparsable ca_keys id hex string\n"); | ||
1340 | + else | ||
1341 | ca_keyid = p; /* owner key 'id:xxxxxx' */ | ||
1342 | } else if (strcmp(str, "builtin") == 0) { | ||
1343 | use_builtin_keys = true; | ||
1344 | diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c | ||
1345 | index 6341e668f362..813397a25594 100644 | ||
1346 | --- a/drivers/acpi/device_pm.c | ||
1347 | +++ b/drivers/acpi/device_pm.c | ||
1348 | @@ -957,6 +957,7 @@ EXPORT_SYMBOL_GPL(acpi_subsys_prepare); | ||
1349 | */ | ||
1350 | void acpi_subsys_complete(struct device *dev) | ||
1351 | { | ||
1352 | + pm_generic_complete(dev); | ||
1353 | /* | ||
1354 | * If the device had been runtime-suspended before the system went into | ||
1355 | * the sleep state it is going out of and it has never been resumed till | ||
1356 | diff --git a/drivers/ata/ahci_mvebu.c b/drivers/ata/ahci_mvebu.c | ||
1357 | index 68672d2692ee..e3267b78b200 100644 | ||
1358 | --- a/drivers/ata/ahci_mvebu.c | ||
1359 | +++ b/drivers/ata/ahci_mvebu.c | ||
1360 | @@ -43,7 +43,7 @@ static void ahci_mvebu_mbus_config(struct ahci_host_priv *hpriv, | ||
1361 | writel((cs->mbus_attr << 8) | | ||
1362 | (dram->mbus_dram_target_id << 4) | 1, | ||
1363 | hpriv->mmio + AHCI_WINDOW_CTRL(i)); | ||
1364 | - writel(cs->base, hpriv->mmio + AHCI_WINDOW_BASE(i)); | ||
1365 | + writel(cs->base >> 16, hpriv->mmio + AHCI_WINDOW_BASE(i)); | ||
1366 | writel(((cs->size - 1) & 0xffff0000), | ||
1367 | hpriv->mmio + AHCI_WINDOW_SIZE(i)); | ||
1368 | } | ||
1369 | diff --git a/drivers/ata/pata_octeon_cf.c b/drivers/ata/pata_octeon_cf.c | ||
1370 | index 2a97d3a531ec..afc252f523f0 100644 | ||
1371 | --- a/drivers/ata/pata_octeon_cf.c | ||
1372 | +++ b/drivers/ata/pata_octeon_cf.c | ||
1373 | @@ -1053,7 +1053,7 @@ static struct of_device_id octeon_cf_match[] = { | ||
1374 | }, | ||
1375 | {}, | ||
1376 | }; | ||
1377 | -MODULE_DEVICE_TABLE(of, octeon_i2c_match); | ||
1378 | +MODULE_DEVICE_TABLE(of, octeon_cf_match); | ||
1379 | |||
1380 | static struct platform_driver octeon_cf_driver = { | ||
1381 | .probe = octeon_cf_probe, | ||
1382 | diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c | ||
1383 | index ee731bb7d957..b389c1dbcdf7 100644 | ||
1384 | --- a/drivers/base/regmap/regmap.c | ||
1385 | +++ b/drivers/base/regmap/regmap.c | ||
1386 | @@ -944,11 +944,10 @@ EXPORT_SYMBOL_GPL(devm_regmap_init); | ||
1387 | static void regmap_field_init(struct regmap_field *rm_field, | ||
1388 | struct regmap *regmap, struct reg_field reg_field) | ||
1389 | { | ||
1390 | - int field_bits = reg_field.msb - reg_field.lsb + 1; | ||
1391 | rm_field->regmap = regmap; | ||
1392 | rm_field->reg = reg_field.reg; | ||
1393 | rm_field->shift = reg_field.lsb; | ||
1394 | - rm_field->mask = ((BIT(field_bits) - 1) << reg_field.lsb); | ||
1395 | + rm_field->mask = GENMASK(reg_field.msb, reg_field.lsb); | ||
1396 | rm_field->id_size = reg_field.id_size; | ||
1397 | rm_field->id_offset = reg_field.id_offset; | ||
1398 | } | ||
1399 | @@ -2317,7 +2316,7 @@ int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val, | ||
1400 | &ival); | ||
1401 | if (ret != 0) | ||
1402 | return ret; | ||
1403 | - memcpy(val + (i * val_bytes), &ival, val_bytes); | ||
1404 | + map->format.format_val(val + (i * val_bytes), ival, 0); | ||
1405 | } | ||
1406 | } | ||
1407 | |||
1408 | diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c | ||
1409 | index 5d684d97dc6d..501a8ca662f4 100644 | ||
1410 | --- a/drivers/block/rbd.c | ||
1411 | +++ b/drivers/block/rbd.c | ||
1412 | @@ -1998,11 +1998,11 @@ static struct rbd_obj_request *rbd_obj_request_create(const char *object_name, | ||
1413 | rbd_assert(obj_request_type_valid(type)); | ||
1414 | |||
1415 | size = strlen(object_name) + 1; | ||
1416 | - name = kmalloc(size, GFP_KERNEL); | ||
1417 | + name = kmalloc(size, GFP_NOIO); | ||
1418 | if (!name) | ||
1419 | return NULL; | ||
1420 | |||
1421 | - obj_request = kmem_cache_zalloc(rbd_obj_request_cache, GFP_KERNEL); | ||
1422 | + obj_request = kmem_cache_zalloc(rbd_obj_request_cache, GFP_NOIO); | ||
1423 | if (!obj_request) { | ||
1424 | kfree(name); | ||
1425 | return NULL; | ||
1426 | diff --git a/drivers/bluetooth/ath3k.c b/drivers/bluetooth/ath3k.c | ||
1427 | index 288547a3c566..8dc319dd3150 100644 | ||
1428 | --- a/drivers/bluetooth/ath3k.c | ||
1429 | +++ b/drivers/bluetooth/ath3k.c | ||
1430 | @@ -80,6 +80,7 @@ static const struct usb_device_id ath3k_table[] = { | ||
1431 | { USB_DEVICE(0x0489, 0xe057) }, | ||
1432 | { USB_DEVICE(0x0489, 0xe056) }, | ||
1433 | { USB_DEVICE(0x0489, 0xe05f) }, | ||
1434 | + { USB_DEVICE(0x0489, 0xe076) }, | ||
1435 | { USB_DEVICE(0x0489, 0xe078) }, | ||
1436 | { USB_DEVICE(0x04c5, 0x1330) }, | ||
1437 | { USB_DEVICE(0x04CA, 0x3004) }, | ||
1438 | @@ -88,6 +89,8 @@ static const struct usb_device_id ath3k_table[] = { | ||
1439 | { USB_DEVICE(0x04CA, 0x3007) }, | ||
1440 | { USB_DEVICE(0x04CA, 0x3008) }, | ||
1441 | { USB_DEVICE(0x04CA, 0x300b) }, | ||
1442 | + { USB_DEVICE(0x04CA, 0x300d) }, | ||
1443 | + { USB_DEVICE(0x04CA, 0x300f) }, | ||
1444 | { USB_DEVICE(0x04CA, 0x3010) }, | ||
1445 | { USB_DEVICE(0x0930, 0x0219) }, | ||
1446 | { USB_DEVICE(0x0930, 0x0220) }, | ||
1447 | @@ -111,6 +114,7 @@ static const struct usb_device_id ath3k_table[] = { | ||
1448 | { USB_DEVICE(0x13d3, 0x3408) }, | ||
1449 | { USB_DEVICE(0x13d3, 0x3423) }, | ||
1450 | { USB_DEVICE(0x13d3, 0x3432) }, | ||
1451 | + { USB_DEVICE(0x13d3, 0x3474) }, | ||
1452 | |||
1453 | /* Atheros AR5BBU12 with sflash firmware */ | ||
1454 | { USB_DEVICE(0x0489, 0xE02C) }, | ||
1455 | @@ -135,6 +139,7 @@ static const struct usb_device_id ath3k_blist_tbl[] = { | ||
1456 | { USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 }, | ||
1457 | { USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 }, | ||
1458 | { USB_DEVICE(0x0489, 0xe05f), .driver_info = BTUSB_ATH3012 }, | ||
1459 | + { USB_DEVICE(0x0489, 0xe076), .driver_info = BTUSB_ATH3012 }, | ||
1460 | { USB_DEVICE(0x0489, 0xe078), .driver_info = BTUSB_ATH3012 }, | ||
1461 | { USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 }, | ||
1462 | { USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 }, | ||
1463 | @@ -143,6 +148,8 @@ static const struct usb_device_id ath3k_blist_tbl[] = { | ||
1464 | { USB_DEVICE(0x04ca, 0x3007), .driver_info = BTUSB_ATH3012 }, | ||
1465 | { USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 }, | ||
1466 | { USB_DEVICE(0x04ca, 0x300b), .driver_info = BTUSB_ATH3012 }, | ||
1467 | + { USB_DEVICE(0x04ca, 0x300d), .driver_info = BTUSB_ATH3012 }, | ||
1468 | + { USB_DEVICE(0x04ca, 0x300f), .driver_info = BTUSB_ATH3012 }, | ||
1469 | { USB_DEVICE(0x04ca, 0x3010), .driver_info = BTUSB_ATH3012 }, | ||
1470 | { USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 }, | ||
1471 | { USB_DEVICE(0x0930, 0x0220), .driver_info = BTUSB_ATH3012 }, | ||
1472 | @@ -166,6 +173,7 @@ static const struct usb_device_id ath3k_blist_tbl[] = { | ||
1473 | { USB_DEVICE(0x13d3, 0x3408), .driver_info = BTUSB_ATH3012 }, | ||
1474 | { USB_DEVICE(0x13d3, 0x3423), .driver_info = BTUSB_ATH3012 }, | ||
1475 | { USB_DEVICE(0x13d3, 0x3432), .driver_info = BTUSB_ATH3012 }, | ||
1476 | + { USB_DEVICE(0x13d3, 0x3474), .driver_info = BTUSB_ATH3012 }, | ||
1477 | |||
1478 | /* Atheros AR5BBU22 with sflash firmware */ | ||
1479 | { USB_DEVICE(0x0489, 0xE036), .driver_info = BTUSB_ATH3012 }, | ||
1480 | diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c | ||
1481 | index 813bb06a8889..c675e2bd9fd3 100644 | ||
1482 | --- a/drivers/bluetooth/btusb.c | ||
1483 | +++ b/drivers/bluetooth/btusb.c | ||
1484 | @@ -168,6 +168,7 @@ static const struct usb_device_id blacklist_table[] = { | ||
1485 | { USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 }, | ||
1486 | { USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 }, | ||
1487 | { USB_DEVICE(0x0489, 0xe05f), .driver_info = BTUSB_ATH3012 }, | ||
1488 | + { USB_DEVICE(0x0489, 0xe076), .driver_info = BTUSB_ATH3012 }, | ||
1489 | { USB_DEVICE(0x0489, 0xe078), .driver_info = BTUSB_ATH3012 }, | ||
1490 | { USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 }, | ||
1491 | { USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 }, | ||
1492 | @@ -176,6 +177,8 @@ static const struct usb_device_id blacklist_table[] = { | ||
1493 | { USB_DEVICE(0x04ca, 0x3007), .driver_info = BTUSB_ATH3012 }, | ||
1494 | { USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 }, | ||
1495 | { USB_DEVICE(0x04ca, 0x300b), .driver_info = BTUSB_ATH3012 }, | ||
1496 | + { USB_DEVICE(0x04ca, 0x300d), .driver_info = BTUSB_ATH3012 }, | ||
1497 | + { USB_DEVICE(0x04ca, 0x300f), .driver_info = BTUSB_ATH3012 }, | ||
1498 | { USB_DEVICE(0x04ca, 0x3010), .driver_info = BTUSB_ATH3012 }, | ||
1499 | { USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 }, | ||
1500 | { USB_DEVICE(0x0930, 0x0220), .driver_info = BTUSB_ATH3012 }, | ||
1501 | @@ -199,6 +202,7 @@ static const struct usb_device_id blacklist_table[] = { | ||
1502 | { USB_DEVICE(0x13d3, 0x3408), .driver_info = BTUSB_ATH3012 }, | ||
1503 | { USB_DEVICE(0x13d3, 0x3423), .driver_info = BTUSB_ATH3012 }, | ||
1504 | { USB_DEVICE(0x13d3, 0x3432), .driver_info = BTUSB_ATH3012 }, | ||
1505 | + { USB_DEVICE(0x13d3, 0x3474), .driver_info = BTUSB_ATH3012 }, | ||
1506 | |||
1507 | /* Atheros AR5BBU12 with sflash firmware */ | ||
1508 | { USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE }, | ||
1509 | @@ -1589,6 +1593,8 @@ static int btusb_setup_intel(struct hci_dev *hdev) | ||
1510 | } | ||
1511 | fw_ptr = fw->data; | ||
1512 | |||
1513 | + kfree_skb(skb); | ||
1514 | + | ||
1515 | /* This Intel specific command enables the manufacturer mode of the | ||
1516 | * controller. | ||
1517 | * | ||
1518 | diff --git a/drivers/bus/arm-ccn.c b/drivers/bus/arm-ccn.c | ||
1519 | index aaa0f2a87118..60397ec77ff7 100644 | ||
1520 | --- a/drivers/bus/arm-ccn.c | ||
1521 | +++ b/drivers/bus/arm-ccn.c | ||
1522 | @@ -212,7 +212,7 @@ static int arm_ccn_node_to_xp_port(int node) | ||
1523 | |||
1524 | static void arm_ccn_pmu_config_set(u64 *config, u32 node_xp, u32 type, u32 port) | ||
1525 | { | ||
1526 | - *config &= ~((0xff << 0) | (0xff << 8) | (0xff << 24)); | ||
1527 | + *config &= ~((0xff << 0) | (0xff << 8) | (0x3 << 24)); | ||
1528 | *config |= (node_xp << 0) | (type << 8) | (port << 24); | ||
1529 | } | ||
1530 | |||
1531 | diff --git a/drivers/char/agp/intel-gtt.c b/drivers/char/agp/intel-gtt.c | ||
1532 | index 9a024f899dd4..9a99d0a3ff08 100644 | ||
1533 | --- a/drivers/char/agp/intel-gtt.c | ||
1534 | +++ b/drivers/char/agp/intel-gtt.c | ||
1535 | @@ -585,7 +585,7 @@ static inline int needs_ilk_vtd_wa(void) | ||
1536 | /* Query intel_iommu to see if we need the workaround. Presumably that | ||
1537 | * was loaded first. | ||
1538 | */ | ||
1539 | - if ((gpu_devid == PCI_DEVICE_ID_INTEL_IRONLAKE_M_HB || | ||
1540 | + if ((gpu_devid == PCI_DEVICE_ID_INTEL_IRONLAKE_D_IG || | ||
1541 | gpu_devid == PCI_DEVICE_ID_INTEL_IRONLAKE_M_IG) && | ||
1542 | intel_iommu_gfx_mapped) | ||
1543 | return 1; | ||
1544 | diff --git a/drivers/char/tpm/tpm_ibmvtpm.c b/drivers/char/tpm/tpm_ibmvtpm.c | ||
1545 | index 102463ba745d..643bba7d6f81 100644 | ||
1546 | --- a/drivers/char/tpm/tpm_ibmvtpm.c | ||
1547 | +++ b/drivers/char/tpm/tpm_ibmvtpm.c | ||
1548 | @@ -579,6 +579,9 @@ static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev, | ||
1549 | goto cleanup; | ||
1550 | } | ||
1551 | |||
1552 | + ibmvtpm->dev = dev; | ||
1553 | + ibmvtpm->vdev = vio_dev; | ||
1554 | + | ||
1555 | crq_q = &ibmvtpm->crq_queue; | ||
1556 | crq_q->crq_addr = (struct ibmvtpm_crq *)get_zeroed_page(GFP_KERNEL); | ||
1557 | if (!crq_q->crq_addr) { | ||
1558 | @@ -623,8 +626,6 @@ static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev, | ||
1559 | |||
1560 | crq_q->index = 0; | ||
1561 | |||
1562 | - ibmvtpm->dev = dev; | ||
1563 | - ibmvtpm->vdev = vio_dev; | ||
1564 | TPM_VPRIV(chip) = (void *)ibmvtpm; | ||
1565 | |||
1566 | spin_lock_init(&ibmvtpm->rtce_lock); | ||
1567 | diff --git a/drivers/clk/at91/clk-pll.c b/drivers/clk/at91/clk-pll.c | ||
1568 | index 6ec79dbc0840..cbbe40377ad6 100644 | ||
1569 | --- a/drivers/clk/at91/clk-pll.c | ||
1570 | +++ b/drivers/clk/at91/clk-pll.c | ||
1571 | @@ -173,8 +173,7 @@ static long clk_pll_get_best_div_mul(struct clk_pll *pll, unsigned long rate, | ||
1572 | int i = 0; | ||
1573 | |||
1574 | /* Check if parent_rate is a valid input rate */ | ||
1575 | - if (parent_rate < characteristics->input.min || | ||
1576 | - parent_rate > characteristics->input.max) | ||
1577 | + if (parent_rate < characteristics->input.min) | ||
1578 | return -ERANGE; | ||
1579 | |||
1580 | /* | ||
1581 | @@ -187,6 +186,15 @@ static long clk_pll_get_best_div_mul(struct clk_pll *pll, unsigned long rate, | ||
1582 | if (!mindiv) | ||
1583 | mindiv = 1; | ||
1584 | |||
1585 | + if (parent_rate > characteristics->input.max) { | ||
1586 | + tmpdiv = DIV_ROUND_UP(parent_rate, characteristics->input.max); | ||
1587 | + if (tmpdiv > PLL_DIV_MAX) | ||
1588 | + return -ERANGE; | ||
1589 | + | ||
1590 | + if (tmpdiv > mindiv) | ||
1591 | + mindiv = tmpdiv; | ||
1592 | + } | ||
1593 | + | ||
1594 | /* | ||
1595 | * Calculate the maximum divider which is limited by PLL register | ||
1596 | * layout (limited by the MUL or DIV field size). | ||
1597 | diff --git a/drivers/clk/at91/pmc.h b/drivers/clk/at91/pmc.h | ||
1598 | index 52d2041fa3f6..af2c99195541 100644 | ||
1599 | --- a/drivers/clk/at91/pmc.h | ||
1600 | +++ b/drivers/clk/at91/pmc.h | ||
1601 | @@ -120,7 +120,7 @@ extern void __init of_at91sam9x5_clk_smd_setup(struct device_node *np, | ||
1602 | struct at91_pmc *pmc); | ||
1603 | #endif | ||
1604 | |||
1605 | -#if defined(CONFIG_HAVE_AT91_SMD) | ||
1606 | +#if defined(CONFIG_HAVE_AT91_H32MX) | ||
1607 | extern void __init of_sama5d4_clk_h32mx_setup(struct device_node *np, | ||
1608 | struct at91_pmc *pmc); | ||
1609 | #endif | ||
1610 | diff --git a/drivers/clocksource/exynos_mct.c b/drivers/clocksource/exynos_mct.c | ||
1611 | index 83564c9cfdbe..c844616028d2 100644 | ||
1612 | --- a/drivers/clocksource/exynos_mct.c | ||
1613 | +++ b/drivers/clocksource/exynos_mct.c | ||
1614 | @@ -466,15 +466,12 @@ static int exynos4_local_timer_setup(struct clock_event_device *evt) | ||
1615 | exynos4_mct_write(TICK_BASE_CNT, mevt->base + MCT_L_TCNTB_OFFSET); | ||
1616 | |||
1617 | if (mct_int_type == MCT_INT_SPI) { | ||
1618 | - evt->irq = mct_irqs[MCT_L0_IRQ + cpu]; | ||
1619 | - if (request_irq(evt->irq, exynos4_mct_tick_isr, | ||
1620 | - IRQF_TIMER | IRQF_NOBALANCING, | ||
1621 | - evt->name, mevt)) { | ||
1622 | - pr_err("exynos-mct: cannot register IRQ %d\n", | ||
1623 | - evt->irq); | ||
1624 | + | ||
1625 | + if (evt->irq == -1) | ||
1626 | return -EIO; | ||
1627 | - } | ||
1628 | - irq_force_affinity(mct_irqs[MCT_L0_IRQ + cpu], cpumask_of(cpu)); | ||
1629 | + | ||
1630 | + irq_force_affinity(evt->irq, cpumask_of(cpu)); | ||
1631 | + enable_irq(evt->irq); | ||
1632 | } else { | ||
1633 | enable_percpu_irq(mct_irqs[MCT_L0_IRQ], 0); | ||
1634 | } | ||
1635 | @@ -487,10 +484,12 @@ static int exynos4_local_timer_setup(struct clock_event_device *evt) | ||
1636 | static void exynos4_local_timer_stop(struct clock_event_device *evt) | ||
1637 | { | ||
1638 | evt->set_mode(CLOCK_EVT_MODE_UNUSED, evt); | ||
1639 | - if (mct_int_type == MCT_INT_SPI) | ||
1640 | - free_irq(evt->irq, this_cpu_ptr(&percpu_mct_tick)); | ||
1641 | - else | ||
1642 | + if (mct_int_type == MCT_INT_SPI) { | ||
1643 | + if (evt->irq != -1) | ||
1644 | + disable_irq_nosync(evt->irq); | ||
1645 | + } else { | ||
1646 | disable_percpu_irq(mct_irqs[MCT_L0_IRQ]); | ||
1647 | + } | ||
1648 | } | ||
1649 | |||
1650 | static int exynos4_mct_cpu_notify(struct notifier_block *self, | ||
1651 | @@ -522,7 +521,7 @@ static struct notifier_block exynos4_mct_cpu_nb = { | ||
1652 | |||
1653 | static void __init exynos4_timer_resources(struct device_node *np, void __iomem *base) | ||
1654 | { | ||
1655 | - int err; | ||
1656 | + int err, cpu; | ||
1657 | struct mct_clock_event_device *mevt = this_cpu_ptr(&percpu_mct_tick); | ||
1658 | struct clk *mct_clk, *tick_clk; | ||
1659 | |||
1660 | @@ -549,7 +548,25 @@ static void __init exynos4_timer_resources(struct device_node *np, void __iomem | ||
1661 | WARN(err, "MCT: can't request IRQ %d (%d)\n", | ||
1662 | mct_irqs[MCT_L0_IRQ], err); | ||
1663 | } else { | ||
1664 | - irq_set_affinity(mct_irqs[MCT_L0_IRQ], cpumask_of(0)); | ||
1665 | + for_each_possible_cpu(cpu) { | ||
1666 | + int mct_irq = mct_irqs[MCT_L0_IRQ + cpu]; | ||
1667 | + struct mct_clock_event_device *pcpu_mevt = | ||
1668 | + per_cpu_ptr(&percpu_mct_tick, cpu); | ||
1669 | + | ||
1670 | + pcpu_mevt->evt.irq = -1; | ||
1671 | + | ||
1672 | + irq_set_status_flags(mct_irq, IRQ_NOAUTOEN); | ||
1673 | + if (request_irq(mct_irq, | ||
1674 | + exynos4_mct_tick_isr, | ||
1675 | + IRQF_TIMER | IRQF_NOBALANCING, | ||
1676 | + pcpu_mevt->name, pcpu_mevt)) { | ||
1677 | + pr_err("exynos-mct: cannot register IRQ (cpu%d)\n", | ||
1678 | + cpu); | ||
1679 | + | ||
1680 | + continue; | ||
1681 | + } | ||
1682 | + pcpu_mevt->evt.irq = mct_irq; | ||
1683 | + } | ||
1684 | } | ||
1685 | |||
1686 | err = register_cpu_notifier(&exynos4_mct_cpu_nb); | ||
1687 | diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c | ||
1688 | index 27bb6d3877ed..d0d21363c63f 100644 | ||
1689 | --- a/drivers/cpufreq/intel_pstate.c | ||
1690 | +++ b/drivers/cpufreq/intel_pstate.c | ||
1691 | @@ -443,7 +443,7 @@ static void byt_set_pstate(struct cpudata *cpudata, int pstate) | ||
1692 | |||
1693 | val |= vid; | ||
1694 | |||
1695 | - wrmsrl(MSR_IA32_PERF_CTL, val); | ||
1696 | + wrmsrl_on_cpu(cpudata->cpu, MSR_IA32_PERF_CTL, val); | ||
1697 | } | ||
1698 | |||
1699 | #define BYT_BCLK_FREQS 5 | ||
1700 | diff --git a/drivers/crypto/caam/caamhash.c b/drivers/crypto/caam/caamhash.c | ||
1701 | index f347ab7eea95..08b0da23c4ab 100644 | ||
1702 | --- a/drivers/crypto/caam/caamhash.c | ||
1703 | +++ b/drivers/crypto/caam/caamhash.c | ||
1704 | @@ -1543,6 +1543,8 @@ static int ahash_init(struct ahash_request *req) | ||
1705 | |||
1706 | state->current_buf = 0; | ||
1707 | state->buf_dma = 0; | ||
1708 | + state->buflen_0 = 0; | ||
1709 | + state->buflen_1 = 0; | ||
1710 | |||
1711 | return 0; | ||
1712 | } | ||
1713 | diff --git a/drivers/crypto/caam/caamrng.c b/drivers/crypto/caam/caamrng.c | ||
1714 | index ae31e555793c..a48dc251b14f 100644 | ||
1715 | --- a/drivers/crypto/caam/caamrng.c | ||
1716 | +++ b/drivers/crypto/caam/caamrng.c | ||
1717 | @@ -56,7 +56,7 @@ | ||
1718 | |||
1719 | /* Buffer, its dma address and lock */ | ||
1720 | struct buf_data { | ||
1721 | - u8 buf[RN_BUF_SIZE]; | ||
1722 | + u8 buf[RN_BUF_SIZE] ____cacheline_aligned; | ||
1723 | dma_addr_t addr; | ||
1724 | struct completion filled; | ||
1725 | u32 hw_desc[DESC_JOB_O_LEN]; | ||
1726 | diff --git a/drivers/crypto/talitos.c b/drivers/crypto/talitos.c | ||
1727 | index 624b8be0c365..307931528eb2 100644 | ||
1728 | --- a/drivers/crypto/talitos.c | ||
1729 | +++ b/drivers/crypto/talitos.c | ||
1730 | @@ -927,7 +927,8 @@ static int sg_to_link_tbl(struct scatterlist *sg, int sg_count, | ||
1731 | sg_count--; | ||
1732 | link_tbl_ptr--; | ||
1733 | } | ||
1734 | - be16_add_cpu(&link_tbl_ptr->len, cryptlen); | ||
1735 | + link_tbl_ptr->len = cpu_to_be16(be16_to_cpu(link_tbl_ptr->len) | ||
1736 | + + cryptlen); | ||
1737 | |||
1738 | /* tag end of link table */ | ||
1739 | link_tbl_ptr->j_extent = DESC_PTR_LNKTBL_RETURN; | ||
1740 | @@ -2563,6 +2564,7 @@ static struct talitos_crypto_alg *talitos_alg_alloc(struct device *dev, | ||
1741 | break; | ||
1742 | default: | ||
1743 | dev_err(dev, "unknown algorithm type %d\n", t_alg->algt.type); | ||
1744 | + kfree(t_alg); | ||
1745 | return ERR_PTR(-EINVAL); | ||
1746 | } | ||
1747 | |||
1748 | diff --git a/drivers/dma/mv_xor.c b/drivers/dma/mv_xor.c | ||
1749 | index a63837ca1410..ede8e868016d 100644 | ||
1750 | --- a/drivers/dma/mv_xor.c | ||
1751 | +++ b/drivers/dma/mv_xor.c | ||
1752 | @@ -277,7 +277,8 @@ static void mv_xor_slot_cleanup(struct mv_xor_chan *mv_chan) | ||
1753 | dma_cookie_t cookie = 0; | ||
1754 | int busy = mv_chan_is_busy(mv_chan); | ||
1755 | u32 current_desc = mv_chan_get_current_desc(mv_chan); | ||
1756 | - int seen_current = 0; | ||
1757 | + int current_cleaned = 0; | ||
1758 | + struct mv_xor_desc *hw_desc; | ||
1759 | |||
1760 | dev_dbg(mv_chan_to_devp(mv_chan), "%s %d\n", __func__, __LINE__); | ||
1761 | dev_dbg(mv_chan_to_devp(mv_chan), "current_desc %x\n", current_desc); | ||
1762 | @@ -289,38 +290,57 @@ static void mv_xor_slot_cleanup(struct mv_xor_chan *mv_chan) | ||
1763 | |||
1764 | list_for_each_entry_safe(iter, _iter, &mv_chan->chain, | ||
1765 | chain_node) { | ||
1766 | - prefetch(_iter); | ||
1767 | - prefetch(&_iter->async_tx); | ||
1768 | |||
1769 | - /* do not advance past the current descriptor loaded into the | ||
1770 | - * hardware channel, subsequent descriptors are either in | ||
1771 | - * process or have not been submitted | ||
1772 | - */ | ||
1773 | - if (seen_current) | ||
1774 | - break; | ||
1775 | + /* clean finished descriptors */ | ||
1776 | + hw_desc = iter->hw_desc; | ||
1777 | + if (hw_desc->status & XOR_DESC_SUCCESS) { | ||
1778 | + cookie = mv_xor_run_tx_complete_actions(iter, mv_chan, | ||
1779 | + cookie); | ||
1780 | |||
1781 | - /* stop the search if we reach the current descriptor and the | ||
1782 | - * channel is busy | ||
1783 | - */ | ||
1784 | - if (iter->async_tx.phys == current_desc) { | ||
1785 | - seen_current = 1; | ||
1786 | - if (busy) | ||
1787 | + /* done processing desc, clean slot */ | ||
1788 | + mv_xor_clean_slot(iter, mv_chan); | ||
1789 | + | ||
1790 | + /* break if we did cleaned the current */ | ||
1791 | + if (iter->async_tx.phys == current_desc) { | ||
1792 | + current_cleaned = 1; | ||
1793 | + break; | ||
1794 | + } | ||
1795 | + } else { | ||
1796 | + if (iter->async_tx.phys == current_desc) { | ||
1797 | + current_cleaned = 0; | ||
1798 | break; | ||
1799 | + } | ||
1800 | } | ||
1801 | - | ||
1802 | - cookie = mv_xor_run_tx_complete_actions(iter, mv_chan, cookie); | ||
1803 | - | ||
1804 | - if (mv_xor_clean_slot(iter, mv_chan)) | ||
1805 | - break; | ||
1806 | } | ||
1807 | |||
1808 | if ((busy == 0) && !list_empty(&mv_chan->chain)) { | ||
1809 | - struct mv_xor_desc_slot *chain_head; | ||
1810 | - chain_head = list_entry(mv_chan->chain.next, | ||
1811 | - struct mv_xor_desc_slot, | ||
1812 | - chain_node); | ||
1813 | - | ||
1814 | - mv_xor_start_new_chain(mv_chan, chain_head); | ||
1815 | + if (current_cleaned) { | ||
1816 | + /* | ||
1817 | + * current descriptor cleaned and removed, run | ||
1818 | + * from list head | ||
1819 | + */ | ||
1820 | + iter = list_entry(mv_chan->chain.next, | ||
1821 | + struct mv_xor_desc_slot, | ||
1822 | + chain_node); | ||
1823 | + mv_xor_start_new_chain(mv_chan, iter); | ||
1824 | + } else { | ||
1825 | + if (!list_is_last(&iter->chain_node, &mv_chan->chain)) { | ||
1826 | + /* | ||
1827 | + * descriptors are still waiting after | ||
1828 | + * current, trigger them | ||
1829 | + */ | ||
1830 | + iter = list_entry(iter->chain_node.next, | ||
1831 | + struct mv_xor_desc_slot, | ||
1832 | + chain_node); | ||
1833 | + mv_xor_start_new_chain(mv_chan, iter); | ||
1834 | + } else { | ||
1835 | + /* | ||
1836 | + * some descriptors are still waiting | ||
1837 | + * to be cleaned | ||
1838 | + */ | ||
1839 | + tasklet_schedule(&mv_chan->irq_tasklet); | ||
1840 | + } | ||
1841 | + } | ||
1842 | } | ||
1843 | |||
1844 | if (cookie > 0) | ||
1845 | diff --git a/drivers/dma/mv_xor.h b/drivers/dma/mv_xor.h | ||
1846 | index 78edc7e44569..4fa0fe2e2f08 100644 | ||
1847 | --- a/drivers/dma/mv_xor.h | ||
1848 | +++ b/drivers/dma/mv_xor.h | ||
1849 | @@ -35,6 +35,7 @@ | ||
1850 | #define XOR_OPERATION_MODE_XOR 0 | ||
1851 | #define XOR_OPERATION_MODE_MEMCPY 2 | ||
1852 | #define XOR_DESCRIPTOR_SWAP BIT(14) | ||
1853 | +#define XOR_DESC_SUCCESS 0x40000000 | ||
1854 | |||
1855 | #define XOR_DESC_DMA_OWNED BIT(31) | ||
1856 | #define XOR_DESC_EOD_INT_EN BIT(31) | ||
1857 | diff --git a/drivers/gpio/gpio-crystalcove.c b/drivers/gpio/gpio-crystalcove.c | ||
1858 | index a7cf0c193ba8..2a8791cc138a 100644 | ||
1859 | --- a/drivers/gpio/gpio-crystalcove.c | ||
1860 | +++ b/drivers/gpio/gpio-crystalcove.c | ||
1861 | @@ -250,6 +250,7 @@ static struct irq_chip crystalcove_irqchip = { | ||
1862 | .irq_set_type = crystalcove_irq_type, | ||
1863 | .irq_bus_lock = crystalcove_bus_lock, | ||
1864 | .irq_bus_sync_unlock = crystalcove_bus_sync_unlock, | ||
1865 | + .flags = IRQCHIP_SKIP_SET_WAKE, | ||
1866 | }; | ||
1867 | |||
1868 | static irqreturn_t crystalcove_gpio_irq_handler(int irq, void *data) | ||
1869 | diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_dp_mst_topology.c | ||
1870 | index f50d884b81cf..1f5e42a1f5b4 100644 | ||
1871 | --- a/drivers/gpu/drm/drm_dp_mst_topology.c | ||
1872 | +++ b/drivers/gpu/drm/drm_dp_mst_topology.c | ||
1873 | @@ -1152,6 +1152,8 @@ static struct drm_dp_mst_branch *drm_dp_get_mst_branch_device(struct drm_dp_mst_ | ||
1874 | struct drm_dp_mst_port *port; | ||
1875 | int i; | ||
1876 | /* find the port by iterating down */ | ||
1877 | + | ||
1878 | + mutex_lock(&mgr->lock); | ||
1879 | mstb = mgr->mst_primary; | ||
1880 | |||
1881 | for (i = 0; i < lct - 1; i++) { | ||
1882 | @@ -1171,6 +1173,7 @@ static struct drm_dp_mst_branch *drm_dp_get_mst_branch_device(struct drm_dp_mst_ | ||
1883 | } | ||
1884 | } | ||
1885 | kref_get(&mstb->kref); | ||
1886 | + mutex_unlock(&mgr->lock); | ||
1887 | return mstb; | ||
1888 | } | ||
1889 | |||
1890 | @@ -1178,7 +1181,7 @@ static void drm_dp_check_and_send_link_address(struct drm_dp_mst_topology_mgr *m | ||
1891 | struct drm_dp_mst_branch *mstb) | ||
1892 | { | ||
1893 | struct drm_dp_mst_port *port; | ||
1894 | - | ||
1895 | + struct drm_dp_mst_branch *mstb_child; | ||
1896 | if (!mstb->link_address_sent) { | ||
1897 | drm_dp_send_link_address(mgr, mstb); | ||
1898 | mstb->link_address_sent = true; | ||
1899 | @@ -1193,17 +1196,31 @@ static void drm_dp_check_and_send_link_address(struct drm_dp_mst_topology_mgr *m | ||
1900 | if (!port->available_pbn) | ||
1901 | drm_dp_send_enum_path_resources(mgr, mstb, port); | ||
1902 | |||
1903 | - if (port->mstb) | ||
1904 | - drm_dp_check_and_send_link_address(mgr, port->mstb); | ||
1905 | + if (port->mstb) { | ||
1906 | + mstb_child = drm_dp_get_validated_mstb_ref(mgr, port->mstb); | ||
1907 | + if (mstb_child) { | ||
1908 | + drm_dp_check_and_send_link_address(mgr, mstb_child); | ||
1909 | + drm_dp_put_mst_branch_device(mstb_child); | ||
1910 | + } | ||
1911 | + } | ||
1912 | } | ||
1913 | } | ||
1914 | |||
1915 | static void drm_dp_mst_link_probe_work(struct work_struct *work) | ||
1916 | { | ||
1917 | struct drm_dp_mst_topology_mgr *mgr = container_of(work, struct drm_dp_mst_topology_mgr, work); | ||
1918 | + struct drm_dp_mst_branch *mstb; | ||
1919 | |||
1920 | - drm_dp_check_and_send_link_address(mgr, mgr->mst_primary); | ||
1921 | - | ||
1922 | + mutex_lock(&mgr->lock); | ||
1923 | + mstb = mgr->mst_primary; | ||
1924 | + if (mstb) { | ||
1925 | + kref_get(&mstb->kref); | ||
1926 | + } | ||
1927 | + mutex_unlock(&mgr->lock); | ||
1928 | + if (mstb) { | ||
1929 | + drm_dp_check_and_send_link_address(mgr, mstb); | ||
1930 | + drm_dp_put_mst_branch_device(mstb); | ||
1931 | + } | ||
1932 | } | ||
1933 | |||
1934 | static bool drm_dp_validate_guid(struct drm_dp_mst_topology_mgr *mgr, | ||
1935 | diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h | ||
1936 | index e08a4729596b..9bf747f2a32b 100644 | ||
1937 | --- a/drivers/gpu/drm/i915/i915_reg.h | ||
1938 | +++ b/drivers/gpu/drm/i915/i915_reg.h | ||
1939 | @@ -5768,6 +5768,7 @@ enum punit_power_well { | ||
1940 | #define HSW_ROW_CHICKEN3_L3_GLOBAL_ATOMICS_DISABLE (1 << 6) | ||
1941 | |||
1942 | #define HALF_SLICE_CHICKEN3 0xe184 | ||
1943 | +#define HSW_SAMPLE_C_PERFORMANCE (1<<9) | ||
1944 | #define GEN8_CENTROID_PIXEL_OPT_DIS (1<<8) | ||
1945 | #define GEN8_SAMPLER_POWER_BYPASS_DIS (1<<1) | ||
1946 | |||
1947 | diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c | ||
1948 | index a29db0a1da42..3104d06aa20c 100644 | ||
1949 | --- a/drivers/gpu/drm/i915/intel_dp.c | ||
1950 | +++ b/drivers/gpu/drm/i915/intel_dp.c | ||
1951 | @@ -778,10 +778,8 @@ intel_dp_aux_ch(struct intel_dp *intel_dp, | ||
1952 | DP_AUX_CH_CTL_RECEIVE_ERROR)) | ||
1953 | continue; | ||
1954 | if (status & DP_AUX_CH_CTL_DONE) | ||
1955 | - break; | ||
1956 | + goto done; | ||
1957 | } | ||
1958 | - if (status & DP_AUX_CH_CTL_DONE) | ||
1959 | - break; | ||
1960 | } | ||
1961 | |||
1962 | if ((status & DP_AUX_CH_CTL_DONE) == 0) { | ||
1963 | @@ -790,6 +788,7 @@ intel_dp_aux_ch(struct intel_dp *intel_dp, | ||
1964 | goto out; | ||
1965 | } | ||
1966 | |||
1967 | +done: | ||
1968 | /* Check for timeout or receive error. | ||
1969 | * Timeouts occur when the sink is not connected | ||
1970 | */ | ||
1971 | diff --git a/drivers/gpu/drm/i915/intel_i2c.c b/drivers/gpu/drm/i915/intel_i2c.c | ||
1972 | index 56e437e31580..ae628001fd97 100644 | ||
1973 | --- a/drivers/gpu/drm/i915/intel_i2c.c | ||
1974 | +++ b/drivers/gpu/drm/i915/intel_i2c.c | ||
1975 | @@ -435,7 +435,7 @@ gmbus_xfer(struct i2c_adapter *adapter, | ||
1976 | struct intel_gmbus, | ||
1977 | adapter); | ||
1978 | struct drm_i915_private *dev_priv = bus->dev_priv; | ||
1979 | - int i, reg_offset; | ||
1980 | + int i = 0, inc, try = 0, reg_offset; | ||
1981 | int ret = 0; | ||
1982 | |||
1983 | intel_aux_display_runtime_get(dev_priv); | ||
1984 | @@ -448,12 +448,14 @@ gmbus_xfer(struct i2c_adapter *adapter, | ||
1985 | |||
1986 | reg_offset = dev_priv->gpio_mmio_base; | ||
1987 | |||
1988 | +retry: | ||
1989 | I915_WRITE(GMBUS0 + reg_offset, bus->reg0); | ||
1990 | |||
1991 | - for (i = 0; i < num; i++) { | ||
1992 | + for (; i < num; i += inc) { | ||
1993 | + inc = 1; | ||
1994 | if (gmbus_is_index_read(msgs, i, num)) { | ||
1995 | ret = gmbus_xfer_index_read(dev_priv, &msgs[i]); | ||
1996 | - i += 1; /* set i to the index of the read xfer */ | ||
1997 | + inc = 2; /* an index read is two msgs */ | ||
1998 | } else if (msgs[i].flags & I2C_M_RD) { | ||
1999 | ret = gmbus_xfer_read(dev_priv, &msgs[i], 0); | ||
2000 | } else { | ||
2001 | @@ -525,6 +527,18 @@ clear_err: | ||
2002 | adapter->name, msgs[i].addr, | ||
2003 | (msgs[i].flags & I2C_M_RD) ? 'r' : 'w', msgs[i].len); | ||
2004 | |||
2005 | + /* | ||
2006 | + * Passive adapters sometimes NAK the first probe. Retry the first | ||
2007 | + * message once on -ENXIO for GMBUS transfers; the bit banging algorithm | ||
2008 | + * has retries internally. See also the retry loop in | ||
2009 | + * drm_do_probe_ddc_edid, which bails out on the first -ENXIO. | ||
2010 | + */ | ||
2011 | + if (ret == -ENXIO && i == 0 && try++ == 0) { | ||
2012 | + DRM_DEBUG_KMS("GMBUS [%s] NAK on first message, retry\n", | ||
2013 | + adapter->name); | ||
2014 | + goto retry; | ||
2015 | + } | ||
2016 | + | ||
2017 | goto out; | ||
2018 | |||
2019 | timeout: | ||
2020 | diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c | ||
2021 | index 83c7ecf2608a..c64f1942e8de 100644 | ||
2022 | --- a/drivers/gpu/drm/i915/intel_pm.c | ||
2023 | +++ b/drivers/gpu/drm/i915/intel_pm.c | ||
2024 | @@ -5691,6 +5691,10 @@ static void haswell_init_clock_gating(struct drm_device *dev) | ||
2025 | I915_WRITE(GEN7_GT_MODE, | ||
2026 | GEN6_WIZ_HASHING_MASK | GEN6_WIZ_HASHING_16x4); | ||
2027 | |||
2028 | + /* WaSampleCChickenBitEnable:hsw */ | ||
2029 | + I915_WRITE(HALF_SLICE_CHICKEN3, | ||
2030 | + _MASKED_BIT_ENABLE(HSW_SAMPLE_C_PERFORMANCE)); | ||
2031 | + | ||
2032 | /* WaSwitchSolVfFArbitrationPriority:hsw */ | ||
2033 | I915_WRITE(GAM_ECOCHK, I915_READ(GAM_ECOCHK) | HSW_ECOCHK_ARB_PRIO_SOL); | ||
2034 | |||
2035 | diff --git a/drivers/gpu/drm/mgag200/mgag200_mode.c b/drivers/gpu/drm/mgag200/mgag200_mode.c | ||
2036 | index 83485ab81ce8..d8e693d1f6d4 100644 | ||
2037 | --- a/drivers/gpu/drm/mgag200/mgag200_mode.c | ||
2038 | +++ b/drivers/gpu/drm/mgag200/mgag200_mode.c | ||
2039 | @@ -1525,6 +1525,11 @@ static int mga_vga_mode_valid(struct drm_connector *connector, | ||
2040 | return MODE_BANDWIDTH; | ||
2041 | } | ||
2042 | |||
2043 | + if ((mode->hdisplay % 8) != 0 || (mode->hsync_start % 8) != 0 || | ||
2044 | + (mode->hsync_end % 8) != 0 || (mode->htotal % 8) != 0) { | ||
2045 | + return MODE_H_ILLEGAL; | ||
2046 | + } | ||
2047 | + | ||
2048 | if (mode->crtc_hdisplay > 2048 || mode->crtc_hsync_start > 4096 || | ||
2049 | mode->crtc_hsync_end > 4096 || mode->crtc_htotal > 4096 || | ||
2050 | mode->crtc_vdisplay > 2048 || mode->crtc_vsync_start > 4096 || | ||
2051 | diff --git a/drivers/gpu/drm/qxl/qxl_cmd.c b/drivers/gpu/drm/qxl/qxl_cmd.c | ||
2052 | index 97823644d347..f33251d67914 100644 | ||
2053 | --- a/drivers/gpu/drm/qxl/qxl_cmd.c | ||
2054 | +++ b/drivers/gpu/drm/qxl/qxl_cmd.c | ||
2055 | @@ -505,6 +505,7 @@ int qxl_hw_surface_alloc(struct qxl_device *qdev, | ||
2056 | |||
2057 | cmd = (struct qxl_surface_cmd *)qxl_release_map(qdev, release); | ||
2058 | cmd->type = QXL_SURFACE_CMD_CREATE; | ||
2059 | + cmd->flags = QXL_SURF_FLAG_KEEP_DATA; | ||
2060 | cmd->u.surface_create.format = surf->surf.format; | ||
2061 | cmd->u.surface_create.width = surf->surf.width; | ||
2062 | cmd->u.surface_create.height = surf->surf.height; | ||
2063 | diff --git a/drivers/gpu/drm/qxl/qxl_ioctl.c b/drivers/gpu/drm/qxl/qxl_ioctl.c | ||
2064 | index b110883f8253..7354a4cda59d 100644 | ||
2065 | --- a/drivers/gpu/drm/qxl/qxl_ioctl.c | ||
2066 | +++ b/drivers/gpu/drm/qxl/qxl_ioctl.c | ||
2067 | @@ -122,8 +122,10 @@ static struct qxl_bo *qxlhw_handle_to_bo(struct qxl_device *qdev, | ||
2068 | qobj = gem_to_qxl_bo(gobj); | ||
2069 | |||
2070 | ret = qxl_release_list_add(release, qobj); | ||
2071 | - if (ret) | ||
2072 | + if (ret) { | ||
2073 | + drm_gem_object_unreference_unlocked(gobj); | ||
2074 | return NULL; | ||
2075 | + } | ||
2076 | |||
2077 | return qobj; | ||
2078 | } | ||
2079 | diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c | ||
2080 | index 4f9ec36698f7..ce8cab52285b 100644 | ||
2081 | --- a/drivers/gpu/drm/radeon/atombios_crtc.c | ||
2082 | +++ b/drivers/gpu/drm/radeon/atombios_crtc.c | ||
2083 | @@ -580,9 +580,6 @@ static u32 atombios_adjust_pll(struct drm_crtc *crtc, | ||
2084 | else | ||
2085 | radeon_crtc->pll_flags |= RADEON_PLL_PREFER_LOW_REF_DIV; | ||
2086 | |||
2087 | - /* if there is no audio, set MINM_OVER_MAXP */ | ||
2088 | - if (!drm_detect_monitor_audio(radeon_connector_edid(connector))) | ||
2089 | - radeon_crtc->pll_flags |= RADEON_PLL_PREFER_MINM_OVER_MAXP; | ||
2090 | if (rdev->family < CHIP_RV770) | ||
2091 | radeon_crtc->pll_flags |= RADEON_PLL_PREFER_MINM_OVER_MAXP; | ||
2092 | /* use frac fb div on APUs */ | ||
2093 | @@ -1789,9 +1786,7 @@ static int radeon_get_shared_nondp_ppll(struct drm_crtc *crtc) | ||
2094 | if ((crtc->mode.clock == test_crtc->mode.clock) && | ||
2095 | (adjusted_clock == test_adjusted_clock) && | ||
2096 | (radeon_crtc->ss_enabled == test_radeon_crtc->ss_enabled) && | ||
2097 | - (test_radeon_crtc->pll_id != ATOM_PPLL_INVALID) && | ||
2098 | - (drm_detect_monitor_audio(radeon_connector_edid(test_radeon_crtc->connector)) == | ||
2099 | - drm_detect_monitor_audio(radeon_connector_edid(radeon_crtc->connector)))) | ||
2100 | + (test_radeon_crtc->pll_id != ATOM_PPLL_INVALID)) | ||
2101 | return test_radeon_crtc->pll_id; | ||
2102 | } | ||
2103 | } | ||
2104 | diff --git a/drivers/gpu/drm/radeon/cik.c b/drivers/gpu/drm/radeon/cik.c | ||
2105 | index 63e8bff5d47a..87073e69fc0d 100644 | ||
2106 | --- a/drivers/gpu/drm/radeon/cik.c | ||
2107 | +++ b/drivers/gpu/drm/radeon/cik.c | ||
2108 | @@ -4523,6 +4523,31 @@ void cik_compute_set_wptr(struct radeon_device *rdev, | ||
2109 | WDOORBELL32(ring->doorbell_index, ring->wptr); | ||
2110 | } | ||
2111 | |||
2112 | +static void cik_compute_stop(struct radeon_device *rdev, | ||
2113 | + struct radeon_ring *ring) | ||
2114 | +{ | ||
2115 | + u32 j, tmp; | ||
2116 | + | ||
2117 | + cik_srbm_select(rdev, ring->me, ring->pipe, ring->queue, 0); | ||
2118 | + /* Disable wptr polling. */ | ||
2119 | + tmp = RREG32(CP_PQ_WPTR_POLL_CNTL); | ||
2120 | + tmp &= ~WPTR_POLL_EN; | ||
2121 | + WREG32(CP_PQ_WPTR_POLL_CNTL, tmp); | ||
2122 | + /* Disable HQD. */ | ||
2123 | + if (RREG32(CP_HQD_ACTIVE) & 1) { | ||
2124 | + WREG32(CP_HQD_DEQUEUE_REQUEST, 1); | ||
2125 | + for (j = 0; j < rdev->usec_timeout; j++) { | ||
2126 | + if (!(RREG32(CP_HQD_ACTIVE) & 1)) | ||
2127 | + break; | ||
2128 | + udelay(1); | ||
2129 | + } | ||
2130 | + WREG32(CP_HQD_DEQUEUE_REQUEST, 0); | ||
2131 | + WREG32(CP_HQD_PQ_RPTR, 0); | ||
2132 | + WREG32(CP_HQD_PQ_WPTR, 0); | ||
2133 | + } | ||
2134 | + cik_srbm_select(rdev, 0, 0, 0, 0); | ||
2135 | +} | ||
2136 | + | ||
2137 | /** | ||
2138 | * cik_cp_compute_enable - enable/disable the compute CP MEs | ||
2139 | * | ||
2140 | @@ -4536,6 +4561,15 @@ static void cik_cp_compute_enable(struct radeon_device *rdev, bool enable) | ||
2141 | if (enable) | ||
2142 | WREG32(CP_MEC_CNTL, 0); | ||
2143 | else { | ||
2144 | + /* | ||
2145 | + * To make hibernation reliable we need to clear compute ring | ||
2146 | + * configuration before halting the compute ring. | ||
2147 | + */ | ||
2148 | + mutex_lock(&rdev->srbm_mutex); | ||
2149 | + cik_compute_stop(rdev,&rdev->ring[CAYMAN_RING_TYPE_CP1_INDEX]); | ||
2150 | + cik_compute_stop(rdev,&rdev->ring[CAYMAN_RING_TYPE_CP2_INDEX]); | ||
2151 | + mutex_unlock(&rdev->srbm_mutex); | ||
2152 | + | ||
2153 | WREG32(CP_MEC_CNTL, (MEC_ME1_HALT | MEC_ME2_HALT)); | ||
2154 | rdev->ring[CAYMAN_RING_TYPE_CP1_INDEX].ready = false; | ||
2155 | rdev->ring[CAYMAN_RING_TYPE_CP2_INDEX].ready = false; | ||
2156 | diff --git a/drivers/gpu/drm/radeon/cik_sdma.c b/drivers/gpu/drm/radeon/cik_sdma.c | ||
2157 | index d748963af08b..02246acba36a 100644 | ||
2158 | --- a/drivers/gpu/drm/radeon/cik_sdma.c | ||
2159 | +++ b/drivers/gpu/drm/radeon/cik_sdma.c | ||
2160 | @@ -268,6 +268,17 @@ static void cik_sdma_gfx_stop(struct radeon_device *rdev) | ||
2161 | } | ||
2162 | rdev->ring[R600_RING_TYPE_DMA_INDEX].ready = false; | ||
2163 | rdev->ring[CAYMAN_RING_TYPE_DMA1_INDEX].ready = false; | ||
2164 | + | ||
2165 | + /* FIXME use something else than big hammer but after few days can not | ||
2166 | + * seem to find good combination so reset SDMA blocks as it seems we | ||
2167 | + * do not shut them down properly. This fix hibernation and does not | ||
2168 | + * affect suspend to ram. | ||
2169 | + */ | ||
2170 | + WREG32(SRBM_SOFT_RESET, SOFT_RESET_SDMA | SOFT_RESET_SDMA1); | ||
2171 | + (void)RREG32(SRBM_SOFT_RESET); | ||
2172 | + udelay(50); | ||
2173 | + WREG32(SRBM_SOFT_RESET, 0); | ||
2174 | + (void)RREG32(SRBM_SOFT_RESET); | ||
2175 | } | ||
2176 | |||
2177 | /** | ||
2178 | diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c | ||
2179 | index bdf263a4a67c..5d54ab0fbe2b 100644 | ||
2180 | --- a/drivers/gpu/drm/radeon/radeon_device.c | ||
2181 | +++ b/drivers/gpu/drm/radeon/radeon_device.c | ||
2182 | @@ -1426,6 +1426,21 @@ int radeon_device_init(struct radeon_device *rdev, | ||
2183 | if (r) | ||
2184 | DRM_ERROR("ib ring test failed (%d).\n", r); | ||
2185 | |||
2186 | + /* | ||
2187 | + * Turks/Thames GPU will freeze whole laptop if DPM is not restarted | ||
2188 | + * after the CP ring have chew one packet at least. Hence here we stop | ||
2189 | + * and restart DPM after the radeon_ib_ring_tests(). | ||
2190 | + */ | ||
2191 | + if (rdev->pm.dpm_enabled && | ||
2192 | + (rdev->pm.pm_method == PM_METHOD_DPM) && | ||
2193 | + (rdev->family == CHIP_TURKS) && | ||
2194 | + (rdev->flags & RADEON_IS_MOBILITY)) { | ||
2195 | + mutex_lock(&rdev->pm.mutex); | ||
2196 | + radeon_dpm_disable(rdev); | ||
2197 | + radeon_dpm_enable(rdev); | ||
2198 | + mutex_unlock(&rdev->pm.mutex); | ||
2199 | + } | ||
2200 | + | ||
2201 | if ((radeon_testing & 1)) { | ||
2202 | if (rdev->accel_working) | ||
2203 | radeon_test_moves(rdev); | ||
2204 | diff --git a/drivers/gpu/drm/radeon/radeon_irq_kms.c b/drivers/gpu/drm/radeon/radeon_irq_kms.c | ||
2205 | index 00fc59762e0d..bbcd754dc7d0 100644 | ||
2206 | --- a/drivers/gpu/drm/radeon/radeon_irq_kms.c | ||
2207 | +++ b/drivers/gpu/drm/radeon/radeon_irq_kms.c | ||
2208 | @@ -79,10 +79,12 @@ static void radeon_hotplug_work_func(struct work_struct *work) | ||
2209 | struct drm_mode_config *mode_config = &dev->mode_config; | ||
2210 | struct drm_connector *connector; | ||
2211 | |||
2212 | + mutex_lock(&mode_config->mutex); | ||
2213 | if (mode_config->num_connector) { | ||
2214 | list_for_each_entry(connector, &mode_config->connector_list, head) | ||
2215 | radeon_connector_hotplug(connector); | ||
2216 | } | ||
2217 | + mutex_unlock(&mode_config->mutex); | ||
2218 | /* Just fire off a uevent and let userspace tell us what to do */ | ||
2219 | drm_helper_hpd_irq_event(dev); | ||
2220 | } | ||
2221 | diff --git a/drivers/gpu/drm/radeon/radeon_kms.c b/drivers/gpu/drm/radeon/radeon_kms.c | ||
2222 | index 8ec652722e4f..46bcd5d38a1e 100644 | ||
2223 | --- a/drivers/gpu/drm/radeon/radeon_kms.c | ||
2224 | +++ b/drivers/gpu/drm/radeon/radeon_kms.c | ||
2225 | @@ -540,6 +540,9 @@ static int radeon_info_ioctl(struct drm_device *dev, void *data, struct drm_file | ||
2226 | else | ||
2227 | *value = 1; | ||
2228 | break; | ||
2229 | + case RADEON_INFO_VA_UNMAP_WORKING: | ||
2230 | + *value = true; | ||
2231 | + break; | ||
2232 | default: | ||
2233 | DRM_DEBUG_KMS("Invalid request %d\n", info->request); | ||
2234 | return -EINVAL; | ||
2235 | diff --git a/drivers/gpu/drm/radeon/radeon_vm.c b/drivers/gpu/drm/radeon/radeon_vm.c | ||
2236 | index 2ab80a5331a4..190eb5bee4eb 100644 | ||
2237 | --- a/drivers/gpu/drm/radeon/radeon_vm.c | ||
2238 | +++ b/drivers/gpu/drm/radeon/radeon_vm.c | ||
2239 | @@ -513,6 +513,8 @@ int radeon_vm_bo_set_addr(struct radeon_device *rdev, | ||
2240 | tmp->addr = bo_va->addr; | ||
2241 | tmp->bo = radeon_bo_ref(bo_va->bo); | ||
2242 | list_add(&tmp->vm_status, &vm->freed); | ||
2243 | + | ||
2244 | + bo_va->addr = 0; | ||
2245 | } | ||
2246 | |||
2247 | interval_tree_remove(&bo_va->it, &vm->va); | ||
2248 | @@ -1058,7 +1060,8 @@ void radeon_vm_bo_rmv(struct radeon_device *rdev, | ||
2249 | list_del(&bo_va->bo_list); | ||
2250 | |||
2251 | mutex_lock(&vm->mutex); | ||
2252 | - interval_tree_remove(&bo_va->it, &vm->va); | ||
2253 | + if (bo_va->it.start || bo_va->it.last) | ||
2254 | + interval_tree_remove(&bo_va->it, &vm->va); | ||
2255 | list_del(&bo_va->vm_status); | ||
2256 | |||
2257 | if (bo_va->addr) { | ||
2258 | diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c | ||
2259 | index 77ba023cab95..7eda03c13805 100644 | ||
2260 | --- a/drivers/hid/hid-core.c | ||
2261 | +++ b/drivers/hid/hid-core.c | ||
2262 | @@ -1919,6 +1919,7 @@ static const struct hid_device_id hid_have_special_driver[] = { | ||
2263 | { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) }, | ||
2264 | { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) }, | ||
2265 | { HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) }, | ||
2266 | + { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE) }, | ||
2267 | { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER) }, | ||
2268 | { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER) }, | ||
2269 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE) }, | ||
2270 | diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h | ||
2271 | index 07e19295fad9..252a7ed40f86 100644 | ||
2272 | --- a/drivers/hid/hid-ids.h | ||
2273 | +++ b/drivers/hid/hid-ids.h | ||
2274 | @@ -829,6 +829,9 @@ | ||
2275 | #define USB_VENDOR_ID_SKYCABLE 0x1223 | ||
2276 | #define USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER 0x3F07 | ||
2277 | |||
2278 | +#define USB_VENDOR_ID_SMK 0x0609 | ||
2279 | +#define USB_DEVICE_ID_SMK_PS3_BDREMOTE 0x0306 | ||
2280 | + | ||
2281 | #define USB_VENDOR_ID_SONY 0x054c | ||
2282 | #define USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE 0x024b | ||
2283 | #define USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE 0x0374 | ||
2284 | diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c | ||
2285 | index bc4269e559f1..15b3475e641d 100644 | ||
2286 | --- a/drivers/hid/hid-sony.c | ||
2287 | +++ b/drivers/hid/hid-sony.c | ||
2288 | @@ -2034,6 +2034,9 @@ static const struct hid_device_id sony_devices[] = { | ||
2289 | /* Logitech Harmony Adapter for PS3 */ | ||
2290 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3), | ||
2291 | .driver_data = PS3REMOTE }, | ||
2292 | + /* SMK-Link PS3 BD Remote Control */ | ||
2293 | + { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE), | ||
2294 | + .driver_data = PS3REMOTE }, | ||
2295 | /* Sony Dualshock 4 controllers for PS4 */ | ||
2296 | { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER), | ||
2297 | .driver_data = DUALSHOCK4_CONTROLLER_USB }, | ||
2298 | diff --git a/drivers/hwmon/mcp3021.c b/drivers/hwmon/mcp3021.c | ||
2299 | index d219c06a857b..972444a14cca 100644 | ||
2300 | --- a/drivers/hwmon/mcp3021.c | ||
2301 | +++ b/drivers/hwmon/mcp3021.c | ||
2302 | @@ -31,14 +31,11 @@ | ||
2303 | /* output format */ | ||
2304 | #define MCP3021_SAR_SHIFT 2 | ||
2305 | #define MCP3021_SAR_MASK 0x3ff | ||
2306 | - | ||
2307 | #define MCP3021_OUTPUT_RES 10 /* 10-bit resolution */ | ||
2308 | -#define MCP3021_OUTPUT_SCALE 4 | ||
2309 | |||
2310 | #define MCP3221_SAR_SHIFT 0 | ||
2311 | #define MCP3221_SAR_MASK 0xfff | ||
2312 | #define MCP3221_OUTPUT_RES 12 /* 12-bit resolution */ | ||
2313 | -#define MCP3221_OUTPUT_SCALE 1 | ||
2314 | |||
2315 | enum chips { | ||
2316 | mcp3021, | ||
2317 | @@ -54,7 +51,6 @@ struct mcp3021_data { | ||
2318 | u16 sar_shift; | ||
2319 | u16 sar_mask; | ||
2320 | u8 output_res; | ||
2321 | - u8 output_scale; | ||
2322 | }; | ||
2323 | |||
2324 | static int mcp3021_read16(struct i2c_client *client) | ||
2325 | @@ -84,13 +80,7 @@ static int mcp3021_read16(struct i2c_client *client) | ||
2326 | |||
2327 | static inline u16 volts_from_reg(struct mcp3021_data *data, u16 val) | ||
2328 | { | ||
2329 | - if (val == 0) | ||
2330 | - return 0; | ||
2331 | - | ||
2332 | - val = val * data->output_scale - data->output_scale / 2; | ||
2333 | - | ||
2334 | - return val * DIV_ROUND_CLOSEST(data->vdd, | ||
2335 | - (1 << data->output_res) * data->output_scale); | ||
2336 | + return DIV_ROUND_CLOSEST(data->vdd * val, 1 << data->output_res); | ||
2337 | } | ||
2338 | |||
2339 | static ssize_t show_in_input(struct device *dev, struct device_attribute *attr, | ||
2340 | @@ -132,14 +122,12 @@ static int mcp3021_probe(struct i2c_client *client, | ||
2341 | data->sar_shift = MCP3021_SAR_SHIFT; | ||
2342 | data->sar_mask = MCP3021_SAR_MASK; | ||
2343 | data->output_res = MCP3021_OUTPUT_RES; | ||
2344 | - data->output_scale = MCP3021_OUTPUT_SCALE; | ||
2345 | break; | ||
2346 | |||
2347 | case mcp3221: | ||
2348 | data->sar_shift = MCP3221_SAR_SHIFT; | ||
2349 | data->sar_mask = MCP3221_SAR_MASK; | ||
2350 | data->output_res = MCP3221_OUTPUT_RES; | ||
2351 | - data->output_scale = MCP3221_OUTPUT_SCALE; | ||
2352 | break; | ||
2353 | } | ||
2354 | |||
2355 | diff --git a/drivers/i2c/busses/i2c-at91.c b/drivers/i2c/busses/i2c-at91.c | ||
2356 | index e05a672db3e5..85d2f6b51c3c 100644 | ||
2357 | --- a/drivers/i2c/busses/i2c-at91.c | ||
2358 | +++ b/drivers/i2c/busses/i2c-at91.c | ||
2359 | @@ -62,6 +62,9 @@ | ||
2360 | #define AT91_TWI_UNRE 0x0080 /* Underrun Error */ | ||
2361 | #define AT91_TWI_NACK 0x0100 /* Not Acknowledged */ | ||
2362 | |||
2363 | +#define AT91_TWI_INT_MASK \ | ||
2364 | + (AT91_TWI_TXCOMP | AT91_TWI_RXRDY | AT91_TWI_TXRDY | AT91_TWI_NACK) | ||
2365 | + | ||
2366 | #define AT91_TWI_IER 0x0024 /* Interrupt Enable Register */ | ||
2367 | #define AT91_TWI_IDR 0x0028 /* Interrupt Disable Register */ | ||
2368 | #define AT91_TWI_IMR 0x002c /* Interrupt Mask Register */ | ||
2369 | @@ -117,13 +120,12 @@ static void at91_twi_write(struct at91_twi_dev *dev, unsigned reg, unsigned val) | ||
2370 | |||
2371 | static void at91_disable_twi_interrupts(struct at91_twi_dev *dev) | ||
2372 | { | ||
2373 | - at91_twi_write(dev, AT91_TWI_IDR, | ||
2374 | - AT91_TWI_TXCOMP | AT91_TWI_RXRDY | AT91_TWI_TXRDY); | ||
2375 | + at91_twi_write(dev, AT91_TWI_IDR, AT91_TWI_INT_MASK); | ||
2376 | } | ||
2377 | |||
2378 | static void at91_twi_irq_save(struct at91_twi_dev *dev) | ||
2379 | { | ||
2380 | - dev->imr = at91_twi_read(dev, AT91_TWI_IMR) & 0x7; | ||
2381 | + dev->imr = at91_twi_read(dev, AT91_TWI_IMR) & AT91_TWI_INT_MASK; | ||
2382 | at91_disable_twi_interrupts(dev); | ||
2383 | } | ||
2384 | |||
2385 | @@ -213,6 +215,14 @@ static void at91_twi_write_data_dma_callback(void *data) | ||
2386 | dma_unmap_single(dev->dev, sg_dma_address(&dev->dma.sg), | ||
2387 | dev->buf_len, DMA_TO_DEVICE); | ||
2388 | |||
2389 | + /* | ||
2390 | + * When this callback is called, THR/TX FIFO is likely not to be empty | ||
2391 | + * yet. So we have to wait for TXCOMP or NACK bits to be set into the | ||
2392 | + * Status Register to be sure that the STOP bit has been sent and the | ||
2393 | + * transfer is completed. The NACK interrupt has already been enabled, | ||
2394 | + * we just have to enable TXCOMP one. | ||
2395 | + */ | ||
2396 | + at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_TXCOMP); | ||
2397 | at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_STOP); | ||
2398 | } | ||
2399 | |||
2400 | @@ -307,7 +317,7 @@ static void at91_twi_read_data_dma_callback(void *data) | ||
2401 | /* The last two bytes have to be read without using dma */ | ||
2402 | dev->buf += dev->buf_len - 2; | ||
2403 | dev->buf_len = 2; | ||
2404 | - at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_RXRDY); | ||
2405 | + at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_RXRDY | AT91_TWI_TXCOMP); | ||
2406 | } | ||
2407 | |||
2408 | static void at91_twi_read_data_dma(struct at91_twi_dev *dev) | ||
2409 | @@ -368,7 +378,7 @@ static irqreturn_t atmel_twi_interrupt(int irq, void *dev_id) | ||
2410 | /* catch error flags */ | ||
2411 | dev->transfer_status |= status; | ||
2412 | |||
2413 | - if (irqstatus & AT91_TWI_TXCOMP) { | ||
2414 | + if (irqstatus & (AT91_TWI_TXCOMP | AT91_TWI_NACK)) { | ||
2415 | at91_disable_twi_interrupts(dev); | ||
2416 | complete(&dev->cmd_complete); | ||
2417 | } | ||
2418 | @@ -381,6 +391,34 @@ static int at91_do_twi_transfer(struct at91_twi_dev *dev) | ||
2419 | int ret; | ||
2420 | bool has_unre_flag = dev->pdata->has_unre_flag; | ||
2421 | |||
2422 | + /* | ||
2423 | + * WARNING: the TXCOMP bit in the Status Register is NOT a clear on | ||
2424 | + * read flag but shows the state of the transmission at the time the | ||
2425 | + * Status Register is read. According to the programmer datasheet, | ||
2426 | + * TXCOMP is set when both holding register and internal shifter are | ||
2427 | + * empty and STOP condition has been sent. | ||
2428 | + * Consequently, we should enable NACK interrupt rather than TXCOMP to | ||
2429 | + * detect transmission failure. | ||
2430 | + * | ||
2431 | + * Besides, the TXCOMP bit is already set before the i2c transaction | ||
2432 | + * has been started. For read transactions, this bit is cleared when | ||
2433 | + * writing the START bit into the Control Register. So the | ||
2434 | + * corresponding interrupt can safely be enabled just after. | ||
2435 | + * However for write transactions managed by the CPU, we first write | ||
2436 | + * into THR, so TXCOMP is cleared. Then we can safely enable TXCOMP | ||
2437 | + * interrupt. If TXCOMP interrupt were enabled before writing into THR, | ||
2438 | + * the interrupt handler would be called immediately and the i2c command | ||
2439 | + * would be reported as completed. | ||
2440 | + * Also when a write transaction is managed by the DMA controller, | ||
2441 | + * enabling the TXCOMP interrupt in this function may lead to a race | ||
2442 | + * condition since we don't know whether the TXCOMP interrupt is enabled | ||
2443 | + * before or after the DMA has started to write into THR. So the TXCOMP | ||
2444 | + * interrupt is enabled later by at91_twi_write_data_dma_callback(). | ||
2445 | + * Immediately after in that DMA callback, we still need to send the | ||
2446 | + * STOP condition manually writing the corresponding bit into the | ||
2447 | + * Control Register. | ||
2448 | + */ | ||
2449 | + | ||
2450 | dev_dbg(dev->dev, "transfer: %s %d bytes.\n", | ||
2451 | (dev->msg->flags & I2C_M_RD) ? "read" : "write", dev->buf_len); | ||
2452 | |||
2453 | @@ -411,26 +449,24 @@ static int at91_do_twi_transfer(struct at91_twi_dev *dev) | ||
2454 | * seems to be the best solution. | ||
2455 | */ | ||
2456 | if (dev->use_dma && (dev->buf_len > AT91_I2C_DMA_THRESHOLD)) { | ||
2457 | + at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_NACK); | ||
2458 | at91_twi_read_data_dma(dev); | ||
2459 | - /* | ||
2460 | - * It is important to enable TXCOMP irq here because | ||
2461 | - * doing it only when transferring the last two bytes | ||
2462 | - * will mask NACK errors since TXCOMP is set when a | ||
2463 | - * NACK occurs. | ||
2464 | - */ | ||
2465 | - at91_twi_write(dev, AT91_TWI_IER, | ||
2466 | - AT91_TWI_TXCOMP); | ||
2467 | - } else | ||
2468 | + } else { | ||
2469 | at91_twi_write(dev, AT91_TWI_IER, | ||
2470 | - AT91_TWI_TXCOMP | AT91_TWI_RXRDY); | ||
2471 | + AT91_TWI_TXCOMP | | ||
2472 | + AT91_TWI_NACK | | ||
2473 | + AT91_TWI_RXRDY); | ||
2474 | + } | ||
2475 | } else { | ||
2476 | if (dev->use_dma && (dev->buf_len > AT91_I2C_DMA_THRESHOLD)) { | ||
2477 | + at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_NACK); | ||
2478 | at91_twi_write_data_dma(dev); | ||
2479 | - at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_TXCOMP); | ||
2480 | } else { | ||
2481 | at91_twi_write_next_byte(dev); | ||
2482 | at91_twi_write(dev, AT91_TWI_IER, | ||
2483 | - AT91_TWI_TXCOMP | AT91_TWI_TXRDY); | ||
2484 | + AT91_TWI_TXCOMP | | ||
2485 | + AT91_TWI_NACK | | ||
2486 | + AT91_TWI_TXRDY); | ||
2487 | } | ||
2488 | } | ||
2489 | |||
2490 | diff --git a/drivers/iio/imu/adis16400.h b/drivers/iio/imu/adis16400.h | ||
2491 | index 0916bf6b6c31..1e8fd2e81d45 100644 | ||
2492 | --- a/drivers/iio/imu/adis16400.h | ||
2493 | +++ b/drivers/iio/imu/adis16400.h | ||
2494 | @@ -165,6 +165,7 @@ struct adis16400_state { | ||
2495 | int filt_int; | ||
2496 | |||
2497 | struct adis adis; | ||
2498 | + unsigned long avail_scan_mask[2]; | ||
2499 | }; | ||
2500 | |||
2501 | /* At the moment triggers are only used for ring buffer | ||
2502 | diff --git a/drivers/iio/imu/adis16400_core.c b/drivers/iio/imu/adis16400_core.c | ||
2503 | index fa795dcd5f75..7b06e058b000 100644 | ||
2504 | --- a/drivers/iio/imu/adis16400_core.c | ||
2505 | +++ b/drivers/iio/imu/adis16400_core.c | ||
2506 | @@ -405,6 +405,11 @@ static int adis16400_read_raw(struct iio_dev *indio_dev, | ||
2507 | *val = st->variant->temp_scale_nano / 1000000; | ||
2508 | *val2 = (st->variant->temp_scale_nano % 1000000); | ||
2509 | return IIO_VAL_INT_PLUS_MICRO; | ||
2510 | + case IIO_PRESSURE: | ||
2511 | + /* 20 uBar = 0.002kPascal */ | ||
2512 | + *val = 0; | ||
2513 | + *val2 = 2000; | ||
2514 | + return IIO_VAL_INT_PLUS_MICRO; | ||
2515 | default: | ||
2516 | return -EINVAL; | ||
2517 | } | ||
2518 | @@ -454,10 +459,10 @@ static int adis16400_read_raw(struct iio_dev *indio_dev, | ||
2519 | } | ||
2520 | } | ||
2521 | |||
2522 | -#define ADIS16400_VOLTAGE_CHAN(addr, bits, name, si) { \ | ||
2523 | +#define ADIS16400_VOLTAGE_CHAN(addr, bits, name, si, chn) { \ | ||
2524 | .type = IIO_VOLTAGE, \ | ||
2525 | .indexed = 1, \ | ||
2526 | - .channel = 0, \ | ||
2527 | + .channel = chn, \ | ||
2528 | .extend_name = name, \ | ||
2529 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ | ||
2530 | BIT(IIO_CHAN_INFO_SCALE), \ | ||
2531 | @@ -474,10 +479,10 @@ static int adis16400_read_raw(struct iio_dev *indio_dev, | ||
2532 | } | ||
2533 | |||
2534 | #define ADIS16400_SUPPLY_CHAN(addr, bits) \ | ||
2535 | - ADIS16400_VOLTAGE_CHAN(addr, bits, "supply", ADIS16400_SCAN_SUPPLY) | ||
2536 | + ADIS16400_VOLTAGE_CHAN(addr, bits, "supply", ADIS16400_SCAN_SUPPLY, 0) | ||
2537 | |||
2538 | #define ADIS16400_AUX_ADC_CHAN(addr, bits) \ | ||
2539 | - ADIS16400_VOLTAGE_CHAN(addr, bits, NULL, ADIS16400_SCAN_ADC) | ||
2540 | + ADIS16400_VOLTAGE_CHAN(addr, bits, NULL, ADIS16400_SCAN_ADC, 1) | ||
2541 | |||
2542 | #define ADIS16400_GYRO_CHAN(mod, addr, bits) { \ | ||
2543 | .type = IIO_ANGL_VEL, \ | ||
2544 | @@ -791,11 +796,6 @@ static const struct iio_info adis16400_info = { | ||
2545 | .debugfs_reg_access = adis_debugfs_reg_access, | ||
2546 | }; | ||
2547 | |||
2548 | -static const unsigned long adis16400_burst_scan_mask[] = { | ||
2549 | - ~0UL, | ||
2550 | - 0, | ||
2551 | -}; | ||
2552 | - | ||
2553 | static const char * const adis16400_status_error_msgs[] = { | ||
2554 | [ADIS16400_DIAG_STAT_ZACCL_FAIL] = "Z-axis accelerometer self-test failure", | ||
2555 | [ADIS16400_DIAG_STAT_YACCL_FAIL] = "Y-axis accelerometer self-test failure", | ||
2556 | @@ -843,6 +843,20 @@ static const struct adis_data adis16400_data = { | ||
2557 | BIT(ADIS16400_DIAG_STAT_POWER_LOW), | ||
2558 | }; | ||
2559 | |||
2560 | +static void adis16400_setup_chan_mask(struct adis16400_state *st) | ||
2561 | +{ | ||
2562 | + const struct adis16400_chip_info *chip_info = st->variant; | ||
2563 | + unsigned i; | ||
2564 | + | ||
2565 | + for (i = 0; i < chip_info->num_channels; i++) { | ||
2566 | + const struct iio_chan_spec *ch = &chip_info->channels[i]; | ||
2567 | + | ||
2568 | + if (ch->scan_index >= 0 && | ||
2569 | + ch->scan_index != ADIS16400_SCAN_TIMESTAMP) | ||
2570 | + st->avail_scan_mask[0] |= BIT(ch->scan_index); | ||
2571 | + } | ||
2572 | +} | ||
2573 | + | ||
2574 | static int adis16400_probe(struct spi_device *spi) | ||
2575 | { | ||
2576 | struct adis16400_state *st; | ||
2577 | @@ -866,8 +880,10 @@ static int adis16400_probe(struct spi_device *spi) | ||
2578 | indio_dev->info = &adis16400_info; | ||
2579 | indio_dev->modes = INDIO_DIRECT_MODE; | ||
2580 | |||
2581 | - if (!(st->variant->flags & ADIS16400_NO_BURST)) | ||
2582 | - indio_dev->available_scan_masks = adis16400_burst_scan_mask; | ||
2583 | + if (!(st->variant->flags & ADIS16400_NO_BURST)) { | ||
2584 | + adis16400_setup_chan_mask(st); | ||
2585 | + indio_dev->available_scan_masks = st->avail_scan_mask; | ||
2586 | + } | ||
2587 | |||
2588 | ret = adis_init(&st->adis, indio_dev, spi, &adis16400_data); | ||
2589 | if (ret) | ||
2590 | diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c | ||
2591 | index 0618e407197d..02c494a8d111 100644 | ||
2592 | --- a/drivers/infiniband/ulp/isert/ib_isert.c | ||
2593 | +++ b/drivers/infiniband/ulp/isert/ib_isert.c | ||
2594 | @@ -61,6 +61,8 @@ static int | ||
2595 | isert_rdma_accept(struct isert_conn *isert_conn); | ||
2596 | struct rdma_cm_id *isert_setup_id(struct isert_np *isert_np); | ||
2597 | |||
2598 | +static void isert_release_work(struct work_struct *work); | ||
2599 | + | ||
2600 | static inline bool | ||
2601 | isert_prot_cmd(struct isert_conn *conn, struct se_cmd *cmd) | ||
2602 | { | ||
2603 | @@ -624,6 +626,7 @@ isert_connect_request(struct rdma_cm_id *cma_id, struct rdma_cm_event *event) | ||
2604 | mutex_init(&isert_conn->conn_mutex); | ||
2605 | spin_lock_init(&isert_conn->conn_lock); | ||
2606 | INIT_LIST_HEAD(&isert_conn->conn_fr_pool); | ||
2607 | + INIT_WORK(&isert_conn->release_work, isert_release_work); | ||
2608 | |||
2609 | isert_conn->conn_cm_id = cma_id; | ||
2610 | |||
2611 | @@ -891,6 +894,7 @@ isert_disconnected_handler(struct rdma_cm_id *cma_id, | ||
2612 | { | ||
2613 | struct isert_np *isert_np = cma_id->context; | ||
2614 | struct isert_conn *isert_conn; | ||
2615 | + bool terminating = false; | ||
2616 | |||
2617 | if (isert_np->np_cm_id == cma_id) | ||
2618 | return isert_np_cma_handler(cma_id->context, event); | ||
2619 | @@ -898,12 +902,25 @@ isert_disconnected_handler(struct rdma_cm_id *cma_id, | ||
2620 | isert_conn = cma_id->qp->qp_context; | ||
2621 | |||
2622 | mutex_lock(&isert_conn->conn_mutex); | ||
2623 | + terminating = (isert_conn->state == ISER_CONN_TERMINATING); | ||
2624 | isert_conn_terminate(isert_conn); | ||
2625 | mutex_unlock(&isert_conn->conn_mutex); | ||
2626 | |||
2627 | pr_info("conn %p completing conn_wait\n", isert_conn); | ||
2628 | complete(&isert_conn->conn_wait); | ||
2629 | |||
2630 | + if (terminating) | ||
2631 | + goto out; | ||
2632 | + | ||
2633 | + mutex_lock(&isert_np->np_accept_mutex); | ||
2634 | + if (!list_empty(&isert_conn->conn_accept_node)) { | ||
2635 | + list_del_init(&isert_conn->conn_accept_node); | ||
2636 | + isert_put_conn(isert_conn); | ||
2637 | + queue_work(isert_release_wq, &isert_conn->release_work); | ||
2638 | + } | ||
2639 | + mutex_unlock(&isert_np->np_accept_mutex); | ||
2640 | + | ||
2641 | +out: | ||
2642 | return 0; | ||
2643 | } | ||
2644 | |||
2645 | @@ -2485,7 +2502,6 @@ isert_build_rdma_wr(struct isert_conn *isert_conn, struct isert_cmd *isert_cmd, | ||
2646 | page_off = offset % PAGE_SIZE; | ||
2647 | |||
2648 | send_wr->sg_list = ib_sge; | ||
2649 | - send_wr->num_sge = sg_nents; | ||
2650 | send_wr->wr_id = (unsigned long)&isert_cmd->tx_desc; | ||
2651 | /* | ||
2652 | * Perform mapping of TCM scatterlist memory ib_sge dma_addr. | ||
2653 | @@ -2504,14 +2520,17 @@ isert_build_rdma_wr(struct isert_conn *isert_conn, struct isert_cmd *isert_cmd, | ||
2654 | ib_sge->addr, ib_sge->length, ib_sge->lkey); | ||
2655 | page_off = 0; | ||
2656 | data_left -= ib_sge->length; | ||
2657 | + if (!data_left) | ||
2658 | + break; | ||
2659 | ib_sge++; | ||
2660 | pr_debug("Incrementing ib_sge pointer to %p\n", ib_sge); | ||
2661 | } | ||
2662 | |||
2663 | + send_wr->num_sge = ++i; | ||
2664 | pr_debug("Set outgoing sg_list: %p num_sg: %u from TCM SGLs\n", | ||
2665 | send_wr->sg_list, send_wr->num_sge); | ||
2666 | |||
2667 | - return sg_nents; | ||
2668 | + return send_wr->num_sge; | ||
2669 | } | ||
2670 | |||
2671 | static int | ||
2672 | @@ -3417,7 +3436,6 @@ static void isert_wait_conn(struct iscsi_conn *conn) | ||
2673 | |||
2674 | wait_for_completion(&isert_conn->conn_wait_comp_err); | ||
2675 | |||
2676 | - INIT_WORK(&isert_conn->release_work, isert_release_work); | ||
2677 | queue_work(isert_release_wq, &isert_conn->release_work); | ||
2678 | } | ||
2679 | |||
2680 | diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c | ||
2681 | index 991dc6b20a58..aa7f9209ac6c 100644 | ||
2682 | --- a/drivers/input/mouse/elantech.c | ||
2683 | +++ b/drivers/input/mouse/elantech.c | ||
2684 | @@ -1376,10 +1376,11 @@ static bool elantech_is_signature_valid(const unsigned char *param) | ||
2685 | return true; | ||
2686 | |||
2687 | /* | ||
2688 | - * Some models have a revision higher then 20. Meaning param[2] may | ||
2689 | - * be 10 or 20, skip the rates check for these. | ||
2690 | + * Some hw_version >= 4 models have a revision higher then 20. Meaning | ||
2691 | + * that param[2] may be 10 or 20, skip the rates check for these. | ||
2692 | */ | ||
2693 | - if (param[0] == 0x46 && (param[1] & 0xef) == 0x0f && param[2] < 40) | ||
2694 | + if ((param[0] & 0x0f) >= 0x06 && (param[1] & 0xaf) == 0x0f && | ||
2695 | + param[2] < 40) | ||
2696 | return true; | ||
2697 | |||
2698 | for (i = 0; i < ARRAY_SIZE(rates); i++) | ||
2699 | diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c | ||
2700 | index 2176874a41b1..f599357e8392 100644 | ||
2701 | --- a/drivers/input/mouse/synaptics.c | ||
2702 | +++ b/drivers/input/mouse/synaptics.c | ||
2703 | @@ -148,6 +148,10 @@ static const struct min_max_quirk min_max_pnpid_table[] = { | ||
2704 | 1024, 5112, 2024, 4832 | ||
2705 | }, | ||
2706 | { | ||
2707 | + (const char * const []){"LEN2000", NULL}, | ||
2708 | + 1024, 5113, 2021, 4832 | ||
2709 | + }, | ||
2710 | + { | ||
2711 | (const char * const []){"LEN2001", NULL}, | ||
2712 | {ANY_BOARD_ID, ANY_BOARD_ID}, | ||
2713 | 1024, 5022, 2508, 4832 | ||
2714 | @@ -185,7 +189,7 @@ static const char * const topbuttonpad_pnp_ids[] = { | ||
2715 | "LEN0047", | ||
2716 | "LEN0048", | ||
2717 | "LEN0049", | ||
2718 | - "LEN2000", | ||
2719 | + "LEN2000", /* S540 */ | ||
2720 | "LEN2001", /* Edge E431 */ | ||
2721 | "LEN2002", /* Edge E531 */ | ||
2722 | "LEN2003", | ||
2723 | diff --git a/drivers/input/touchscreen/pixcir_i2c_ts.c b/drivers/input/touchscreen/pixcir_i2c_ts.c | ||
2724 | index fc49c75317d1..9788a9b4a610 100644 | ||
2725 | --- a/drivers/input/touchscreen/pixcir_i2c_ts.c | ||
2726 | +++ b/drivers/input/touchscreen/pixcir_i2c_ts.c | ||
2727 | @@ -78,7 +78,7 @@ static void pixcir_ts_parse(struct pixcir_i2c_ts_data *tsdata, | ||
2728 | } | ||
2729 | |||
2730 | ret = i2c_master_recv(tsdata->client, rdbuf, readsize); | ||
2731 | - if (ret != sizeof(rdbuf)) { | ||
2732 | + if (ret != readsize) { | ||
2733 | dev_err(&tsdata->client->dev, | ||
2734 | "%s: i2c_master_recv failed(), ret=%d\n", | ||
2735 | __func__, ret); | ||
2736 | diff --git a/drivers/irqchip/irq-sunxi-nmi.c b/drivers/irqchip/irq-sunxi-nmi.c | ||
2737 | index 12f547a44ae4..eb9b59e8f122 100644 | ||
2738 | --- a/drivers/irqchip/irq-sunxi-nmi.c | ||
2739 | +++ b/drivers/irqchip/irq-sunxi-nmi.c | ||
2740 | @@ -104,7 +104,7 @@ static int sunxi_sc_nmi_set_type(struct irq_data *data, unsigned int flow_type) | ||
2741 | irqd_set_trigger_type(data, flow_type); | ||
2742 | irq_setup_alt_chip(data, flow_type); | ||
2743 | |||
2744 | - for (i = 0; i <= gc->num_ct; i++, ct++) | ||
2745 | + for (i = 0; i < gc->num_ct; i++, ct++) | ||
2746 | if (ct->type & flow_type) | ||
2747 | ctrl_off = ct->regs.type; | ||
2748 | |||
2749 | diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c | ||
2750 | index 7440c58b8e6f..f5dfb8f7fe3b 100644 | ||
2751 | --- a/drivers/leds/led-class.c | ||
2752 | +++ b/drivers/leds/led-class.c | ||
2753 | @@ -173,6 +173,7 @@ void led_classdev_resume(struct led_classdev *led_cdev) | ||
2754 | } | ||
2755 | EXPORT_SYMBOL_GPL(led_classdev_resume); | ||
2756 | |||
2757 | +#ifdef CONFIG_PM_SLEEP | ||
2758 | static int led_suspend(struct device *dev) | ||
2759 | { | ||
2760 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | ||
2761 | @@ -192,11 +193,9 @@ static int led_resume(struct device *dev) | ||
2762 | |||
2763 | return 0; | ||
2764 | } | ||
2765 | +#endif | ||
2766 | |||
2767 | -static const struct dev_pm_ops leds_class_dev_pm_ops = { | ||
2768 | - .suspend = led_suspend, | ||
2769 | - .resume = led_resume, | ||
2770 | -}; | ||
2771 | +static SIMPLE_DEV_PM_OPS(leds_class_dev_pm_ops, led_suspend, led_resume); | ||
2772 | |||
2773 | /** | ||
2774 | * led_classdev_register - register a new object of led_classdev class. | ||
2775 | diff --git a/drivers/md/dm-stats.c b/drivers/md/dm-stats.c | ||
2776 | index 87f86c77b094..6f2a4ce413f7 100644 | ||
2777 | --- a/drivers/md/dm-stats.c | ||
2778 | +++ b/drivers/md/dm-stats.c | ||
2779 | @@ -795,6 +795,8 @@ static int message_stats_create(struct mapped_device *md, | ||
2780 | return -EINVAL; | ||
2781 | |||
2782 | if (sscanf(argv[2], "/%u%c", &divisor, &dummy) == 1) { | ||
2783 | + if (!divisor) | ||
2784 | + return -EINVAL; | ||
2785 | step = end - start; | ||
2786 | if (do_div(step, divisor)) | ||
2787 | step++; | ||
2788 | diff --git a/drivers/md/persistent-data/dm-space-map-metadata.c b/drivers/md/persistent-data/dm-space-map-metadata.c | ||
2789 | index f4e22bcc7fb8..199c9ccd1f5d 100644 | ||
2790 | --- a/drivers/md/persistent-data/dm-space-map-metadata.c | ||
2791 | +++ b/drivers/md/persistent-data/dm-space-map-metadata.c | ||
2792 | @@ -204,6 +204,27 @@ static void in(struct sm_metadata *smm) | ||
2793 | smm->recursion_count++; | ||
2794 | } | ||
2795 | |||
2796 | +static int apply_bops(struct sm_metadata *smm) | ||
2797 | +{ | ||
2798 | + int r = 0; | ||
2799 | + | ||
2800 | + while (!brb_empty(&smm->uncommitted)) { | ||
2801 | + struct block_op bop; | ||
2802 | + | ||
2803 | + r = brb_pop(&smm->uncommitted, &bop); | ||
2804 | + if (r) { | ||
2805 | + DMERR("bug in bop ring buffer"); | ||
2806 | + break; | ||
2807 | + } | ||
2808 | + | ||
2809 | + r = commit_bop(smm, &bop); | ||
2810 | + if (r) | ||
2811 | + break; | ||
2812 | + } | ||
2813 | + | ||
2814 | + return r; | ||
2815 | +} | ||
2816 | + | ||
2817 | static int out(struct sm_metadata *smm) | ||
2818 | { | ||
2819 | int r = 0; | ||
2820 | @@ -216,21 +237,8 @@ static int out(struct sm_metadata *smm) | ||
2821 | return -ENOMEM; | ||
2822 | } | ||
2823 | |||
2824 | - if (smm->recursion_count == 1) { | ||
2825 | - while (!brb_empty(&smm->uncommitted)) { | ||
2826 | - struct block_op bop; | ||
2827 | - | ||
2828 | - r = brb_pop(&smm->uncommitted, &bop); | ||
2829 | - if (r) { | ||
2830 | - DMERR("bug in bop ring buffer"); | ||
2831 | - break; | ||
2832 | - } | ||
2833 | - | ||
2834 | - r = commit_bop(smm, &bop); | ||
2835 | - if (r) | ||
2836 | - break; | ||
2837 | - } | ||
2838 | - } | ||
2839 | + if (smm->recursion_count == 1) | ||
2840 | + apply_bops(smm); | ||
2841 | |||
2842 | smm->recursion_count--; | ||
2843 | |||
2844 | @@ -702,6 +710,12 @@ static int sm_metadata_extend(struct dm_space_map *sm, dm_block_t extra_blocks) | ||
2845 | } | ||
2846 | old_len = smm->begin; | ||
2847 | |||
2848 | + r = apply_bops(smm); | ||
2849 | + if (r) { | ||
2850 | + DMERR("%s: apply_bops failed", __func__); | ||
2851 | + goto out; | ||
2852 | + } | ||
2853 | + | ||
2854 | r = sm_ll_commit(&smm->ll); | ||
2855 | if (r) | ||
2856 | goto out; | ||
2857 | @@ -771,6 +785,12 @@ int dm_sm_metadata_create(struct dm_space_map *sm, | ||
2858 | if (r) | ||
2859 | return r; | ||
2860 | |||
2861 | + r = apply_bops(smm); | ||
2862 | + if (r) { | ||
2863 | + DMERR("%s: apply_bops failed", __func__); | ||
2864 | + return r; | ||
2865 | + } | ||
2866 | + | ||
2867 | return sm_metadata_commit(sm); | ||
2868 | } | ||
2869 | |||
2870 | diff --git a/drivers/media/dvb-frontends/af9013.c b/drivers/media/dvb-frontends/af9013.c | ||
2871 | index 8001690d7576..ba6c8f6c42a1 100644 | ||
2872 | --- a/drivers/media/dvb-frontends/af9013.c | ||
2873 | +++ b/drivers/media/dvb-frontends/af9013.c | ||
2874 | @@ -605,6 +605,10 @@ static int af9013_set_frontend(struct dvb_frontend *fe) | ||
2875 | } | ||
2876 | } | ||
2877 | |||
2878 | + /* Return an error if can't find bandwidth or the right clock */ | ||
2879 | + if (i == ARRAY_SIZE(coeff_lut)) | ||
2880 | + return -EINVAL; | ||
2881 | + | ||
2882 | ret = af9013_wr_regs(state, 0xae00, coeff_lut[i].val, | ||
2883 | sizeof(coeff_lut[i].val)); | ||
2884 | } | ||
2885 | diff --git a/drivers/media/dvb-frontends/cx24116.c b/drivers/media/dvb-frontends/cx24116.c | ||
2886 | index 2916d7c74a1d..7bc68b355c0b 100644 | ||
2887 | --- a/drivers/media/dvb-frontends/cx24116.c | ||
2888 | +++ b/drivers/media/dvb-frontends/cx24116.c | ||
2889 | @@ -963,6 +963,10 @@ static int cx24116_send_diseqc_msg(struct dvb_frontend *fe, | ||
2890 | struct cx24116_state *state = fe->demodulator_priv; | ||
2891 | int i, ret; | ||
2892 | |||
2893 | + /* Validate length */ | ||
2894 | + if (d->msg_len > sizeof(d->msg)) | ||
2895 | + return -EINVAL; | ||
2896 | + | ||
2897 | /* Dump DiSEqC message */ | ||
2898 | if (debug) { | ||
2899 | printk(KERN_INFO "cx24116: %s(", __func__); | ||
2900 | @@ -974,10 +978,6 @@ static int cx24116_send_diseqc_msg(struct dvb_frontend *fe, | ||
2901 | printk(") toneburst=%d\n", toneburst); | ||
2902 | } | ||
2903 | |||
2904 | - /* Validate length */ | ||
2905 | - if (d->msg_len > (CX24116_ARGLEN - CX24116_DISEQC_MSGOFS)) | ||
2906 | - return -EINVAL; | ||
2907 | - | ||
2908 | /* DiSEqC message */ | ||
2909 | for (i = 0; i < d->msg_len; i++) | ||
2910 | state->dsec_cmd.args[CX24116_DISEQC_MSGOFS + i] = d->msg[i]; | ||
2911 | diff --git a/drivers/media/dvb-frontends/cx24117.c b/drivers/media/dvb-frontends/cx24117.c | ||
2912 | index a6c3c9e2e897..d2eab0676d30 100644 | ||
2913 | --- a/drivers/media/dvb-frontends/cx24117.c | ||
2914 | +++ b/drivers/media/dvb-frontends/cx24117.c | ||
2915 | @@ -1043,7 +1043,7 @@ static int cx24117_send_diseqc_msg(struct dvb_frontend *fe, | ||
2916 | dev_dbg(&state->priv->i2c->dev, ")\n"); | ||
2917 | |||
2918 | /* Validate length */ | ||
2919 | - if (d->msg_len > 15) | ||
2920 | + if (d->msg_len > sizeof(d->msg)) | ||
2921 | return -EINVAL; | ||
2922 | |||
2923 | /* DiSEqC message */ | ||
2924 | diff --git a/drivers/media/dvb-frontends/s5h1420.c b/drivers/media/dvb-frontends/s5h1420.c | ||
2925 | index 93eeaf7118fd..0b4f8fe6bf99 100644 | ||
2926 | --- a/drivers/media/dvb-frontends/s5h1420.c | ||
2927 | +++ b/drivers/media/dvb-frontends/s5h1420.c | ||
2928 | @@ -180,7 +180,7 @@ static int s5h1420_send_master_cmd (struct dvb_frontend* fe, | ||
2929 | int result = 0; | ||
2930 | |||
2931 | dprintk("enter %s\n", __func__); | ||
2932 | - if (cmd->msg_len > 8) | ||
2933 | + if (cmd->msg_len > sizeof(cmd->msg)) | ||
2934 | return -EINVAL; | ||
2935 | |||
2936 | /* setup for DISEQC */ | ||
2937 | diff --git a/drivers/media/usb/dvb-usb/dib0700_core.c b/drivers/media/usb/dvb-usb/dib0700_core.c | ||
2938 | index 50856dbf5496..605b090c618b 100644 | ||
2939 | --- a/drivers/media/usb/dvb-usb/dib0700_core.c | ||
2940 | +++ b/drivers/media/usb/dvb-usb/dib0700_core.c | ||
2941 | @@ -658,10 +658,20 @@ out: | ||
2942 | struct dib0700_rc_response { | ||
2943 | u8 report_id; | ||
2944 | u8 data_state; | ||
2945 | - u8 system; | ||
2946 | - u8 not_system; | ||
2947 | - u8 data; | ||
2948 | - u8 not_data; | ||
2949 | + union { | ||
2950 | + struct { | ||
2951 | + u8 system; | ||
2952 | + u8 not_system; | ||
2953 | + u8 data; | ||
2954 | + u8 not_data; | ||
2955 | + } nec; | ||
2956 | + struct { | ||
2957 | + u8 not_used; | ||
2958 | + u8 system; | ||
2959 | + u8 data; | ||
2960 | + u8 not_data; | ||
2961 | + } rc5; | ||
2962 | + }; | ||
2963 | }; | ||
2964 | #define RC_MSG_SIZE_V1_20 6 | ||
2965 | |||
2966 | @@ -697,8 +707,8 @@ static void dib0700_rc_urb_completion(struct urb *purb) | ||
2967 | |||
2968 | deb_data("IR ID = %02X state = %02X System = %02X %02X Cmd = %02X %02X (len %d)\n", | ||
2969 | poll_reply->report_id, poll_reply->data_state, | ||
2970 | - poll_reply->system, poll_reply->not_system, | ||
2971 | - poll_reply->data, poll_reply->not_data, | ||
2972 | + poll_reply->nec.system, poll_reply->nec.not_system, | ||
2973 | + poll_reply->nec.data, poll_reply->nec.not_data, | ||
2974 | purb->actual_length); | ||
2975 | |||
2976 | switch (d->props.rc.core.protocol) { | ||
2977 | @@ -707,30 +717,30 @@ static void dib0700_rc_urb_completion(struct urb *purb) | ||
2978 | toggle = 0; | ||
2979 | |||
2980 | /* NEC protocol sends repeat code as 0 0 0 FF */ | ||
2981 | - if (poll_reply->system == 0x00 && | ||
2982 | - poll_reply->not_system == 0x00 && | ||
2983 | - poll_reply->data == 0x00 && | ||
2984 | - poll_reply->not_data == 0xff) { | ||
2985 | + if (poll_reply->nec.system == 0x00 && | ||
2986 | + poll_reply->nec.not_system == 0x00 && | ||
2987 | + poll_reply->nec.data == 0x00 && | ||
2988 | + poll_reply->nec.not_data == 0xff) { | ||
2989 | poll_reply->data_state = 2; | ||
2990 | break; | ||
2991 | } | ||
2992 | |||
2993 | - if ((poll_reply->data ^ poll_reply->not_data) != 0xff) { | ||
2994 | + if ((poll_reply->nec.data ^ poll_reply->nec.not_data) != 0xff) { | ||
2995 | deb_data("NEC32 protocol\n"); | ||
2996 | - keycode = RC_SCANCODE_NEC32(poll_reply->system << 24 | | ||
2997 | - poll_reply->not_system << 16 | | ||
2998 | - poll_reply->data << 8 | | ||
2999 | - poll_reply->not_data); | ||
3000 | - } else if ((poll_reply->system ^ poll_reply->not_system) != 0xff) { | ||
3001 | + keycode = RC_SCANCODE_NEC32(poll_reply->nec.system << 24 | | ||
3002 | + poll_reply->nec.not_system << 16 | | ||
3003 | + poll_reply->nec.data << 8 | | ||
3004 | + poll_reply->nec.not_data); | ||
3005 | + } else if ((poll_reply->nec.system ^ poll_reply->nec.not_system) != 0xff) { | ||
3006 | deb_data("NEC extended protocol\n"); | ||
3007 | - keycode = RC_SCANCODE_NECX(poll_reply->system << 8 | | ||
3008 | - poll_reply->not_system, | ||
3009 | - poll_reply->data); | ||
3010 | + keycode = RC_SCANCODE_NECX(poll_reply->nec.system << 8 | | ||
3011 | + poll_reply->nec.not_system, | ||
3012 | + poll_reply->nec.data); | ||
3013 | |||
3014 | } else { | ||
3015 | deb_data("NEC normal protocol\n"); | ||
3016 | - keycode = RC_SCANCODE_NEC(poll_reply->system, | ||
3017 | - poll_reply->data); | ||
3018 | + keycode = RC_SCANCODE_NEC(poll_reply->nec.system, | ||
3019 | + poll_reply->nec.data); | ||
3020 | } | ||
3021 | |||
3022 | break; | ||
3023 | @@ -738,19 +748,19 @@ static void dib0700_rc_urb_completion(struct urb *purb) | ||
3024 | deb_data("RC5 protocol\n"); | ||
3025 | protocol = RC_TYPE_RC5; | ||
3026 | toggle = poll_reply->report_id; | ||
3027 | - keycode = RC_SCANCODE_RC5(poll_reply->system, poll_reply->data); | ||
3028 | + keycode = RC_SCANCODE_RC5(poll_reply->rc5.system, poll_reply->rc5.data); | ||
3029 | + | ||
3030 | + if ((poll_reply->rc5.data ^ poll_reply->rc5.not_data) != 0xff) { | ||
3031 | + /* Key failed integrity check */ | ||
3032 | + err("key failed integrity check: %02x %02x %02x %02x", | ||
3033 | + poll_reply->rc5.not_used, poll_reply->rc5.system, | ||
3034 | + poll_reply->rc5.data, poll_reply->rc5.not_data); | ||
3035 | + goto resubmit; | ||
3036 | + } | ||
3037 | |||
3038 | break; | ||
3039 | } | ||
3040 | |||
3041 | - if ((poll_reply->data + poll_reply->not_data) != 0xff) { | ||
3042 | - /* Key failed integrity check */ | ||
3043 | - err("key failed integrity check: %02x %02x %02x %02x", | ||
3044 | - poll_reply->system, poll_reply->not_system, | ||
3045 | - poll_reply->data, poll_reply->not_data); | ||
3046 | - goto resubmit; | ||
3047 | - } | ||
3048 | - | ||
3049 | rc_keydown(d->rc_dev, protocol, keycode, toggle); | ||
3050 | |||
3051 | resubmit: | ||
3052 | diff --git a/drivers/media/usb/dvb-usb/dib0700_devices.c b/drivers/media/usb/dvb-usb/dib0700_devices.c | ||
3053 | index e1757b8f5f5d..6aa4e9f4e441 100644 | ||
3054 | --- a/drivers/media/usb/dvb-usb/dib0700_devices.c | ||
3055 | +++ b/drivers/media/usb/dvb-usb/dib0700_devices.c | ||
3056 | @@ -3947,6 +3947,8 @@ struct dvb_usb_device_properties dib0700_devices[] = { | ||
3057 | |||
3058 | DIB0700_DEFAULT_STREAMING_CONFIG(0x02), | ||
3059 | }}, | ||
3060 | + .size_of_priv = sizeof(struct | ||
3061 | + dib0700_adapter_state), | ||
3062 | }, { | ||
3063 | .num_frontends = 1, | ||
3064 | .fe = {{ | ||
3065 | @@ -3959,6 +3961,8 @@ struct dvb_usb_device_properties dib0700_devices[] = { | ||
3066 | |||
3067 | DIB0700_DEFAULT_STREAMING_CONFIG(0x03), | ||
3068 | }}, | ||
3069 | + .size_of_priv = sizeof(struct | ||
3070 | + dib0700_adapter_state), | ||
3071 | } | ||
3072 | }, | ||
3073 | |||
3074 | @@ -4012,6 +4016,8 @@ struct dvb_usb_device_properties dib0700_devices[] = { | ||
3075 | |||
3076 | DIB0700_DEFAULT_STREAMING_CONFIG(0x02), | ||
3077 | }}, | ||
3078 | + .size_of_priv = sizeof(struct | ||
3079 | + dib0700_adapter_state), | ||
3080 | }, | ||
3081 | }, | ||
3082 | |||
3083 | diff --git a/drivers/misc/mei/client.c b/drivers/misc/mei/client.c | ||
3084 | index bc9ba5359bc6..351e4bc07a51 100644 | ||
3085 | --- a/drivers/misc/mei/client.c | ||
3086 | +++ b/drivers/misc/mei/client.c | ||
3087 | @@ -478,7 +478,7 @@ void mei_host_client_init(struct work_struct *work) | ||
3088 | bool mei_hbuf_acquire(struct mei_device *dev) | ||
3089 | { | ||
3090 | if (mei_pg_state(dev) == MEI_PG_ON || | ||
3091 | - dev->pg_event == MEI_PG_EVENT_WAIT) { | ||
3092 | + mei_pg_in_transition(dev)) { | ||
3093 | dev_dbg(dev->dev, "device is in pg\n"); | ||
3094 | return false; | ||
3095 | } | ||
3096 | diff --git a/drivers/misc/mei/hw-me.c b/drivers/misc/mei/hw-me.c | ||
3097 | index 350a28af98aa..c1ef64c5e81e 100644 | ||
3098 | --- a/drivers/misc/mei/hw-me.c | ||
3099 | +++ b/drivers/misc/mei/hw-me.c | ||
3100 | @@ -627,11 +627,27 @@ int mei_me_pg_unset_sync(struct mei_device *dev) | ||
3101 | mutex_lock(&dev->device_lock); | ||
3102 | |||
3103 | reply: | ||
3104 | - if (dev->pg_event == MEI_PG_EVENT_RECEIVED) | ||
3105 | - ret = mei_hbm_pg(dev, MEI_PG_ISOLATION_EXIT_RES_CMD); | ||
3106 | + if (dev->pg_event != MEI_PG_EVENT_RECEIVED) { | ||
3107 | + ret = -ETIME; | ||
3108 | + goto out; | ||
3109 | + } | ||
3110 | + | ||
3111 | + dev->pg_event = MEI_PG_EVENT_INTR_WAIT; | ||
3112 | + ret = mei_hbm_pg(dev, MEI_PG_ISOLATION_EXIT_RES_CMD); | ||
3113 | + if (ret) | ||
3114 | + return ret; | ||
3115 | + | ||
3116 | + mutex_unlock(&dev->device_lock); | ||
3117 | + wait_event_timeout(dev->wait_pg, | ||
3118 | + dev->pg_event == MEI_PG_EVENT_INTR_RECEIVED, timeout); | ||
3119 | + mutex_lock(&dev->device_lock); | ||
3120 | + | ||
3121 | + if (dev->pg_event == MEI_PG_EVENT_INTR_RECEIVED) | ||
3122 | + ret = 0; | ||
3123 | else | ||
3124 | ret = -ETIME; | ||
3125 | |||
3126 | +out: | ||
3127 | dev->pg_event = MEI_PG_EVENT_IDLE; | ||
3128 | hw->pg_state = MEI_PG_OFF; | ||
3129 | |||
3130 | @@ -639,6 +655,19 @@ reply: | ||
3131 | } | ||
3132 | |||
3133 | /** | ||
3134 | + * mei_me_pg_in_transition - is device now in pg transition | ||
3135 | + * | ||
3136 | + * @dev: the device structure | ||
3137 | + * | ||
3138 | + * Return: true if in pg transition, false otherwise | ||
3139 | + */ | ||
3140 | +static bool mei_me_pg_in_transition(struct mei_device *dev) | ||
3141 | +{ | ||
3142 | + return dev->pg_event >= MEI_PG_EVENT_WAIT && | ||
3143 | + dev->pg_event <= MEI_PG_EVENT_INTR_WAIT; | ||
3144 | +} | ||
3145 | + | ||
3146 | +/** | ||
3147 | * mei_me_pg_is_enabled - detect if PG is supported by HW | ||
3148 | * | ||
3149 | * @dev: the device structure | ||
3150 | @@ -670,6 +699,24 @@ notsupported: | ||
3151 | } | ||
3152 | |||
3153 | /** | ||
3154 | + * mei_me_pg_intr - perform pg processing in interrupt thread handler | ||
3155 | + * | ||
3156 | + * @dev: the device structure | ||
3157 | + */ | ||
3158 | +static void mei_me_pg_intr(struct mei_device *dev) | ||
3159 | +{ | ||
3160 | + struct mei_me_hw *hw = to_me_hw(dev); | ||
3161 | + | ||
3162 | + if (dev->pg_event != MEI_PG_EVENT_INTR_WAIT) | ||
3163 | + return; | ||
3164 | + | ||
3165 | + dev->pg_event = MEI_PG_EVENT_INTR_RECEIVED; | ||
3166 | + hw->pg_state = MEI_PG_OFF; | ||
3167 | + if (waitqueue_active(&dev->wait_pg)) | ||
3168 | + wake_up(&dev->wait_pg); | ||
3169 | +} | ||
3170 | + | ||
3171 | +/** | ||
3172 | * mei_me_irq_quick_handler - The ISR of the MEI device | ||
3173 | * | ||
3174 | * @irq: The irq number | ||
3175 | @@ -727,6 +774,8 @@ irqreturn_t mei_me_irq_thread_handler(int irq, void *dev_id) | ||
3176 | goto end; | ||
3177 | } | ||
3178 | |||
3179 | + mei_me_pg_intr(dev); | ||
3180 | + | ||
3181 | /* check if we need to start the dev */ | ||
3182 | if (!mei_host_is_ready(dev)) { | ||
3183 | if (mei_hw_is_ready(dev)) { | ||
3184 | @@ -763,9 +812,10 @@ irqreturn_t mei_me_irq_thread_handler(int irq, void *dev_id) | ||
3185 | /* | ||
3186 | * During PG handshake only allowed write is the replay to the | ||
3187 | * PG exit message, so block calling write function | ||
3188 | - * if the pg state is not idle | ||
3189 | + * if the pg event is in PG handshake | ||
3190 | */ | ||
3191 | - if (dev->pg_event == MEI_PG_EVENT_IDLE) { | ||
3192 | + if (dev->pg_event != MEI_PG_EVENT_WAIT && | ||
3193 | + dev->pg_event != MEI_PG_EVENT_RECEIVED) { | ||
3194 | rets = mei_irq_write_handler(dev, &complete_list); | ||
3195 | dev->hbuf_is_ready = mei_hbuf_is_ready(dev); | ||
3196 | } | ||
3197 | @@ -790,6 +840,7 @@ static const struct mei_hw_ops mei_me_hw_ops = { | ||
3198 | .hw_config = mei_me_hw_config, | ||
3199 | .hw_start = mei_me_hw_start, | ||
3200 | |||
3201 | + .pg_in_transition = mei_me_pg_in_transition, | ||
3202 | .pg_is_enabled = mei_me_pg_is_enabled, | ||
3203 | |||
3204 | .intr_clear = mei_me_intr_clear, | ||
3205 | diff --git a/drivers/misc/mei/hw-txe.c b/drivers/misc/mei/hw-txe.c | ||
3206 | index c5e1902e493f..c11a01a1ec21 100644 | ||
3207 | --- a/drivers/misc/mei/hw-txe.c | ||
3208 | +++ b/drivers/misc/mei/hw-txe.c | ||
3209 | @@ -16,6 +16,7 @@ | ||
3210 | |||
3211 | #include <linux/pci.h> | ||
3212 | #include <linux/jiffies.h> | ||
3213 | +#include <linux/ktime.h> | ||
3214 | #include <linux/delay.h> | ||
3215 | #include <linux/kthread.h> | ||
3216 | #include <linux/irqreturn.h> | ||
3217 | @@ -218,26 +219,25 @@ static u32 mei_txe_aliveness_get(struct mei_device *dev) | ||
3218 | * | ||
3219 | * Polls for HICR_HOST_ALIVENESS_RESP.ALIVENESS_RESP to be set | ||
3220 | * | ||
3221 | - * Return: > 0 if the expected value was received, -ETIME otherwise | ||
3222 | + * Return: 0 if the expected value was received, -ETIME otherwise | ||
3223 | */ | ||
3224 | static int mei_txe_aliveness_poll(struct mei_device *dev, u32 expected) | ||
3225 | { | ||
3226 | struct mei_txe_hw *hw = to_txe_hw(dev); | ||
3227 | - int t = 0; | ||
3228 | + ktime_t stop, start; | ||
3229 | |||
3230 | + start = ktime_get(); | ||
3231 | + stop = ktime_add(start, ms_to_ktime(SEC_ALIVENESS_WAIT_TIMEOUT)); | ||
3232 | do { | ||
3233 | hw->aliveness = mei_txe_aliveness_get(dev); | ||
3234 | if (hw->aliveness == expected) { | ||
3235 | dev->pg_event = MEI_PG_EVENT_IDLE; | ||
3236 | - dev_dbg(dev->dev, | ||
3237 | - "aliveness settled after %d msecs\n", t); | ||
3238 | - return t; | ||
3239 | + dev_dbg(dev->dev, "aliveness settled after %lld usecs\n", | ||
3240 | + ktime_to_us(ktime_sub(ktime_get(), start))); | ||
3241 | + return 0; | ||
3242 | } | ||
3243 | - mutex_unlock(&dev->device_lock); | ||
3244 | - msleep(MSEC_PER_SEC / 5); | ||
3245 | - mutex_lock(&dev->device_lock); | ||
3246 | - t += MSEC_PER_SEC / 5; | ||
3247 | - } while (t < SEC_ALIVENESS_WAIT_TIMEOUT); | ||
3248 | + usleep_range(20, 50); | ||
3249 | + } while (ktime_before(ktime_get(), stop)); | ||
3250 | |||
3251 | dev->pg_event = MEI_PG_EVENT_IDLE; | ||
3252 | dev_err(dev->dev, "aliveness timed out\n"); | ||
3253 | @@ -302,6 +302,18 @@ int mei_txe_aliveness_set_sync(struct mei_device *dev, u32 req) | ||
3254 | } | ||
3255 | |||
3256 | /** | ||
3257 | + * mei_txe_pg_in_transition - is device now in pg transition | ||
3258 | + * | ||
3259 | + * @dev: the device structure | ||
3260 | + * | ||
3261 | + * Return: true if in pg transition, false otherwise | ||
3262 | + */ | ||
3263 | +static bool mei_txe_pg_in_transition(struct mei_device *dev) | ||
3264 | +{ | ||
3265 | + return dev->pg_event == MEI_PG_EVENT_WAIT; | ||
3266 | +} | ||
3267 | + | ||
3268 | +/** | ||
3269 | * mei_txe_pg_is_enabled - detect if PG is supported by HW | ||
3270 | * | ||
3271 | * @dev: the device structure | ||
3272 | @@ -1139,6 +1151,7 @@ static const struct mei_hw_ops mei_txe_hw_ops = { | ||
3273 | .hw_config = mei_txe_hw_config, | ||
3274 | .hw_start = mei_txe_hw_start, | ||
3275 | |||
3276 | + .pg_in_transition = mei_txe_pg_in_transition, | ||
3277 | .pg_is_enabled = mei_txe_pg_is_enabled, | ||
3278 | |||
3279 | .intr_clear = mei_txe_intr_clear, | ||
3280 | diff --git a/drivers/misc/mei/mei_dev.h b/drivers/misc/mei/mei_dev.h | ||
3281 | index 71744b16cc8c..909b2d81895b 100644 | ||
3282 | --- a/drivers/misc/mei/mei_dev.h | ||
3283 | +++ b/drivers/misc/mei/mei_dev.h | ||
3284 | @@ -264,6 +264,7 @@ struct mei_cl { | ||
3285 | |||
3286 | * @fw_status : get fw status registers | ||
3287 | * @pg_state : power gating state of the device | ||
3288 | + * @pg_in_transition : is device now in pg transition | ||
3289 | * @pg_is_enabled : is power gating enabled | ||
3290 | |||
3291 | * @intr_clear : clear pending interrupts | ||
3292 | @@ -293,6 +294,7 @@ struct mei_hw_ops { | ||
3293 | |||
3294 | int (*fw_status)(struct mei_device *dev, struct mei_fw_status *fw_sts); | ||
3295 | enum mei_pg_state (*pg_state)(struct mei_device *dev); | ||
3296 | + bool (*pg_in_transition)(struct mei_device *dev); | ||
3297 | bool (*pg_is_enabled)(struct mei_device *dev); | ||
3298 | |||
3299 | void (*intr_clear)(struct mei_device *dev); | ||
3300 | @@ -390,11 +392,15 @@ struct mei_cl_device { | ||
3301 | * @MEI_PG_EVENT_IDLE: the driver is not in power gating transition | ||
3302 | * @MEI_PG_EVENT_WAIT: the driver is waiting for a pg event to complete | ||
3303 | * @MEI_PG_EVENT_RECEIVED: the driver received pg event | ||
3304 | + * @MEI_PG_EVENT_INTR_WAIT: the driver is waiting for a pg event interrupt | ||
3305 | + * @MEI_PG_EVENT_INTR_RECEIVED: the driver received pg event interrupt | ||
3306 | */ | ||
3307 | enum mei_pg_event { | ||
3308 | MEI_PG_EVENT_IDLE, | ||
3309 | MEI_PG_EVENT_WAIT, | ||
3310 | MEI_PG_EVENT_RECEIVED, | ||
3311 | + MEI_PG_EVENT_INTR_WAIT, | ||
3312 | + MEI_PG_EVENT_INTR_RECEIVED, | ||
3313 | }; | ||
3314 | |||
3315 | /** | ||
3316 | @@ -721,6 +727,11 @@ static inline enum mei_pg_state mei_pg_state(struct mei_device *dev) | ||
3317 | return dev->ops->pg_state(dev); | ||
3318 | } | ||
3319 | |||
3320 | +static inline bool mei_pg_in_transition(struct mei_device *dev) | ||
3321 | +{ | ||
3322 | + return dev->ops->pg_in_transition(dev); | ||
3323 | +} | ||
3324 | + | ||
3325 | static inline bool mei_pg_is_enabled(struct mei_device *dev) | ||
3326 | { | ||
3327 | return dev->ops->pg_is_enabled(dev); | ||
3328 | diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c | ||
3329 | index 38251da7ba32..29708b82ceef 100644 | ||
3330 | --- a/drivers/mmc/host/sdhci-pxav3.c | ||
3331 | +++ b/drivers/mmc/host/sdhci-pxav3.c | ||
3332 | @@ -330,16 +330,6 @@ static int sdhci_pxav3_probe(struct platform_device *pdev) | ||
3333 | /* enable 1/8V DDR capable */ | ||
3334 | host->mmc->caps |= MMC_CAP_1_8V_DDR; | ||
3335 | |||
3336 | - if (of_device_is_compatible(np, "marvell,armada-380-sdhci")) { | ||
3337 | - ret = armada_38x_quirks(pdev, host); | ||
3338 | - if (ret < 0) | ||
3339 | - goto err_clk_get; | ||
3340 | - ret = mv_conf_mbus_windows(pdev, mv_mbus_dram_info()); | ||
3341 | - if (ret < 0) | ||
3342 | - goto err_mbus_win; | ||
3343 | - } | ||
3344 | - | ||
3345 | - | ||
3346 | pltfm_host = sdhci_priv(host); | ||
3347 | pltfm_host->priv = pxa; | ||
3348 | |||
3349 | @@ -352,6 +342,15 @@ static int sdhci_pxav3_probe(struct platform_device *pdev) | ||
3350 | pltfm_host->clk = clk; | ||
3351 | clk_prepare_enable(clk); | ||
3352 | |||
3353 | + if (of_device_is_compatible(np, "marvell,armada-380-sdhci")) { | ||
3354 | + ret = armada_38x_quirks(pdev, host); | ||
3355 | + if (ret < 0) | ||
3356 | + goto err_clk_get; | ||
3357 | + ret = mv_conf_mbus_windows(pdev, mv_mbus_dram_info()); | ||
3358 | + if (ret < 0) | ||
3359 | + goto err_mbus_win; | ||
3360 | + } | ||
3361 | + | ||
3362 | match = of_match_device(of_match_ptr(sdhci_pxav3_of_match), &pdev->dev); | ||
3363 | if (match) { | ||
3364 | ret = mmc_of_parse(host->mmc); | ||
3365 | @@ -421,9 +420,9 @@ err_add_host: | ||
3366 | pm_runtime_put_noidle(&pdev->dev); | ||
3367 | err_of_parse: | ||
3368 | err_cd_req: | ||
3369 | +err_mbus_win: | ||
3370 | clk_disable_unprepare(clk); | ||
3371 | err_clk_get: | ||
3372 | -err_mbus_win: | ||
3373 | sdhci_pltfm_free(pdev); | ||
3374 | return ret; | ||
3375 | } | ||
3376 | diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c | ||
3377 | index d08229eb44d8..3a69b1e56908 100644 | ||
3378 | --- a/drivers/mtd/mtd_blkdevs.c | ||
3379 | +++ b/drivers/mtd/mtd_blkdevs.c | ||
3380 | @@ -200,6 +200,7 @@ static int blktrans_open(struct block_device *bdev, fmode_t mode) | ||
3381 | return -ERESTARTSYS; /* FIXME: busy loop! -arnd*/ | ||
3382 | |||
3383 | mutex_lock(&dev->lock); | ||
3384 | + mutex_lock(&mtd_table_mutex); | ||
3385 | |||
3386 | if (dev->open) | ||
3387 | goto unlock; | ||
3388 | @@ -223,6 +224,7 @@ static int blktrans_open(struct block_device *bdev, fmode_t mode) | ||
3389 | |||
3390 | unlock: | ||
3391 | dev->open++; | ||
3392 | + mutex_unlock(&mtd_table_mutex); | ||
3393 | mutex_unlock(&dev->lock); | ||
3394 | blktrans_dev_put(dev); | ||
3395 | return ret; | ||
3396 | @@ -233,6 +235,7 @@ error_release: | ||
3397 | error_put: | ||
3398 | module_put(dev->tr->owner); | ||
3399 | kref_put(&dev->ref, blktrans_dev_release); | ||
3400 | + mutex_unlock(&mtd_table_mutex); | ||
3401 | mutex_unlock(&dev->lock); | ||
3402 | blktrans_dev_put(dev); | ||
3403 | return ret; | ||
3404 | @@ -246,6 +249,7 @@ static void blktrans_release(struct gendisk *disk, fmode_t mode) | ||
3405 | return; | ||
3406 | |||
3407 | mutex_lock(&dev->lock); | ||
3408 | + mutex_lock(&mtd_table_mutex); | ||
3409 | |||
3410 | if (--dev->open) | ||
3411 | goto unlock; | ||
3412 | @@ -259,6 +263,7 @@ static void blktrans_release(struct gendisk *disk, fmode_t mode) | ||
3413 | __put_mtd_device(dev->mtd); | ||
3414 | } | ||
3415 | unlock: | ||
3416 | + mutex_unlock(&mtd_table_mutex); | ||
3417 | mutex_unlock(&dev->lock); | ||
3418 | blktrans_dev_put(dev); | ||
3419 | } | ||
3420 | diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c | ||
3421 | index 710eb5793eb3..1217eafb61a4 100644 | ||
3422 | --- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c | ||
3423 | +++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c | ||
3424 | @@ -9307,7 +9307,8 @@ unload_error: | ||
3425 | * function stop ramrod is sent, since as part of this ramrod FW access | ||
3426 | * PTP registers. | ||
3427 | */ | ||
3428 | - bnx2x_stop_ptp(bp); | ||
3429 | + if (bp->flags & PTP_SUPPORTED) | ||
3430 | + bnx2x_stop_ptp(bp); | ||
3431 | |||
3432 | /* Disable HW interrupts, NAPI */ | ||
3433 | bnx2x_netif_stop(bp, 1); | ||
3434 | diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c | ||
3435 | index 67a84cfaefa1..fb34708aa5f4 100644 | ||
3436 | --- a/drivers/net/ethernet/marvell/mvneta.c | ||
3437 | +++ b/drivers/net/ethernet/marvell/mvneta.c | ||
3438 | @@ -304,6 +304,7 @@ struct mvneta_port { | ||
3439 | unsigned int link; | ||
3440 | unsigned int duplex; | ||
3441 | unsigned int speed; | ||
3442 | + unsigned int tx_csum_limit; | ||
3443 | }; | ||
3444 | |||
3445 | /* The mvneta_tx_desc and mvneta_rx_desc structures describe the | ||
3446 | @@ -2441,8 +2442,10 @@ static int mvneta_change_mtu(struct net_device *dev, int mtu) | ||
3447 | |||
3448 | dev->mtu = mtu; | ||
3449 | |||
3450 | - if (!netif_running(dev)) | ||
3451 | + if (!netif_running(dev)) { | ||
3452 | + netdev_update_features(dev); | ||
3453 | return 0; | ||
3454 | + } | ||
3455 | |||
3456 | /* The interface is running, so we have to force a | ||
3457 | * reallocation of the queues | ||
3458 | @@ -2471,9 +2474,26 @@ static int mvneta_change_mtu(struct net_device *dev, int mtu) | ||
3459 | mvneta_start_dev(pp); | ||
3460 | mvneta_port_up(pp); | ||
3461 | |||
3462 | + netdev_update_features(dev); | ||
3463 | + | ||
3464 | return 0; | ||
3465 | } | ||
3466 | |||
3467 | +static netdev_features_t mvneta_fix_features(struct net_device *dev, | ||
3468 | + netdev_features_t features) | ||
3469 | +{ | ||
3470 | + struct mvneta_port *pp = netdev_priv(dev); | ||
3471 | + | ||
3472 | + if (pp->tx_csum_limit && dev->mtu > pp->tx_csum_limit) { | ||
3473 | + features &= ~(NETIF_F_IP_CSUM | NETIF_F_TSO); | ||
3474 | + netdev_info(dev, | ||
3475 | + "Disable IP checksum for MTU greater than %dB\n", | ||
3476 | + pp->tx_csum_limit); | ||
3477 | + } | ||
3478 | + | ||
3479 | + return features; | ||
3480 | +} | ||
3481 | + | ||
3482 | /* Get mac address */ | ||
3483 | static void mvneta_get_mac_addr(struct mvneta_port *pp, unsigned char *addr) | ||
3484 | { | ||
3485 | @@ -2791,6 +2811,7 @@ static const struct net_device_ops mvneta_netdev_ops = { | ||
3486 | .ndo_set_rx_mode = mvneta_set_rx_mode, | ||
3487 | .ndo_set_mac_address = mvneta_set_mac_addr, | ||
3488 | .ndo_change_mtu = mvneta_change_mtu, | ||
3489 | + .ndo_fix_features = mvneta_fix_features, | ||
3490 | .ndo_get_stats64 = mvneta_get_stats64, | ||
3491 | .ndo_do_ioctl = mvneta_ioctl, | ||
3492 | }; | ||
3493 | @@ -3029,6 +3050,9 @@ static int mvneta_probe(struct platform_device *pdev) | ||
3494 | } | ||
3495 | } | ||
3496 | |||
3497 | + if (of_device_is_compatible(dn, "marvell,armada-370-neta")) | ||
3498 | + pp->tx_csum_limit = 1600; | ||
3499 | + | ||
3500 | pp->tx_ring_size = MVNETA_MAX_TXD; | ||
3501 | pp->rx_ring_size = MVNETA_MAX_RXD; | ||
3502 | |||
3503 | @@ -3101,6 +3125,7 @@ static int mvneta_remove(struct platform_device *pdev) | ||
3504 | |||
3505 | static const struct of_device_id mvneta_match[] = { | ||
3506 | { .compatible = "marvell,armada-370-neta" }, | ||
3507 | + { .compatible = "marvell,armada-xp-neta" }, | ||
3508 | { } | ||
3509 | }; | ||
3510 | MODULE_DEVICE_TABLE(of, mvneta_match); | ||
3511 | diff --git a/drivers/net/ethernet/mellanox/mlx4/en_tx.c b/drivers/net/ethernet/mellanox/mlx4/en_tx.c | ||
3512 | index 142ddd595e2e..5980d3fe597c 100644 | ||
3513 | --- a/drivers/net/ethernet/mellanox/mlx4/en_tx.c | ||
3514 | +++ b/drivers/net/ethernet/mellanox/mlx4/en_tx.c | ||
3515 | @@ -66,6 +66,7 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv, | ||
3516 | ring->size = size; | ||
3517 | ring->size_mask = size - 1; | ||
3518 | ring->stride = stride; | ||
3519 | + ring->full_size = ring->size - HEADROOM - MAX_DESC_TXBBS; | ||
3520 | |||
3521 | tmp = size * sizeof(struct mlx4_en_tx_info); | ||
3522 | ring->tx_info = kmalloc_node(tmp, GFP_KERNEL | __GFP_NOWARN, node); | ||
3523 | @@ -223,6 +224,11 @@ void mlx4_en_deactivate_tx_ring(struct mlx4_en_priv *priv, | ||
3524 | MLX4_QP_STATE_RST, NULL, 0, 0, &ring->qp); | ||
3525 | } | ||
3526 | |||
3527 | +static inline bool mlx4_en_is_tx_ring_full(struct mlx4_en_tx_ring *ring) | ||
3528 | +{ | ||
3529 | + return ring->prod - ring->cons > ring->full_size; | ||
3530 | +} | ||
3531 | + | ||
3532 | static void mlx4_en_stamp_wqe(struct mlx4_en_priv *priv, | ||
3533 | struct mlx4_en_tx_ring *ring, int index, | ||
3534 | u8 owner) | ||
3535 | @@ -465,11 +471,10 @@ static bool mlx4_en_process_tx_cq(struct net_device *dev, | ||
3536 | |||
3537 | netdev_tx_completed_queue(ring->tx_queue, packets, bytes); | ||
3538 | |||
3539 | - /* | ||
3540 | - * Wakeup Tx queue if this stopped, and at least 1 packet | ||
3541 | - * was completed | ||
3542 | + /* Wakeup Tx queue if this stopped, and ring is not full. | ||
3543 | */ | ||
3544 | - if (netif_tx_queue_stopped(ring->tx_queue) && txbbs_skipped > 0) { | ||
3545 | + if (netif_tx_queue_stopped(ring->tx_queue) && | ||
3546 | + !mlx4_en_is_tx_ring_full(ring)) { | ||
3547 | netif_tx_wake_queue(ring->tx_queue); | ||
3548 | ring->wake_queue++; | ||
3549 | } | ||
3550 | @@ -913,8 +918,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev) | ||
3551 | skb_tx_timestamp(skb); | ||
3552 | |||
3553 | /* Check available TXBBs And 2K spare for prefetch */ | ||
3554 | - stop_queue = (int)(ring->prod - ring_cons) > | ||
3555 | - ring->size - HEADROOM - MAX_DESC_TXBBS; | ||
3556 | + stop_queue = mlx4_en_is_tx_ring_full(ring); | ||
3557 | if (unlikely(stop_queue)) { | ||
3558 | netif_tx_stop_queue(ring->tx_queue); | ||
3559 | ring->queue_stopped++; | ||
3560 | @@ -983,8 +987,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev) | ||
3561 | smp_rmb(); | ||
3562 | |||
3563 | ring_cons = ACCESS_ONCE(ring->cons); | ||
3564 | - if (unlikely(((int)(ring->prod - ring_cons)) <= | ||
3565 | - ring->size - HEADROOM - MAX_DESC_TXBBS)) { | ||
3566 | + if (unlikely(!mlx4_en_is_tx_ring_full(ring))) { | ||
3567 | netif_tx_wake_queue(ring->tx_queue); | ||
3568 | ring->wake_queue++; | ||
3569 | } | ||
3570 | diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h | ||
3571 | index 692bd4e8b21f..4f908065accf 100644 | ||
3572 | --- a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h | ||
3573 | +++ b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h | ||
3574 | @@ -280,6 +280,7 @@ struct mlx4_en_tx_ring { | ||
3575 | u32 size; /* number of TXBBs */ | ||
3576 | u32 size_mask; | ||
3577 | u16 stride; | ||
3578 | + u32 full_size; | ||
3579 | u16 cqn; /* index of port CQ associated with this ring */ | ||
3580 | u32 buf_size; | ||
3581 | __be32 doorbell_qpn; | ||
3582 | diff --git a/drivers/net/ethernet/stmicro/stmmac/descs.h b/drivers/net/ethernet/stmicro/stmmac/descs.h | ||
3583 | index ad3996038018..799c2929c536 100644 | ||
3584 | --- a/drivers/net/ethernet/stmicro/stmmac/descs.h | ||
3585 | +++ b/drivers/net/ethernet/stmicro/stmmac/descs.h | ||
3586 | @@ -158,6 +158,8 @@ struct dma_desc { | ||
3587 | u32 buffer2_size:13; | ||
3588 | u32 reserved4:3; | ||
3589 | } etx; /* -- enhanced -- */ | ||
3590 | + | ||
3591 | + u64 all_flags; | ||
3592 | } des01; | ||
3593 | unsigned int des2; | ||
3594 | unsigned int des3; | ||
3595 | diff --git a/drivers/net/ethernet/stmicro/stmmac/enh_desc.c b/drivers/net/ethernet/stmicro/stmmac/enh_desc.c | ||
3596 | index 1e2bcf5f89e1..7d944449f5ef 100644 | ||
3597 | --- a/drivers/net/ethernet/stmicro/stmmac/enh_desc.c | ||
3598 | +++ b/drivers/net/ethernet/stmicro/stmmac/enh_desc.c | ||
3599 | @@ -240,6 +240,7 @@ static int enh_desc_get_rx_status(void *data, struct stmmac_extra_stats *x, | ||
3600 | static void enh_desc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, | ||
3601 | int mode, int end) | ||
3602 | { | ||
3603 | + p->des01.all_flags = 0; | ||
3604 | p->des01.erx.own = 1; | ||
3605 | p->des01.erx.buffer1_size = BUF_SIZE_8KiB - 1; | ||
3606 | |||
3607 | @@ -254,7 +255,7 @@ static void enh_desc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, | ||
3608 | |||
3609 | static void enh_desc_init_tx_desc(struct dma_desc *p, int mode, int end) | ||
3610 | { | ||
3611 | - p->des01.etx.own = 0; | ||
3612 | + p->des01.all_flags = 0; | ||
3613 | if (mode == STMMAC_CHAIN_MODE) | ||
3614 | ehn_desc_tx_set_on_chain(p, end); | ||
3615 | else | ||
3616 | diff --git a/drivers/net/ethernet/stmicro/stmmac/norm_desc.c b/drivers/net/ethernet/stmicro/stmmac/norm_desc.c | ||
3617 | index 35ad4f427ae2..48c3456445b2 100644 | ||
3618 | --- a/drivers/net/ethernet/stmicro/stmmac/norm_desc.c | ||
3619 | +++ b/drivers/net/ethernet/stmicro/stmmac/norm_desc.c | ||
3620 | @@ -123,6 +123,7 @@ static int ndesc_get_rx_status(void *data, struct stmmac_extra_stats *x, | ||
3621 | static void ndesc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, int mode, | ||
3622 | int end) | ||
3623 | { | ||
3624 | + p->des01.all_flags = 0; | ||
3625 | p->des01.rx.own = 1; | ||
3626 | p->des01.rx.buffer1_size = BUF_SIZE_2KiB - 1; | ||
3627 | |||
3628 | @@ -137,7 +138,7 @@ static void ndesc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, int mode, | ||
3629 | |||
3630 | static void ndesc_init_tx_desc(struct dma_desc *p, int mode, int end) | ||
3631 | { | ||
3632 | - p->des01.tx.own = 0; | ||
3633 | + p->des01.all_flags = 0; | ||
3634 | if (mode == STMMAC_CHAIN_MODE) | ||
3635 | ndesc_tx_set_on_chain(p, end); | ||
3636 | else | ||
3637 | diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c | ||
3638 | index 18c46bb0f3bf..c769da8d6f3a 100644 | ||
3639 | --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c | ||
3640 | +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c | ||
3641 | @@ -1172,41 +1172,41 @@ static int alloc_dma_desc_resources(struct stmmac_priv *priv) | ||
3642 | goto err_tx_skbuff; | ||
3643 | |||
3644 | if (priv->extend_desc) { | ||
3645 | - priv->dma_erx = dma_alloc_coherent(priv->device, rxsize * | ||
3646 | - sizeof(struct | ||
3647 | - dma_extended_desc), | ||
3648 | - &priv->dma_rx_phy, | ||
3649 | - GFP_KERNEL); | ||
3650 | + priv->dma_erx = dma_zalloc_coherent(priv->device, rxsize * | ||
3651 | + sizeof(struct | ||
3652 | + dma_extended_desc), | ||
3653 | + &priv->dma_rx_phy, | ||
3654 | + GFP_KERNEL); | ||
3655 | if (!priv->dma_erx) | ||
3656 | goto err_dma; | ||
3657 | |||
3658 | - priv->dma_etx = dma_alloc_coherent(priv->device, txsize * | ||
3659 | - sizeof(struct | ||
3660 | - dma_extended_desc), | ||
3661 | - &priv->dma_tx_phy, | ||
3662 | - GFP_KERNEL); | ||
3663 | + priv->dma_etx = dma_zalloc_coherent(priv->device, txsize * | ||
3664 | + sizeof(struct | ||
3665 | + dma_extended_desc), | ||
3666 | + &priv->dma_tx_phy, | ||
3667 | + GFP_KERNEL); | ||
3668 | if (!priv->dma_etx) { | ||
3669 | dma_free_coherent(priv->device, priv->dma_rx_size * | ||
3670 | - sizeof(struct dma_extended_desc), | ||
3671 | - priv->dma_erx, priv->dma_rx_phy); | ||
3672 | + sizeof(struct dma_extended_desc), | ||
3673 | + priv->dma_erx, priv->dma_rx_phy); | ||
3674 | goto err_dma; | ||
3675 | } | ||
3676 | } else { | ||
3677 | - priv->dma_rx = dma_alloc_coherent(priv->device, rxsize * | ||
3678 | - sizeof(struct dma_desc), | ||
3679 | - &priv->dma_rx_phy, | ||
3680 | - GFP_KERNEL); | ||
3681 | + priv->dma_rx = dma_zalloc_coherent(priv->device, rxsize * | ||
3682 | + sizeof(struct dma_desc), | ||
3683 | + &priv->dma_rx_phy, | ||
3684 | + GFP_KERNEL); | ||
3685 | if (!priv->dma_rx) | ||
3686 | goto err_dma; | ||
3687 | |||
3688 | - priv->dma_tx = dma_alloc_coherent(priv->device, txsize * | ||
3689 | - sizeof(struct dma_desc), | ||
3690 | - &priv->dma_tx_phy, | ||
3691 | - GFP_KERNEL); | ||
3692 | + priv->dma_tx = dma_zalloc_coherent(priv->device, txsize * | ||
3693 | + sizeof(struct dma_desc), | ||
3694 | + &priv->dma_tx_phy, | ||
3695 | + GFP_KERNEL); | ||
3696 | if (!priv->dma_tx) { | ||
3697 | dma_free_coherent(priv->device, priv->dma_rx_size * | ||
3698 | - sizeof(struct dma_desc), | ||
3699 | - priv->dma_rx, priv->dma_rx_phy); | ||
3700 | + sizeof(struct dma_desc), | ||
3701 | + priv->dma_rx, priv->dma_rx_phy); | ||
3702 | goto err_dma; | ||
3703 | } | ||
3704 | } | ||
3705 | diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c | ||
3706 | index 3fc91e89f5a5..70a0d88de654 100644 | ||
3707 | --- a/drivers/net/phy/phy_device.c | ||
3708 | +++ b/drivers/net/phy/phy_device.c | ||
3709 | @@ -782,10 +782,11 @@ static int genphy_config_advert(struct phy_device *phydev) | ||
3710 | if (phydev->supported & (SUPPORTED_1000baseT_Half | | ||
3711 | SUPPORTED_1000baseT_Full)) { | ||
3712 | adv |= ethtool_adv_to_mii_ctrl1000_t(advertise); | ||
3713 | - if (adv != oldadv) | ||
3714 | - changed = 1; | ||
3715 | } | ||
3716 | |||
3717 | + if (adv != oldadv) | ||
3718 | + changed = 1; | ||
3719 | + | ||
3720 | err = phy_write(phydev, MII_CTRL1000, adv); | ||
3721 | if (err < 0) | ||
3722 | return err; | ||
3723 | diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c | ||
3724 | index 4f18a6be0c7d..2cf58993da8b 100644 | ||
3725 | --- a/drivers/net/wireless/ath/ath9k/main.c | ||
3726 | +++ b/drivers/net/wireless/ath/ath9k/main.c | ||
3727 | @@ -212,11 +212,13 @@ static bool ath_prepare_reset(struct ath_softc *sc) | ||
3728 | ath_stop_ani(sc); | ||
3729 | ath9k_hw_disable_interrupts(ah); | ||
3730 | |||
3731 | - if (!ath_drain_all_txq(sc)) | ||
3732 | - ret = false; | ||
3733 | - | ||
3734 | - if (!ath_stoprecv(sc)) | ||
3735 | - ret = false; | ||
3736 | + if (AR_SREV_9300_20_OR_LATER(ah)) { | ||
3737 | + ret &= ath_stoprecv(sc); | ||
3738 | + ret &= ath_drain_all_txq(sc); | ||
3739 | + } else { | ||
3740 | + ret &= ath_drain_all_txq(sc); | ||
3741 | + ret &= ath_stoprecv(sc); | ||
3742 | + } | ||
3743 | |||
3744 | return ret; | ||
3745 | } | ||
3746 | diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c | ||
3747 | index 5d4173ee55bc..614d62ebc0ba 100644 | ||
3748 | --- a/drivers/net/wireless/b43/main.c | ||
3749 | +++ b/drivers/net/wireless/b43/main.c | ||
3750 | @@ -5314,6 +5314,10 @@ static void b43_supported_bands(struct b43_wldev *dev, bool *have_2ghz_phy, | ||
3751 | *have_5ghz_phy = true; | ||
3752 | return; | ||
3753 | case 0x4321: /* BCM4306 */ | ||
3754 | + /* There are 14e4:4321 PCI devs with 2.4 GHz BCM4321 (N-PHY) */ | ||
3755 | + if (dev->phy.type != B43_PHYTYPE_G) | ||
3756 | + break; | ||
3757 | + /* fall through */ | ||
3758 | case 0x4313: /* BCM4311 */ | ||
3759 | case 0x431a: /* BCM4318 */ | ||
3760 | case 0x432a: /* BCM4321 */ | ||
3761 | diff --git a/drivers/net/wireless/rtlwifi/rtl8188ee/hw.c b/drivers/net/wireless/rtlwifi/rtl8188ee/hw.c | ||
3762 | index f2b9713c456e..425ccb301705 100644 | ||
3763 | --- a/drivers/net/wireless/rtlwifi/rtl8188ee/hw.c | ||
3764 | +++ b/drivers/net/wireless/rtlwifi/rtl8188ee/hw.c | ||
3765 | @@ -1353,27 +1353,11 @@ void rtl88ee_set_qos(struct ieee80211_hw *hw, int aci) | ||
3766 | } | ||
3767 | } | ||
3768 | |||
3769 | -static void rtl88ee_clear_interrupt(struct ieee80211_hw *hw) | ||
3770 | -{ | ||
3771 | - struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3772 | - u32 tmp; | ||
3773 | - | ||
3774 | - tmp = rtl_read_dword(rtlpriv, REG_HISR); | ||
3775 | - rtl_write_dword(rtlpriv, REG_HISR, tmp); | ||
3776 | - | ||
3777 | - tmp = rtl_read_dword(rtlpriv, REG_HISRE); | ||
3778 | - rtl_write_dword(rtlpriv, REG_HISRE, tmp); | ||
3779 | - | ||
3780 | - tmp = rtl_read_dword(rtlpriv, REG_HSISR); | ||
3781 | - rtl_write_dword(rtlpriv, REG_HSISR, tmp); | ||
3782 | -} | ||
3783 | - | ||
3784 | void rtl88ee_enable_interrupt(struct ieee80211_hw *hw) | ||
3785 | { | ||
3786 | struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3787 | struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); | ||
3788 | |||
3789 | - rtl88ee_clear_interrupt(hw);/*clear it here first*/ | ||
3790 | rtl_write_dword(rtlpriv, REG_HIMR, | ||
3791 | rtlpci->irq_mask[0] & 0xFFFFFFFF); | ||
3792 | rtl_write_dword(rtlpriv, REG_HIMRE, | ||
3793 | diff --git a/drivers/net/wireless/rtlwifi/rtl8192ee/hw.c b/drivers/net/wireless/rtlwifi/rtl8192ee/hw.c | ||
3794 | index b461b3128da5..93624541e495 100644 | ||
3795 | --- a/drivers/net/wireless/rtlwifi/rtl8192ee/hw.c | ||
3796 | +++ b/drivers/net/wireless/rtlwifi/rtl8192ee/hw.c | ||
3797 | @@ -1584,28 +1584,11 @@ void rtl92ee_set_qos(struct ieee80211_hw *hw, int aci) | ||
3798 | } | ||
3799 | } | ||
3800 | |||
3801 | -static void rtl92ee_clear_interrupt(struct ieee80211_hw *hw) | ||
3802 | -{ | ||
3803 | - struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3804 | - u32 tmp; | ||
3805 | - | ||
3806 | - tmp = rtl_read_dword(rtlpriv, REG_HISR); | ||
3807 | - rtl_write_dword(rtlpriv, REG_HISR, tmp); | ||
3808 | - | ||
3809 | - tmp = rtl_read_dword(rtlpriv, REG_HISRE); | ||
3810 | - rtl_write_dword(rtlpriv, REG_HISRE, tmp); | ||
3811 | - | ||
3812 | - tmp = rtl_read_dword(rtlpriv, REG_HSISR); | ||
3813 | - rtl_write_dword(rtlpriv, REG_HSISR, tmp); | ||
3814 | -} | ||
3815 | - | ||
3816 | void rtl92ee_enable_interrupt(struct ieee80211_hw *hw) | ||
3817 | { | ||
3818 | struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3819 | struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); | ||
3820 | |||
3821 | - rtl92ee_clear_interrupt(hw);/*clear it here first*/ | ||
3822 | - | ||
3823 | rtl_write_dword(rtlpriv, REG_HIMR, rtlpci->irq_mask[0] & 0xFFFFFFFF); | ||
3824 | rtl_write_dword(rtlpriv, REG_HIMRE, rtlpci->irq_mask[1] & 0xFFFFFFFF); | ||
3825 | rtlpci->irq_enabled = true; | ||
3826 | diff --git a/drivers/net/wireless/rtlwifi/rtl8723ae/hw.c b/drivers/net/wireless/rtlwifi/rtl8723ae/hw.c | ||
3827 | index aa085462d0e9..5e1334082570 100644 | ||
3828 | --- a/drivers/net/wireless/rtlwifi/rtl8723ae/hw.c | ||
3829 | +++ b/drivers/net/wireless/rtlwifi/rtl8723ae/hw.c | ||
3830 | @@ -1258,18 +1258,6 @@ void rtl8723e_set_qos(struct ieee80211_hw *hw, int aci) | ||
3831 | } | ||
3832 | } | ||
3833 | |||
3834 | -static void rtl8723e_clear_interrupt(struct ieee80211_hw *hw) | ||
3835 | -{ | ||
3836 | - struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3837 | - u32 tmp; | ||
3838 | - | ||
3839 | - tmp = rtl_read_dword(rtlpriv, REG_HISR); | ||
3840 | - rtl_write_dword(rtlpriv, REG_HISR, tmp); | ||
3841 | - | ||
3842 | - tmp = rtl_read_dword(rtlpriv, REG_HISRE); | ||
3843 | - rtl_write_dword(rtlpriv, REG_HISRE, tmp); | ||
3844 | -} | ||
3845 | - | ||
3846 | void rtl8723e_enable_interrupt(struct ieee80211_hw *hw) | ||
3847 | { | ||
3848 | struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3849 | @@ -1284,7 +1272,6 @@ void rtl8723e_disable_interrupt(struct ieee80211_hw *hw) | ||
3850 | { | ||
3851 | struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3852 | struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); | ||
3853 | - rtl8723e_clear_interrupt(hw);/*clear it here first*/ | ||
3854 | rtl_write_dword(rtlpriv, 0x3a8, IMR8190_DISABLED); | ||
3855 | rtl_write_dword(rtlpriv, 0x3ac, IMR8190_DISABLED); | ||
3856 | rtlpci->irq_enabled = false; | ||
3857 | diff --git a/drivers/net/wireless/rtlwifi/rtl8723be/hw.c b/drivers/net/wireless/rtlwifi/rtl8723be/hw.c | ||
3858 | index 6dad28e77bbb..cfe679963676 100644 | ||
3859 | --- a/drivers/net/wireless/rtlwifi/rtl8723be/hw.c | ||
3860 | +++ b/drivers/net/wireless/rtlwifi/rtl8723be/hw.c | ||
3861 | @@ -1634,28 +1634,11 @@ void rtl8723be_set_qos(struct ieee80211_hw *hw, int aci) | ||
3862 | } | ||
3863 | } | ||
3864 | |||
3865 | -static void rtl8723be_clear_interrupt(struct ieee80211_hw *hw) | ||
3866 | -{ | ||
3867 | - struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3868 | - u32 tmp; | ||
3869 | - | ||
3870 | - tmp = rtl_read_dword(rtlpriv, REG_HISR); | ||
3871 | - rtl_write_dword(rtlpriv, REG_HISR, tmp); | ||
3872 | - | ||
3873 | - tmp = rtl_read_dword(rtlpriv, REG_HISRE); | ||
3874 | - rtl_write_dword(rtlpriv, REG_HISRE, tmp); | ||
3875 | - | ||
3876 | - tmp = rtl_read_dword(rtlpriv, REG_HSISR); | ||
3877 | - rtl_write_dword(rtlpriv, REG_HSISR, tmp); | ||
3878 | -} | ||
3879 | - | ||
3880 | void rtl8723be_enable_interrupt(struct ieee80211_hw *hw) | ||
3881 | { | ||
3882 | struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3883 | struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); | ||
3884 | |||
3885 | - rtl8723be_clear_interrupt(hw);/*clear it here first*/ | ||
3886 | - | ||
3887 | rtl_write_dword(rtlpriv, REG_HIMR, rtlpci->irq_mask[0] & 0xFFFFFFFF); | ||
3888 | rtl_write_dword(rtlpriv, REG_HIMRE, rtlpci->irq_mask[1] & 0xFFFFFFFF); | ||
3889 | rtlpci->irq_enabled = true; | ||
3890 | diff --git a/drivers/net/wireless/rtlwifi/rtl8821ae/hw.c b/drivers/net/wireless/rtlwifi/rtl8821ae/hw.c | ||
3891 | index 8ec8200002c7..43c14d4da563 100644 | ||
3892 | --- a/drivers/net/wireless/rtlwifi/rtl8821ae/hw.c | ||
3893 | +++ b/drivers/net/wireless/rtlwifi/rtl8821ae/hw.c | ||
3894 | @@ -2253,31 +2253,11 @@ void rtl8821ae_set_qos(struct ieee80211_hw *hw, int aci) | ||
3895 | } | ||
3896 | } | ||
3897 | |||
3898 | -static void rtl8821ae_clear_interrupt(struct ieee80211_hw *hw) | ||
3899 | -{ | ||
3900 | - struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3901 | - u32 tmp; | ||
3902 | - tmp = rtl_read_dword(rtlpriv, REG_HISR); | ||
3903 | - /*printk("clear interrupt first:\n"); | ||
3904 | - printk("0x%x = 0x%08x\n",REG_HISR, tmp);*/ | ||
3905 | - rtl_write_dword(rtlpriv, REG_HISR, tmp); | ||
3906 | - | ||
3907 | - tmp = rtl_read_dword(rtlpriv, REG_HISRE); | ||
3908 | - /*printk("0x%x = 0x%08x\n",REG_HISRE, tmp);*/ | ||
3909 | - rtl_write_dword(rtlpriv, REG_HISRE, tmp); | ||
3910 | - | ||
3911 | - tmp = rtl_read_dword(rtlpriv, REG_HSISR); | ||
3912 | - /*printk("0x%x = 0x%08x\n",REG_HSISR, tmp);*/ | ||
3913 | - rtl_write_dword(rtlpriv, REG_HSISR, tmp); | ||
3914 | -} | ||
3915 | - | ||
3916 | void rtl8821ae_enable_interrupt(struct ieee80211_hw *hw) | ||
3917 | { | ||
3918 | struct rtl_priv *rtlpriv = rtl_priv(hw); | ||
3919 | struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); | ||
3920 | |||
3921 | - rtl8821ae_clear_interrupt(hw);/*clear it here first*/ | ||
3922 | - | ||
3923 | rtl_write_dword(rtlpriv, REG_HIMR, rtlpci->irq_mask[0] & 0xFFFFFFFF); | ||
3924 | rtl_write_dword(rtlpriv, REG_HIMRE, rtlpci->irq_mask[1] & 0xFFFFFFFF); | ||
3925 | rtlpci->irq_enabled = true; | ||
3926 | diff --git a/drivers/nfc/st21nfcb/i2c.c b/drivers/nfc/st21nfcb/i2c.c | ||
3927 | index 2cf867b9796d..157259d5fa26 100644 | ||
3928 | --- a/drivers/nfc/st21nfcb/i2c.c | ||
3929 | +++ b/drivers/nfc/st21nfcb/i2c.c | ||
3930 | @@ -90,11 +90,6 @@ static void st21nfcb_nci_i2c_disable(void *phy_id) | ||
3931 | gpio_set_value(phy->gpio_reset, 1); | ||
3932 | } | ||
3933 | |||
3934 | -static void st21nfcb_nci_remove_header(struct sk_buff *skb) | ||
3935 | -{ | ||
3936 | - skb_pull(skb, ST21NFCB_FRAME_HEADROOM); | ||
3937 | -} | ||
3938 | - | ||
3939 | /* | ||
3940 | * Writing a frame must not return the number of written bytes. | ||
3941 | * It must return either zero for success, or <0 for error. | ||
3942 | @@ -124,8 +119,6 @@ static int st21nfcb_nci_i2c_write(void *phy_id, struct sk_buff *skb) | ||
3943 | r = 0; | ||
3944 | } | ||
3945 | |||
3946 | - st21nfcb_nci_remove_header(skb); | ||
3947 | - | ||
3948 | return r; | ||
3949 | } | ||
3950 | |||
3951 | @@ -395,9 +388,6 @@ static int st21nfcb_nci_i2c_remove(struct i2c_client *client) | ||
3952 | |||
3953 | ndlc_remove(phy->ndlc); | ||
3954 | |||
3955 | - if (phy->powered) | ||
3956 | - st21nfcb_nci_i2c_disable(phy); | ||
3957 | - | ||
3958 | return 0; | ||
3959 | } | ||
3960 | |||
3961 | diff --git a/drivers/nfc/st21nfcb/st21nfcb.c b/drivers/nfc/st21nfcb/st21nfcb.c | ||
3962 | index ea63d5877831..28b39143a830 100644 | ||
3963 | --- a/drivers/nfc/st21nfcb/st21nfcb.c | ||
3964 | +++ b/drivers/nfc/st21nfcb/st21nfcb.c | ||
3965 | @@ -122,11 +122,8 @@ EXPORT_SYMBOL_GPL(st21nfcb_nci_probe); | ||
3966 | |||
3967 | void st21nfcb_nci_remove(struct nci_dev *ndev) | ||
3968 | { | ||
3969 | - struct st21nfcb_nci_info *info = nci_get_drvdata(ndev); | ||
3970 | - | ||
3971 | nci_unregister_device(ndev); | ||
3972 | nci_free_device(ndev); | ||
3973 | - kfree(info); | ||
3974 | } | ||
3975 | EXPORT_SYMBOL_GPL(st21nfcb_nci_remove); | ||
3976 | |||
3977 | diff --git a/drivers/of/address.c b/drivers/of/address.c | ||
3978 | index 216b00d99bd8..1dba1a9c1fcf 100644 | ||
3979 | --- a/drivers/of/address.c | ||
3980 | +++ b/drivers/of/address.c | ||
3981 | @@ -712,7 +712,7 @@ int __weak pci_register_io_range(phys_addr_t addr, resource_size_t size) | ||
3982 | } | ||
3983 | |||
3984 | /* add the range to the list */ | ||
3985 | - range = kzalloc(sizeof(*range), GFP_KERNEL); | ||
3986 | + range = kzalloc(sizeof(*range), GFP_ATOMIC); | ||
3987 | if (!range) { | ||
3988 | err = -ENOMEM; | ||
3989 | goto end_register; | ||
3990 | @@ -765,7 +765,7 @@ unsigned long __weak pci_address_to_pio(phys_addr_t address) | ||
3991 | spin_lock(&io_range_lock); | ||
3992 | list_for_each_entry(res, &io_range_list, list) { | ||
3993 | if (address >= res->start && address < res->start + res->size) { | ||
3994 | - addr = res->start - address + offset; | ||
3995 | + addr = address - res->start + offset; | ||
3996 | break; | ||
3997 | } | ||
3998 | offset += res->size; | ||
3999 | diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c | ||
4000 | index 0ebf754fc177..6d6868811e56 100644 | ||
4001 | --- a/drivers/pci/hotplug/pciehp_hpc.c | ||
4002 | +++ b/drivers/pci/hotplug/pciehp_hpc.c | ||
4003 | @@ -176,20 +176,17 @@ static void pcie_wait_cmd(struct controller *ctrl) | ||
4004 | jiffies_to_msecs(jiffies - ctrl->cmd_started)); | ||
4005 | } | ||
4006 | |||
4007 | -/** | ||
4008 | - * pcie_write_cmd - Issue controller command | ||
4009 | - * @ctrl: controller to which the command is issued | ||
4010 | - * @cmd: command value written to slot control register | ||
4011 | - * @mask: bitmask of slot control register to be modified | ||
4012 | - */ | ||
4013 | -static void pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask) | ||
4014 | +static void pcie_do_write_cmd(struct controller *ctrl, u16 cmd, | ||
4015 | + u16 mask, bool wait) | ||
4016 | { | ||
4017 | struct pci_dev *pdev = ctrl_dev(ctrl); | ||
4018 | u16 slot_ctrl; | ||
4019 | |||
4020 | mutex_lock(&ctrl->ctrl_lock); | ||
4021 | |||
4022 | - /* Wait for any previous command that might still be in progress */ | ||
4023 | + /* | ||
4024 | + * Always wait for any previous command that might still be in progress | ||
4025 | + */ | ||
4026 | pcie_wait_cmd(ctrl); | ||
4027 | |||
4028 | pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &slot_ctrl); | ||
4029 | @@ -201,9 +198,33 @@ static void pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask) | ||
4030 | ctrl->cmd_started = jiffies; | ||
4031 | ctrl->slot_ctrl = slot_ctrl; | ||
4032 | |||
4033 | + /* | ||
4034 | + * Optionally wait for the hardware to be ready for a new command, | ||
4035 | + * indicating completion of the above issued command. | ||
4036 | + */ | ||
4037 | + if (wait) | ||
4038 | + pcie_wait_cmd(ctrl); | ||
4039 | + | ||
4040 | mutex_unlock(&ctrl->ctrl_lock); | ||
4041 | } | ||
4042 | |||
4043 | +/** | ||
4044 | + * pcie_write_cmd - Issue controller command | ||
4045 | + * @ctrl: controller to which the command is issued | ||
4046 | + * @cmd: command value written to slot control register | ||
4047 | + * @mask: bitmask of slot control register to be modified | ||
4048 | + */ | ||
4049 | +static void pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask) | ||
4050 | +{ | ||
4051 | + pcie_do_write_cmd(ctrl, cmd, mask, true); | ||
4052 | +} | ||
4053 | + | ||
4054 | +/* Same as above without waiting for the hardware to latch */ | ||
4055 | +static void pcie_write_cmd_nowait(struct controller *ctrl, u16 cmd, u16 mask) | ||
4056 | +{ | ||
4057 | + pcie_do_write_cmd(ctrl, cmd, mask, false); | ||
4058 | +} | ||
4059 | + | ||
4060 | bool pciehp_check_link_active(struct controller *ctrl) | ||
4061 | { | ||
4062 | struct pci_dev *pdev = ctrl_dev(ctrl); | ||
4063 | @@ -422,7 +443,7 @@ void pciehp_set_attention_status(struct slot *slot, u8 value) | ||
4064 | default: | ||
4065 | return; | ||
4066 | } | ||
4067 | - pcie_write_cmd(ctrl, slot_cmd, PCI_EXP_SLTCTL_AIC); | ||
4068 | + pcie_write_cmd_nowait(ctrl, slot_cmd, PCI_EXP_SLTCTL_AIC); | ||
4069 | ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__, | ||
4070 | pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd); | ||
4071 | } | ||
4072 | @@ -434,7 +455,8 @@ void pciehp_green_led_on(struct slot *slot) | ||
4073 | if (!PWR_LED(ctrl)) | ||
4074 | return; | ||
4075 | |||
4076 | - pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_IND_ON, PCI_EXP_SLTCTL_PIC); | ||
4077 | + pcie_write_cmd_nowait(ctrl, PCI_EXP_SLTCTL_PWR_IND_ON, | ||
4078 | + PCI_EXP_SLTCTL_PIC); | ||
4079 | ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__, | ||
4080 | pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, | ||
4081 | PCI_EXP_SLTCTL_PWR_IND_ON); | ||
4082 | @@ -447,7 +469,8 @@ void pciehp_green_led_off(struct slot *slot) | ||
4083 | if (!PWR_LED(ctrl)) | ||
4084 | return; | ||
4085 | |||
4086 | - pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF, PCI_EXP_SLTCTL_PIC); | ||
4087 | + pcie_write_cmd_nowait(ctrl, PCI_EXP_SLTCTL_PWR_IND_OFF, | ||
4088 | + PCI_EXP_SLTCTL_PIC); | ||
4089 | ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__, | ||
4090 | pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, | ||
4091 | PCI_EXP_SLTCTL_PWR_IND_OFF); | ||
4092 | @@ -460,7 +483,8 @@ void pciehp_green_led_blink(struct slot *slot) | ||
4093 | if (!PWR_LED(ctrl)) | ||
4094 | return; | ||
4095 | |||
4096 | - pcie_write_cmd(ctrl, PCI_EXP_SLTCTL_PWR_IND_BLINK, PCI_EXP_SLTCTL_PIC); | ||
4097 | + pcie_write_cmd_nowait(ctrl, PCI_EXP_SLTCTL_PWR_IND_BLINK, | ||
4098 | + PCI_EXP_SLTCTL_PIC); | ||
4099 | ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__, | ||
4100 | pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, | ||
4101 | PCI_EXP_SLTCTL_PWR_IND_BLINK); | ||
4102 | @@ -613,7 +637,7 @@ void pcie_enable_notification(struct controller *ctrl) | ||
4103 | PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_CCIE | | ||
4104 | PCI_EXP_SLTCTL_DLLSCE); | ||
4105 | |||
4106 | - pcie_write_cmd(ctrl, cmd, mask); | ||
4107 | + pcie_write_cmd_nowait(ctrl, cmd, mask); | ||
4108 | ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__, | ||
4109 | pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, cmd); | ||
4110 | } | ||
4111 | @@ -664,7 +688,7 @@ int pciehp_reset_slot(struct slot *slot, int probe) | ||
4112 | pci_reset_bridge_secondary_bus(ctrl->pcie->port); | ||
4113 | |||
4114 | pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, stat_mask); | ||
4115 | - pcie_write_cmd(ctrl, ctrl_mask, ctrl_mask); | ||
4116 | + pcie_write_cmd_nowait(ctrl, ctrl_mask, ctrl_mask); | ||
4117 | ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__, | ||
4118 | pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, ctrl_mask); | ||
4119 | if (pciehp_poll_mode) | ||
4120 | diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c | ||
4121 | index 0190d1ee36b7..ff7af33f2353 100644 | ||
4122 | --- a/drivers/pci/pci.c | ||
4123 | +++ b/drivers/pci/pci.c | ||
4124 | @@ -4299,6 +4299,17 @@ bool pci_device_is_present(struct pci_dev *pdev) | ||
4125 | } | ||
4126 | EXPORT_SYMBOL_GPL(pci_device_is_present); | ||
4127 | |||
4128 | +void pci_ignore_hotplug(struct pci_dev *dev) | ||
4129 | +{ | ||
4130 | + struct pci_dev *bridge = dev->bus->self; | ||
4131 | + | ||
4132 | + dev->ignore_hotplug = 1; | ||
4133 | + /* Propagate the "ignore hotplug" setting to the parent bridge. */ | ||
4134 | + if (bridge) | ||
4135 | + bridge->ignore_hotplug = 1; | ||
4136 | +} | ||
4137 | +EXPORT_SYMBOL_GPL(pci_ignore_hotplug); | ||
4138 | + | ||
4139 | #define RESOURCE_ALIGNMENT_PARAM_SIZE COMMAND_LINE_SIZE | ||
4140 | static char resource_alignment_param[RESOURCE_ALIGNMENT_PARAM_SIZE] = {0}; | ||
4141 | static DEFINE_SPINLOCK(resource_alignment_lock); | ||
4142 | diff --git a/drivers/pcmcia/topic.h b/drivers/pcmcia/topic.h | ||
4143 | index 615a45a8fe86..582688fe7505 100644 | ||
4144 | --- a/drivers/pcmcia/topic.h | ||
4145 | +++ b/drivers/pcmcia/topic.h | ||
4146 | @@ -104,6 +104,9 @@ | ||
4147 | #define TOPIC_EXCA_IF_CONTROL 0x3e /* 8 bit */ | ||
4148 | #define TOPIC_EXCA_IFC_33V_ENA 0x01 | ||
4149 | |||
4150 | +#define TOPIC_PCI_CFG_PPBCN 0x3e /* 16-bit */ | ||
4151 | +#define TOPIC_PCI_CFG_PPBCN_WBEN 0x0400 | ||
4152 | + | ||
4153 | static void topic97_zoom_video(struct pcmcia_socket *sock, int onoff) | ||
4154 | { | ||
4155 | struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); | ||
4156 | @@ -138,6 +141,7 @@ static int topic97_override(struct yenta_socket *socket) | ||
4157 | static int topic95_override(struct yenta_socket *socket) | ||
4158 | { | ||
4159 | u8 fctrl; | ||
4160 | + u16 ppbcn; | ||
4161 | |||
4162 | /* enable 3.3V support for 16bit cards */ | ||
4163 | fctrl = exca_readb(socket, TOPIC_EXCA_IF_CONTROL); | ||
4164 | @@ -146,6 +150,18 @@ static int topic95_override(struct yenta_socket *socket) | ||
4165 | /* tell yenta to use exca registers to power 16bit cards */ | ||
4166 | socket->flags |= YENTA_16BIT_POWER_EXCA | YENTA_16BIT_POWER_DF; | ||
4167 | |||
4168 | + /* Disable write buffers to prevent lockups under load with numerous | ||
4169 | + Cardbus cards, observed on Tecra 500CDT and reported elsewhere on the | ||
4170 | + net. This is not a power-on default according to the datasheet | ||
4171 | + but some BIOSes seem to set it. */ | ||
4172 | + if (pci_read_config_word(socket->dev, TOPIC_PCI_CFG_PPBCN, &ppbcn) == 0 | ||
4173 | + && socket->dev->revision <= 7 | ||
4174 | + && (ppbcn & TOPIC_PCI_CFG_PPBCN_WBEN)) { | ||
4175 | + ppbcn &= ~TOPIC_PCI_CFG_PPBCN_WBEN; | ||
4176 | + pci_write_config_word(socket->dev, TOPIC_PCI_CFG_PPBCN, ppbcn); | ||
4177 | + dev_info(&socket->dev->dev, "Disabled ToPIC95 Cardbus write buffers.\n"); | ||
4178 | + } | ||
4179 | + | ||
4180 | return 0; | ||
4181 | } | ||
4182 | |||
4183 | diff --git a/drivers/pinctrl/mvebu/pinctrl-armada-370.c b/drivers/pinctrl/mvebu/pinctrl-armada-370.c | ||
4184 | index 670e5b01c678..5e423e0b0cb2 100644 | ||
4185 | --- a/drivers/pinctrl/mvebu/pinctrl-armada-370.c | ||
4186 | +++ b/drivers/pinctrl/mvebu/pinctrl-armada-370.c | ||
4187 | @@ -370,11 +370,11 @@ static struct mvebu_mpp_mode mv88f6710_mpp_modes[] = { | ||
4188 | MPP_MODE(64, | ||
4189 | MPP_FUNCTION(0x0, "gpio", NULL), | ||
4190 | MPP_FUNCTION(0x1, "spi0", "miso"), | ||
4191 | - MPP_FUNCTION(0x2, "spi0-1", "cs1")), | ||
4192 | + MPP_FUNCTION(0x2, "spi0", "cs1")), | ||
4193 | MPP_MODE(65, | ||
4194 | MPP_FUNCTION(0x0, "gpio", NULL), | ||
4195 | MPP_FUNCTION(0x1, "spi0", "mosi"), | ||
4196 | - MPP_FUNCTION(0x2, "spi0-1", "cs2")), | ||
4197 | + MPP_FUNCTION(0x2, "spi0", "cs2")), | ||
4198 | }; | ||
4199 | |||
4200 | static struct mvebu_pinctrl_soc_info armada_370_pinctrl_info; | ||
4201 | diff --git a/drivers/pinctrl/mvebu/pinctrl-armada-375.c b/drivers/pinctrl/mvebu/pinctrl-armada-375.c | ||
4202 | index db078fe7ace6..64cc1184ecc2 100644 | ||
4203 | --- a/drivers/pinctrl/mvebu/pinctrl-armada-375.c | ||
4204 | +++ b/drivers/pinctrl/mvebu/pinctrl-armada-375.c | ||
4205 | @@ -92,19 +92,17 @@ static struct mvebu_mpp_mode mv88f6720_mpp_modes[] = { | ||
4206 | MPP_FUNCTION(0x5, "nand", "io1")), | ||
4207 | MPP_MODE(8, | ||
4208 | MPP_FUNCTION(0x0, "gpio", NULL), | ||
4209 | - MPP_FUNCTION(0x1, "dev ", "bootcs"), | ||
4210 | + MPP_FUNCTION(0x1, "dev", "bootcs"), | ||
4211 | MPP_FUNCTION(0x2, "spi0", "cs0"), | ||
4212 | MPP_FUNCTION(0x3, "spi1", "cs0"), | ||
4213 | MPP_FUNCTION(0x5, "nand", "ce")), | ||
4214 | MPP_MODE(9, | ||
4215 | MPP_FUNCTION(0x0, "gpio", NULL), | ||
4216 | - MPP_FUNCTION(0x1, "nf", "wen"), | ||
4217 | MPP_FUNCTION(0x2, "spi0", "sck"), | ||
4218 | MPP_FUNCTION(0x3, "spi1", "sck"), | ||
4219 | MPP_FUNCTION(0x5, "nand", "we")), | ||
4220 | MPP_MODE(10, | ||
4221 | MPP_FUNCTION(0x0, "gpio", NULL), | ||
4222 | - MPP_FUNCTION(0x1, "nf", "ren"), | ||
4223 | MPP_FUNCTION(0x2, "dram", "vttctrl"), | ||
4224 | MPP_FUNCTION(0x3, "led", "c1"), | ||
4225 | MPP_FUNCTION(0x5, "nand", "re"), | ||
4226 | diff --git a/drivers/pinctrl/mvebu/pinctrl-armada-38x.c b/drivers/pinctrl/mvebu/pinctrl-armada-38x.c | ||
4227 | index 1049f82fb62f..adb6c238f059 100644 | ||
4228 | --- a/drivers/pinctrl/mvebu/pinctrl-armada-38x.c | ||
4229 | +++ b/drivers/pinctrl/mvebu/pinctrl-armada-38x.c | ||
4230 | @@ -94,37 +94,39 @@ static struct mvebu_mpp_mode armada_38x_mpp_modes[] = { | ||
4231 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4232 | MPP_VAR_FUNCTION(1, "ge0", "rxd0", V_88F6810_PLUS), | ||
4233 | MPP_VAR_FUNCTION(2, "pcie0", "rstout", V_88F6810_PLUS), | ||
4234 | - MPP_VAR_FUNCTION(3, "pcie1", "rstout", V_88F6820_PLUS), | ||
4235 | MPP_VAR_FUNCTION(4, "spi0", "cs1", V_88F6810_PLUS), | ||
4236 | - MPP_VAR_FUNCTION(5, "dev", "ad14", V_88F6810_PLUS)), | ||
4237 | + MPP_VAR_FUNCTION(5, "dev", "ad14", V_88F6810_PLUS), | ||
4238 | + MPP_VAR_FUNCTION(6, "pcie3", "clkreq", V_88F6810_PLUS)), | ||
4239 | MPP_MODE(13, | ||
4240 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4241 | MPP_VAR_FUNCTION(1, "ge0", "rxd1", V_88F6810_PLUS), | ||
4242 | MPP_VAR_FUNCTION(2, "pcie0", "clkreq", V_88F6810_PLUS), | ||
4243 | MPP_VAR_FUNCTION(3, "pcie1", "clkreq", V_88F6820_PLUS), | ||
4244 | MPP_VAR_FUNCTION(4, "spi0", "cs2", V_88F6810_PLUS), | ||
4245 | - MPP_VAR_FUNCTION(5, "dev", "ad15", V_88F6810_PLUS)), | ||
4246 | + MPP_VAR_FUNCTION(5, "dev", "ad15", V_88F6810_PLUS), | ||
4247 | + MPP_VAR_FUNCTION(6, "pcie2", "clkreq", V_88F6810_PLUS)), | ||
4248 | MPP_MODE(14, | ||
4249 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4250 | MPP_VAR_FUNCTION(1, "ge0", "rxd2", V_88F6810_PLUS), | ||
4251 | MPP_VAR_FUNCTION(2, "ptp", "clk", V_88F6810_PLUS), | ||
4252 | MPP_VAR_FUNCTION(3, "m", "vtt_ctrl", V_88F6810_PLUS), | ||
4253 | MPP_VAR_FUNCTION(4, "spi0", "cs3", V_88F6810_PLUS), | ||
4254 | - MPP_VAR_FUNCTION(5, "dev", "wen1", V_88F6810_PLUS)), | ||
4255 | + MPP_VAR_FUNCTION(5, "dev", "wen1", V_88F6810_PLUS), | ||
4256 | + MPP_VAR_FUNCTION(6, "pcie3", "clkreq", V_88F6810_PLUS)), | ||
4257 | MPP_MODE(15, | ||
4258 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4259 | MPP_VAR_FUNCTION(1, "ge0", "rxd3", V_88F6810_PLUS), | ||
4260 | MPP_VAR_FUNCTION(2, "ge", "mdc slave", V_88F6810_PLUS), | ||
4261 | MPP_VAR_FUNCTION(3, "pcie0", "rstout", V_88F6810_PLUS), | ||
4262 | - MPP_VAR_FUNCTION(4, "spi0", "mosi", V_88F6810_PLUS), | ||
4263 | - MPP_VAR_FUNCTION(5, "pcie1", "rstout", V_88F6820_PLUS)), | ||
4264 | + MPP_VAR_FUNCTION(4, "spi0", "mosi", V_88F6810_PLUS)), | ||
4265 | MPP_MODE(16, | ||
4266 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4267 | MPP_VAR_FUNCTION(1, "ge0", "rxctl", V_88F6810_PLUS), | ||
4268 | MPP_VAR_FUNCTION(2, "ge", "mdio slave", V_88F6810_PLUS), | ||
4269 | MPP_VAR_FUNCTION(3, "m", "decc_err", V_88F6810_PLUS), | ||
4270 | MPP_VAR_FUNCTION(4, "spi0", "miso", V_88F6810_PLUS), | ||
4271 | - MPP_VAR_FUNCTION(5, "pcie0", "clkreq", V_88F6810_PLUS)), | ||
4272 | + MPP_VAR_FUNCTION(5, "pcie0", "clkreq", V_88F6810_PLUS), | ||
4273 | + MPP_VAR_FUNCTION(6, "pcie1", "clkreq", V_88F6820_PLUS)), | ||
4274 | MPP_MODE(17, | ||
4275 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4276 | MPP_VAR_FUNCTION(1, "ge0", "rxclk", V_88F6810_PLUS), | ||
4277 | @@ -137,20 +139,18 @@ static struct mvebu_mpp_mode armada_38x_mpp_modes[] = { | ||
4278 | MPP_VAR_FUNCTION(1, "ge0", "rxerr", V_88F6810_PLUS), | ||
4279 | MPP_VAR_FUNCTION(2, "ptp", "trig_gen", V_88F6810_PLUS), | ||
4280 | MPP_VAR_FUNCTION(3, "ua1", "txd", V_88F6810_PLUS), | ||
4281 | - MPP_VAR_FUNCTION(4, "spi0", "cs0", V_88F6810_PLUS), | ||
4282 | - MPP_VAR_FUNCTION(5, "pcie1", "rstout", V_88F6820_PLUS)), | ||
4283 | + MPP_VAR_FUNCTION(4, "spi0", "cs0", V_88F6810_PLUS)), | ||
4284 | MPP_MODE(19, | ||
4285 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4286 | MPP_VAR_FUNCTION(1, "ge0", "col", V_88F6810_PLUS), | ||
4287 | MPP_VAR_FUNCTION(2, "ptp", "event_req", V_88F6810_PLUS), | ||
4288 | - MPP_VAR_FUNCTION(3, "pcie0", "clkreq", V_88F6810_PLUS), | ||
4289 | + MPP_VAR_FUNCTION(3, "ge0", "txerr", V_88F6810_PLUS), | ||
4290 | MPP_VAR_FUNCTION(4, "sata1", "prsnt", V_88F6810_PLUS), | ||
4291 | MPP_VAR_FUNCTION(5, "ua0", "cts", V_88F6810_PLUS)), | ||
4292 | MPP_MODE(20, | ||
4293 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4294 | MPP_VAR_FUNCTION(1, "ge0", "txclk", V_88F6810_PLUS), | ||
4295 | MPP_VAR_FUNCTION(2, "ptp", "clk", V_88F6810_PLUS), | ||
4296 | - MPP_VAR_FUNCTION(3, "pcie1", "rstout", V_88F6820_PLUS), | ||
4297 | MPP_VAR_FUNCTION(4, "sata0", "prsnt", V_88F6810_PLUS), | ||
4298 | MPP_VAR_FUNCTION(5, "ua0", "rts", V_88F6810_PLUS)), | ||
4299 | MPP_MODE(21, | ||
4300 | @@ -275,35 +275,27 @@ static struct mvebu_mpp_mode armada_38x_mpp_modes[] = { | ||
4301 | MPP_VAR_FUNCTION(1, "pcie0", "clkreq", V_88F6810_PLUS), | ||
4302 | MPP_VAR_FUNCTION(2, "m", "vtt_ctrl", V_88F6810_PLUS), | ||
4303 | MPP_VAR_FUNCTION(3, "m", "decc_err", V_88F6810_PLUS), | ||
4304 | - MPP_VAR_FUNCTION(4, "pcie0", "rstout", V_88F6810_PLUS), | ||
4305 | + MPP_VAR_FUNCTION(4, "spi1", "cs2", V_88F6810_PLUS), | ||
4306 | MPP_VAR_FUNCTION(5, "dev", "clkout", V_88F6810_PLUS)), | ||
4307 | MPP_MODE(44, | ||
4308 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4309 | MPP_VAR_FUNCTION(1, "sata0", "prsnt", V_88F6810_PLUS), | ||
4310 | MPP_VAR_FUNCTION(2, "sata1", "prsnt", V_88F6810_PLUS), | ||
4311 | MPP_VAR_FUNCTION(3, "sata2", "prsnt", V_88F6828), | ||
4312 | - MPP_VAR_FUNCTION(4, "sata3", "prsnt", V_88F6828), | ||
4313 | - MPP_VAR_FUNCTION(5, "pcie0", "rstout", V_88F6810_PLUS)), | ||
4314 | + MPP_VAR_FUNCTION(4, "sata3", "prsnt", V_88F6828)), | ||
4315 | MPP_MODE(45, | ||
4316 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4317 | MPP_VAR_FUNCTION(1, "ref", "clk_out0", V_88F6810_PLUS), | ||
4318 | - MPP_VAR_FUNCTION(2, "pcie0", "rstout", V_88F6810_PLUS), | ||
4319 | - MPP_VAR_FUNCTION(3, "pcie1", "rstout", V_88F6820_PLUS), | ||
4320 | - MPP_VAR_FUNCTION(4, "pcie2", "rstout", V_88F6810_PLUS), | ||
4321 | - MPP_VAR_FUNCTION(5, "pcie3", "rstout", V_88F6810_PLUS)), | ||
4322 | + MPP_VAR_FUNCTION(2, "pcie0", "rstout", V_88F6810_PLUS)), | ||
4323 | MPP_MODE(46, | ||
4324 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4325 | MPP_VAR_FUNCTION(1, "ref", "clk_out1", V_88F6810_PLUS), | ||
4326 | - MPP_VAR_FUNCTION(2, "pcie0", "rstout", V_88F6810_PLUS), | ||
4327 | - MPP_VAR_FUNCTION(3, "pcie1", "rstout", V_88F6820_PLUS), | ||
4328 | - MPP_VAR_FUNCTION(4, "pcie2", "rstout", V_88F6810_PLUS), | ||
4329 | - MPP_VAR_FUNCTION(5, "pcie3", "rstout", V_88F6810_PLUS)), | ||
4330 | + MPP_VAR_FUNCTION(2, "pcie0", "rstout", V_88F6810_PLUS)), | ||
4331 | MPP_MODE(47, | ||
4332 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4333 | MPP_VAR_FUNCTION(1, "sata0", "prsnt", V_88F6810_PLUS), | ||
4334 | MPP_VAR_FUNCTION(2, "sata1", "prsnt", V_88F6810_PLUS), | ||
4335 | MPP_VAR_FUNCTION(3, "sata2", "prsnt", V_88F6828), | ||
4336 | - MPP_VAR_FUNCTION(4, "spi1", "cs2", V_88F6810_PLUS), | ||
4337 | MPP_VAR_FUNCTION(5, "sata3", "prsnt", V_88F6828)), | ||
4338 | MPP_MODE(48, | ||
4339 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4340 | @@ -311,18 +303,19 @@ static struct mvebu_mpp_mode armada_38x_mpp_modes[] = { | ||
4341 | MPP_VAR_FUNCTION(2, "m", "vtt_ctrl", V_88F6810_PLUS), | ||
4342 | MPP_VAR_FUNCTION(3, "tdm2c", "pclk", V_88F6810_PLUS), | ||
4343 | MPP_VAR_FUNCTION(4, "audio", "mclk", V_88F6810_PLUS), | ||
4344 | - MPP_VAR_FUNCTION(5, "sd0", "d4", V_88F6810_PLUS)), | ||
4345 | + MPP_VAR_FUNCTION(5, "sd0", "d4", V_88F6810_PLUS), | ||
4346 | + MPP_VAR_FUNCTION(6, "pcie0", "clkreq", V_88F6810_PLUS)), | ||
4347 | MPP_MODE(49, | ||
4348 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4349 | MPP_VAR_FUNCTION(1, "sata2", "prsnt", V_88F6828), | ||
4350 | MPP_VAR_FUNCTION(2, "sata3", "prsnt", V_88F6828), | ||
4351 | MPP_VAR_FUNCTION(3, "tdm2c", "fsync", V_88F6810_PLUS), | ||
4352 | MPP_VAR_FUNCTION(4, "audio", "lrclk", V_88F6810_PLUS), | ||
4353 | - MPP_VAR_FUNCTION(5, "sd0", "d5", V_88F6810_PLUS)), | ||
4354 | + MPP_VAR_FUNCTION(5, "sd0", "d5", V_88F6810_PLUS), | ||
4355 | + MPP_VAR_FUNCTION(6, "pcie1", "clkreq", V_88F6820_PLUS)), | ||
4356 | MPP_MODE(50, | ||
4357 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4358 | MPP_VAR_FUNCTION(1, "pcie0", "rstout", V_88F6810_PLUS), | ||
4359 | - MPP_VAR_FUNCTION(2, "pcie1", "rstout", V_88F6820_PLUS), | ||
4360 | MPP_VAR_FUNCTION(3, "tdm2c", "drx", V_88F6810_PLUS), | ||
4361 | MPP_VAR_FUNCTION(4, "audio", "extclk", V_88F6810_PLUS), | ||
4362 | MPP_VAR_FUNCTION(5, "sd0", "cmd", V_88F6810_PLUS)), | ||
4363 | @@ -334,7 +327,6 @@ static struct mvebu_mpp_mode armada_38x_mpp_modes[] = { | ||
4364 | MPP_MODE(52, | ||
4365 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4366 | MPP_VAR_FUNCTION(1, "pcie0", "rstout", V_88F6810_PLUS), | ||
4367 | - MPP_VAR_FUNCTION(2, "pcie1", "rstout", V_88F6820_PLUS), | ||
4368 | MPP_VAR_FUNCTION(3, "tdm2c", "intn", V_88F6810_PLUS), | ||
4369 | MPP_VAR_FUNCTION(4, "audio", "sdi", V_88F6810_PLUS), | ||
4370 | MPP_VAR_FUNCTION(5, "sd0", "d6", V_88F6810_PLUS)), | ||
4371 | @@ -350,7 +342,7 @@ static struct mvebu_mpp_mode armada_38x_mpp_modes[] = { | ||
4372 | MPP_VAR_FUNCTION(1, "sata0", "prsnt", V_88F6810_PLUS), | ||
4373 | MPP_VAR_FUNCTION(2, "sata1", "prsnt", V_88F6810_PLUS), | ||
4374 | MPP_VAR_FUNCTION(3, "pcie0", "rstout", V_88F6810_PLUS), | ||
4375 | - MPP_VAR_FUNCTION(4, "pcie1", "rstout", V_88F6820_PLUS), | ||
4376 | + MPP_VAR_FUNCTION(4, "ge0", "txerr", V_88F6810_PLUS), | ||
4377 | MPP_VAR_FUNCTION(5, "sd0", "d3", V_88F6810_PLUS)), | ||
4378 | MPP_MODE(55, | ||
4379 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4380 | @@ -380,7 +372,6 @@ static struct mvebu_mpp_mode armada_38x_mpp_modes[] = { | ||
4381 | MPP_VAR_FUNCTION(0, "gpio", NULL, V_88F6810_PLUS), | ||
4382 | MPP_VAR_FUNCTION(1, "pcie0", "rstout", V_88F6810_PLUS), | ||
4383 | MPP_VAR_FUNCTION(2, "i2c1", "sda", V_88F6810_PLUS), | ||
4384 | - MPP_VAR_FUNCTION(3, "pcie1", "rstout", V_88F6820_PLUS), | ||
4385 | MPP_VAR_FUNCTION(4, "spi1", "cs0", V_88F6810_PLUS), | ||
4386 | MPP_VAR_FUNCTION(5, "sd0", "d2", V_88F6810_PLUS)), | ||
4387 | }; | ||
4388 | @@ -409,7 +400,7 @@ static struct mvebu_mpp_ctrl armada_38x_mpp_controls[] = { | ||
4389 | |||
4390 | static struct pinctrl_gpio_range armada_38x_mpp_gpio_ranges[] = { | ||
4391 | MPP_GPIO_RANGE(0, 0, 0, 32), | ||
4392 | - MPP_GPIO_RANGE(1, 32, 32, 27), | ||
4393 | + MPP_GPIO_RANGE(1, 32, 32, 28), | ||
4394 | }; | ||
4395 | |||
4396 | static int armada_38x_pinctrl_probe(struct platform_device *pdev) | ||
4397 | diff --git a/drivers/pinctrl/mvebu/pinctrl-armada-xp.c b/drivers/pinctrl/mvebu/pinctrl-armada-xp.c | ||
4398 | index de311129f7a0..cb06fd293fd2 100644 | ||
4399 | --- a/drivers/pinctrl/mvebu/pinctrl-armada-xp.c | ||
4400 | +++ b/drivers/pinctrl/mvebu/pinctrl-armada-xp.c | ||
4401 | @@ -14,10 +14,7 @@ | ||
4402 | * available: mv78230, mv78260 and mv78460. From a pin muxing | ||
4403 | * perspective, the mv78230 has 49 MPP pins. The mv78260 and mv78460 | ||
4404 | * both have 67 MPP pins (more GPIOs and address lines for the memory | ||
4405 | - * bus mainly). The only difference between the mv78260 and the | ||
4406 | - * mv78460 in terms of pin muxing is the addition of two functions on | ||
4407 | - * pins 43 and 56 to access the VDD of the CPU2 and 3 (mv78260 has two | ||
4408 | - * cores, mv78460 has four cores). | ||
4409 | + * bus mainly). | ||
4410 | */ | ||
4411 | |||
4412 | #include <linux/err.h> | ||
4413 | @@ -171,20 +168,17 @@ static struct mvebu_mpp_mode armada_xp_mpp_modes[] = { | ||
4414 | MPP_MODE(24, | ||
4415 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4416 | MPP_VAR_FUNCTION(0x1, "sata1", "prsnt", V_MV78230_PLUS), | ||
4417 | - MPP_VAR_FUNCTION(0x2, "nf", "bootcs-re", V_MV78230_PLUS), | ||
4418 | MPP_VAR_FUNCTION(0x3, "tdm", "rst", V_MV78230_PLUS), | ||
4419 | MPP_VAR_FUNCTION(0x4, "lcd", "hsync", V_MV78230_PLUS)), | ||
4420 | MPP_MODE(25, | ||
4421 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4422 | MPP_VAR_FUNCTION(0x1, "sata0", "prsnt", V_MV78230_PLUS), | ||
4423 | - MPP_VAR_FUNCTION(0x2, "nf", "bootcs-we", V_MV78230_PLUS), | ||
4424 | MPP_VAR_FUNCTION(0x3, "tdm", "pclk", V_MV78230_PLUS), | ||
4425 | MPP_VAR_FUNCTION(0x4, "lcd", "vsync", V_MV78230_PLUS)), | ||
4426 | MPP_MODE(26, | ||
4427 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4428 | MPP_VAR_FUNCTION(0x3, "tdm", "fsync", V_MV78230_PLUS), | ||
4429 | - MPP_VAR_FUNCTION(0x4, "lcd", "clk", V_MV78230_PLUS), | ||
4430 | - MPP_VAR_FUNCTION(0x5, "vdd", "cpu1-pd", V_MV78230_PLUS)), | ||
4431 | + MPP_VAR_FUNCTION(0x4, "lcd", "clk", V_MV78230_PLUS)), | ||
4432 | MPP_MODE(27, | ||
4433 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4434 | MPP_VAR_FUNCTION(0x1, "ptp", "trig", V_MV78230_PLUS), | ||
4435 | @@ -199,8 +193,7 @@ static struct mvebu_mpp_mode armada_xp_mpp_modes[] = { | ||
4436 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4437 | MPP_VAR_FUNCTION(0x1, "ptp", "clk", V_MV78230_PLUS), | ||
4438 | MPP_VAR_FUNCTION(0x3, "tdm", "int0", V_MV78230_PLUS), | ||
4439 | - MPP_VAR_FUNCTION(0x4, "lcd", "ref-clk", V_MV78230_PLUS), | ||
4440 | - MPP_VAR_FUNCTION(0x5, "vdd", "cpu0-pd", V_MV78230_PLUS)), | ||
4441 | + MPP_VAR_FUNCTION(0x4, "lcd", "ref-clk", V_MV78230_PLUS)), | ||
4442 | MPP_MODE(30, | ||
4443 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4444 | MPP_VAR_FUNCTION(0x1, "sd0", "clk", V_MV78230_PLUS), | ||
4445 | @@ -208,13 +201,11 @@ static struct mvebu_mpp_mode armada_xp_mpp_modes[] = { | ||
4446 | MPP_MODE(31, | ||
4447 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4448 | MPP_VAR_FUNCTION(0x1, "sd0", "cmd", V_MV78230_PLUS), | ||
4449 | - MPP_VAR_FUNCTION(0x3, "tdm", "int2", V_MV78230_PLUS), | ||
4450 | - MPP_VAR_FUNCTION(0x5, "vdd", "cpu0-pd", V_MV78230_PLUS)), | ||
4451 | + MPP_VAR_FUNCTION(0x3, "tdm", "int2", V_MV78230_PLUS)), | ||
4452 | MPP_MODE(32, | ||
4453 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4454 | MPP_VAR_FUNCTION(0x1, "sd0", "d0", V_MV78230_PLUS), | ||
4455 | - MPP_VAR_FUNCTION(0x3, "tdm", "int3", V_MV78230_PLUS), | ||
4456 | - MPP_VAR_FUNCTION(0x5, "vdd", "cpu1-pd", V_MV78230_PLUS)), | ||
4457 | + MPP_VAR_FUNCTION(0x3, "tdm", "int3", V_MV78230_PLUS)), | ||
4458 | MPP_MODE(33, | ||
4459 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4460 | MPP_VAR_FUNCTION(0x1, "sd0", "d1", V_MV78230_PLUS), | ||
4461 | @@ -246,7 +237,6 @@ static struct mvebu_mpp_mode armada_xp_mpp_modes[] = { | ||
4462 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4463 | MPP_VAR_FUNCTION(0x1, "spi", "cs1", V_MV78230_PLUS), | ||
4464 | MPP_VAR_FUNCTION(0x2, "uart2", "cts", V_MV78230_PLUS), | ||
4465 | - MPP_VAR_FUNCTION(0x3, "vdd", "cpu1-pd", V_MV78230_PLUS), | ||
4466 | MPP_VAR_FUNCTION(0x4, "lcd", "vga-hsync", V_MV78230_PLUS), | ||
4467 | MPP_VAR_FUNCTION(0x5, "pcie", "clkreq0", V_MV78230_PLUS)), | ||
4468 | MPP_MODE(41, | ||
4469 | @@ -261,15 +251,13 @@ static struct mvebu_mpp_mode armada_xp_mpp_modes[] = { | ||
4470 | MPP_VAR_FUNCTION(0x1, "uart2", "rxd", V_MV78230_PLUS), | ||
4471 | MPP_VAR_FUNCTION(0x2, "uart0", "cts", V_MV78230_PLUS), | ||
4472 | MPP_VAR_FUNCTION(0x3, "tdm", "int7", V_MV78230_PLUS), | ||
4473 | - MPP_VAR_FUNCTION(0x4, "tdm-1", "timer", V_MV78230_PLUS), | ||
4474 | - MPP_VAR_FUNCTION(0x5, "vdd", "cpu0-pd", V_MV78230_PLUS)), | ||
4475 | + MPP_VAR_FUNCTION(0x4, "tdm-1", "timer", V_MV78230_PLUS)), | ||
4476 | MPP_MODE(43, | ||
4477 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4478 | MPP_VAR_FUNCTION(0x1, "uart2", "txd", V_MV78230_PLUS), | ||
4479 | MPP_VAR_FUNCTION(0x2, "uart0", "rts", V_MV78230_PLUS), | ||
4480 | MPP_VAR_FUNCTION(0x3, "spi", "cs3", V_MV78230_PLUS), | ||
4481 | - MPP_VAR_FUNCTION(0x4, "pcie", "rstout", V_MV78230_PLUS), | ||
4482 | - MPP_VAR_FUNCTION(0x5, "vdd", "cpu2-3-pd", V_MV78460)), | ||
4483 | + MPP_VAR_FUNCTION(0x4, "pcie", "rstout", V_MV78230_PLUS)), | ||
4484 | MPP_MODE(44, | ||
4485 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4486 | MPP_VAR_FUNCTION(0x1, "uart2", "cts", V_MV78230_PLUS), | ||
4487 | @@ -298,7 +286,7 @@ static struct mvebu_mpp_mode armada_xp_mpp_modes[] = { | ||
4488 | MPP_VAR_FUNCTION(0x5, "pcie", "clkreq3", V_MV78230_PLUS)), | ||
4489 | MPP_MODE(48, | ||
4490 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78230_PLUS), | ||
4491 | - MPP_VAR_FUNCTION(0x1, "tclk", NULL, V_MV78230_PLUS), | ||
4492 | + MPP_VAR_FUNCTION(0x1, "dev", "clkout", V_MV78230_PLUS), | ||
4493 | MPP_VAR_FUNCTION(0x2, "dev", "burst/last", V_MV78230_PLUS)), | ||
4494 | MPP_MODE(49, | ||
4495 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78260_PLUS), | ||
4496 | @@ -320,16 +308,13 @@ static struct mvebu_mpp_mode armada_xp_mpp_modes[] = { | ||
4497 | MPP_VAR_FUNCTION(0x1, "dev", "ad19", V_MV78260_PLUS)), | ||
4498 | MPP_MODE(55, | ||
4499 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78260_PLUS), | ||
4500 | - MPP_VAR_FUNCTION(0x1, "dev", "ad20", V_MV78260_PLUS), | ||
4501 | - MPP_VAR_FUNCTION(0x2, "vdd", "cpu0-pd", V_MV78260_PLUS)), | ||
4502 | + MPP_VAR_FUNCTION(0x1, "dev", "ad20", V_MV78260_PLUS)), | ||
4503 | MPP_MODE(56, | ||
4504 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78260_PLUS), | ||
4505 | - MPP_VAR_FUNCTION(0x1, "dev", "ad21", V_MV78260_PLUS), | ||
4506 | - MPP_VAR_FUNCTION(0x2, "vdd", "cpu1-pd", V_MV78260_PLUS)), | ||
4507 | + MPP_VAR_FUNCTION(0x1, "dev", "ad21", V_MV78260_PLUS)), | ||
4508 | MPP_MODE(57, | ||
4509 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78260_PLUS), | ||
4510 | - MPP_VAR_FUNCTION(0x1, "dev", "ad22", V_MV78260_PLUS), | ||
4511 | - MPP_VAR_FUNCTION(0x2, "vdd", "cpu2-3-pd", V_MV78460)), | ||
4512 | + MPP_VAR_FUNCTION(0x1, "dev", "ad22", V_MV78260_PLUS)), | ||
4513 | MPP_MODE(58, | ||
4514 | MPP_VAR_FUNCTION(0x0, "gpio", NULL, V_MV78260_PLUS), | ||
4515 | MPP_VAR_FUNCTION(0x1, "dev", "ad23", V_MV78260_PLUS)), | ||
4516 | diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c | ||
4517 | index ed494f37c40f..14ad4c28b0be 100644 | ||
4518 | --- a/drivers/platform/x86/ideapad-laptop.c | ||
4519 | +++ b/drivers/platform/x86/ideapad-laptop.c | ||
4520 | @@ -464,8 +464,9 @@ static const struct ideapad_rfk_data ideapad_rfk_data[] = { | ||
4521 | static int ideapad_rfk_set(void *data, bool blocked) | ||
4522 | { | ||
4523 | struct ideapad_rfk_priv *priv = data; | ||
4524 | + int opcode = ideapad_rfk_data[priv->dev].opcode; | ||
4525 | |||
4526 | - return write_ec_cmd(priv->priv->adev->handle, priv->dev, !blocked); | ||
4527 | + return write_ec_cmd(priv->priv->adev->handle, opcode, !blocked); | ||
4528 | } | ||
4529 | |||
4530 | static struct rfkill_ops ideapad_rfk_ops = { | ||
4531 | @@ -831,6 +832,13 @@ static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data) | ||
4532 | */ | ||
4533 | static const struct dmi_system_id no_hw_rfkill_list[] = { | ||
4534 | { | ||
4535 | + .ident = "Lenovo G50-30", | ||
4536 | + .matches = { | ||
4537 | + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), | ||
4538 | + DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo G50-30"), | ||
4539 | + }, | ||
4540 | + }, | ||
4541 | + { | ||
4542 | .ident = "Lenovo Yoga 2 11 / 13 / Pro", | ||
4543 | .matches = { | ||
4544 | DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), | ||
4545 | diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c | ||
4546 | index d92612c51657..bc3d80f9d5d6 100644 | ||
4547 | --- a/drivers/regulator/core.c | ||
4548 | +++ b/drivers/regulator/core.c | ||
4549 | @@ -774,7 +774,7 @@ static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state) | ||
4550 | static void print_constraints(struct regulator_dev *rdev) | ||
4551 | { | ||
4552 | struct regulation_constraints *constraints = rdev->constraints; | ||
4553 | - char buf[80] = ""; | ||
4554 | + char buf[160] = ""; | ||
4555 | int count = 0; | ||
4556 | int ret; | ||
4557 | |||
4558 | diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h | ||
4559 | index fa82c003bc32..ae4626f64208 100644 | ||
4560 | --- a/drivers/scsi/ipr.h | ||
4561 | +++ b/drivers/scsi/ipr.h | ||
4562 | @@ -270,7 +270,7 @@ | ||
4563 | #define IPR_RUNTIME_RESET 0x40000000 | ||
4564 | |||
4565 | #define IPR_IPL_INIT_MIN_STAGE_TIME 5 | ||
4566 | -#define IPR_IPL_INIT_DEFAULT_STAGE_TIME 15 | ||
4567 | +#define IPR_IPL_INIT_DEFAULT_STAGE_TIME 30 | ||
4568 | #define IPR_IPL_INIT_STAGE_UNKNOWN 0x0 | ||
4569 | #define IPR_IPL_INIT_STAGE_TRANSOP 0xB0000000 | ||
4570 | #define IPR_IPL_INIT_STAGE_MASK 0xff000000 | ||
4571 | diff --git a/drivers/scsi/scsi_transport_srp.c b/drivers/scsi/scsi_transport_srp.c | ||
4572 | index ae45bd99baed..e05cd7e2d6d3 100644 | ||
4573 | --- a/drivers/scsi/scsi_transport_srp.c | ||
4574 | +++ b/drivers/scsi/scsi_transport_srp.c | ||
4575 | @@ -396,6 +396,36 @@ static void srp_reconnect_work(struct work_struct *work) | ||
4576 | } | ||
4577 | } | ||
4578 | |||
4579 | +/** | ||
4580 | + * scsi_request_fn_active() - number of kernel threads inside scsi_request_fn() | ||
4581 | + * @shost: SCSI host for which to count the number of scsi_request_fn() callers. | ||
4582 | + * | ||
4583 | + * To do: add support for scsi-mq in this function. | ||
4584 | + */ | ||
4585 | +static int scsi_request_fn_active(struct Scsi_Host *shost) | ||
4586 | +{ | ||
4587 | + struct scsi_device *sdev; | ||
4588 | + struct request_queue *q; | ||
4589 | + int request_fn_active = 0; | ||
4590 | + | ||
4591 | + shost_for_each_device(sdev, shost) { | ||
4592 | + q = sdev->request_queue; | ||
4593 | + | ||
4594 | + spin_lock_irq(q->queue_lock); | ||
4595 | + request_fn_active += q->request_fn_active; | ||
4596 | + spin_unlock_irq(q->queue_lock); | ||
4597 | + } | ||
4598 | + | ||
4599 | + return request_fn_active; | ||
4600 | +} | ||
4601 | + | ||
4602 | +/* Wait until ongoing shost->hostt->queuecommand() calls have finished. */ | ||
4603 | +static void srp_wait_for_queuecommand(struct Scsi_Host *shost) | ||
4604 | +{ | ||
4605 | + while (scsi_request_fn_active(shost)) | ||
4606 | + msleep(20); | ||
4607 | +} | ||
4608 | + | ||
4609 | static void __rport_fail_io_fast(struct srp_rport *rport) | ||
4610 | { | ||
4611 | struct Scsi_Host *shost = rport_to_shost(rport); | ||
4612 | @@ -504,27 +534,6 @@ void srp_start_tl_fail_timers(struct srp_rport *rport) | ||
4613 | EXPORT_SYMBOL(srp_start_tl_fail_timers); | ||
4614 | |||
4615 | /** | ||
4616 | - * scsi_request_fn_active() - number of kernel threads inside scsi_request_fn() | ||
4617 | - * @shost: SCSI host for which to count the number of scsi_request_fn() callers. | ||
4618 | - */ | ||
4619 | -static int scsi_request_fn_active(struct Scsi_Host *shost) | ||
4620 | -{ | ||
4621 | - struct scsi_device *sdev; | ||
4622 | - struct request_queue *q; | ||
4623 | - int request_fn_active = 0; | ||
4624 | - | ||
4625 | - shost_for_each_device(sdev, shost) { | ||
4626 | - q = sdev->request_queue; | ||
4627 | - | ||
4628 | - spin_lock_irq(q->queue_lock); | ||
4629 | - request_fn_active += q->request_fn_active; | ||
4630 | - spin_unlock_irq(q->queue_lock); | ||
4631 | - } | ||
4632 | - | ||
4633 | - return request_fn_active; | ||
4634 | -} | ||
4635 | - | ||
4636 | -/** | ||
4637 | * srp_reconnect_rport() - reconnect to an SRP target port | ||
4638 | * @rport: SRP target port. | ||
4639 | * | ||
4640 | @@ -559,8 +568,7 @@ int srp_reconnect_rport(struct srp_rport *rport) | ||
4641 | if (res) | ||
4642 | goto out; | ||
4643 | scsi_target_block(&shost->shost_gendev); | ||
4644 | - while (scsi_request_fn_active(shost)) | ||
4645 | - msleep(20); | ||
4646 | + srp_wait_for_queuecommand(shost); | ||
4647 | res = rport->state != SRP_RPORT_LOST ? i->f->reconnect(rport) : -ENODEV; | ||
4648 | pr_debug("%s (state %d): transport.reconnect() returned %d\n", | ||
4649 | dev_name(&shost->shost_gendev), rport->state, res); | ||
4650 | diff --git a/drivers/spi/spi-orion.c b/drivers/spi/spi-orion.c | ||
4651 | index c76b7d7879df..bd09807b6b05 100644 | ||
4652 | --- a/drivers/spi/spi-orion.c | ||
4653 | +++ b/drivers/spi/spi-orion.c | ||
4654 | @@ -52,6 +52,12 @@ enum orion_spi_type { | ||
4655 | |||
4656 | struct orion_spi_dev { | ||
4657 | enum orion_spi_type typ; | ||
4658 | + /* | ||
4659 | + * min_divisor and max_hz should be exclusive, the only we can | ||
4660 | + * have both is for managing the armada-370-spi case with old | ||
4661 | + * device tree | ||
4662 | + */ | ||
4663 | + unsigned long max_hz; | ||
4664 | unsigned int min_divisor; | ||
4665 | unsigned int max_divisor; | ||
4666 | u32 prescale_mask; | ||
4667 | @@ -402,8 +408,9 @@ static const struct orion_spi_dev orion_spi_dev_data = { | ||
4668 | |||
4669 | static const struct orion_spi_dev armada_spi_dev_data = { | ||
4670 | .typ = ARMADA_SPI, | ||
4671 | - .min_divisor = 1, | ||
4672 | + .min_divisor = 4, | ||
4673 | .max_divisor = 1920, | ||
4674 | + .max_hz = 50000000, | ||
4675 | .prescale_mask = ARMADA_SPI_CLK_PRESCALE_MASK, | ||
4676 | }; | ||
4677 | |||
4678 | @@ -468,7 +475,21 @@ static int orion_spi_probe(struct platform_device *pdev) | ||
4679 | goto out; | ||
4680 | |||
4681 | tclk_hz = clk_get_rate(spi->clk); | ||
4682 | - master->max_speed_hz = DIV_ROUND_UP(tclk_hz, devdata->min_divisor); | ||
4683 | + | ||
4684 | + /* | ||
4685 | + * With old device tree, armada-370-spi could be used with | ||
4686 | + * Armada XP, however for this SoC the maximum frequency is | ||
4687 | + * 50MHz instead of tclk/4. On Armada 370, tclk cannot be | ||
4688 | + * higher than 200MHz. So, in order to be able to handle both | ||
4689 | + * SoCs, we can take the minimum of 50MHz and tclk/4. | ||
4690 | + */ | ||
4691 | + if (of_device_is_compatible(pdev->dev.of_node, | ||
4692 | + "marvell,armada-370-spi")) | ||
4693 | + master->max_speed_hz = min(devdata->max_hz, | ||
4694 | + DIV_ROUND_UP(tclk_hz, devdata->min_divisor)); | ||
4695 | + else | ||
4696 | + master->max_speed_hz = | ||
4697 | + DIV_ROUND_UP(tclk_hz, devdata->min_divisor); | ||
4698 | master->min_speed_hz = DIV_ROUND_UP(tclk_hz, devdata->max_divisor); | ||
4699 | |||
4700 | r = platform_get_resource(pdev, IORESOURCE_MEM, 0); | ||
4701 | diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c | ||
4702 | index 1c72be19e70e..115ad5dbc7c5 100644 | ||
4703 | --- a/drivers/spi/spi.c | ||
4704 | +++ b/drivers/spi/spi.c | ||
4705 | @@ -1059,9 +1059,6 @@ void spi_finalize_current_message(struct spi_master *master) | ||
4706 | |||
4707 | spin_lock_irqsave(&master->queue_lock, flags); | ||
4708 | mesg = master->cur_msg; | ||
4709 | - master->cur_msg = NULL; | ||
4710 | - | ||
4711 | - queue_kthread_work(&master->kworker, &master->pump_messages); | ||
4712 | spin_unlock_irqrestore(&master->queue_lock, flags); | ||
4713 | |||
4714 | spi_unmap_msg(master, mesg); | ||
4715 | @@ -1074,9 +1071,13 @@ void spi_finalize_current_message(struct spi_master *master) | ||
4716 | } | ||
4717 | } | ||
4718 | |||
4719 | - trace_spi_message_done(mesg); | ||
4720 | - | ||
4721 | + spin_lock_irqsave(&master->queue_lock, flags); | ||
4722 | + master->cur_msg = NULL; | ||
4723 | master->cur_msg_prepared = false; | ||
4724 | + queue_kthread_work(&master->kworker, &master->pump_messages); | ||
4725 | + spin_unlock_irqrestore(&master->queue_lock, flags); | ||
4726 | + | ||
4727 | + trace_spi_message_done(mesg); | ||
4728 | |||
4729 | mesg->state = NULL; | ||
4730 | if (mesg->complete) | ||
4731 | diff --git a/drivers/staging/ozwpan/ozusbsvc1.c b/drivers/staging/ozwpan/ozusbsvc1.c | ||
4732 | index be7ee01c50ab..0c6bea0b311c 100644 | ||
4733 | --- a/drivers/staging/ozwpan/ozusbsvc1.c | ||
4734 | +++ b/drivers/staging/ozwpan/ozusbsvc1.c | ||
4735 | @@ -326,7 +326,11 @@ static void oz_usb_handle_ep_data(struct oz_usb_ctx *usb_ctx, | ||
4736 | struct oz_multiple_fixed *body = | ||
4737 | (struct oz_multiple_fixed *)data_hdr; | ||
4738 | u8 *data = body->data; | ||
4739 | - int n = (len - sizeof(struct oz_multiple_fixed)+1) | ||
4740 | + unsigned int n; | ||
4741 | + if (!body->unit_size || | ||
4742 | + len < sizeof(struct oz_multiple_fixed) - 1) | ||
4743 | + break; | ||
4744 | + n = (len - (sizeof(struct oz_multiple_fixed) - 1)) | ||
4745 | / body->unit_size; | ||
4746 | while (n--) { | ||
4747 | oz_hcd_data_ind(usb_ctx->hport, body->endpoint, | ||
4748 | @@ -390,10 +394,15 @@ void oz_usb_rx(struct oz_pd *pd, struct oz_elt *elt) | ||
4749 | case OZ_GET_DESC_RSP: { | ||
4750 | struct oz_get_desc_rsp *body = | ||
4751 | (struct oz_get_desc_rsp *)usb_hdr; | ||
4752 | - int data_len = elt->length - | ||
4753 | - sizeof(struct oz_get_desc_rsp) + 1; | ||
4754 | - u16 offs = le16_to_cpu(get_unaligned(&body->offset)); | ||
4755 | - u16 total_size = | ||
4756 | + u16 offs, total_size; | ||
4757 | + u8 data_len; | ||
4758 | + | ||
4759 | + if (elt->length < sizeof(struct oz_get_desc_rsp) - 1) | ||
4760 | + break; | ||
4761 | + data_len = elt->length - | ||
4762 | + (sizeof(struct oz_get_desc_rsp) - 1); | ||
4763 | + offs = le16_to_cpu(get_unaligned(&body->offset)); | ||
4764 | + total_size = | ||
4765 | le16_to_cpu(get_unaligned(&body->total_size)); | ||
4766 | oz_dbg(ON, "USB_REQ_GET_DESCRIPTOR - cnf\n"); | ||
4767 | oz_hcd_get_desc_cnf(usb_ctx->hport, body->req_id, | ||
4768 | diff --git a/drivers/staging/rtl8712/rtl8712_recv.c b/drivers/staging/rtl8712/rtl8712_recv.c | ||
4769 | index b27806209268..ff7583d97bf5 100644 | ||
4770 | --- a/drivers/staging/rtl8712/rtl8712_recv.c | ||
4771 | +++ b/drivers/staging/rtl8712/rtl8712_recv.c | ||
4772 | @@ -1068,7 +1068,8 @@ static int recvbuf2recvframe(struct _adapter *padapter, struct sk_buff *pskb) | ||
4773 | /* for first fragment packet, driver need allocate 1536 + | ||
4774 | * drvinfo_sz + RXDESC_SIZE to defrag packet. */ | ||
4775 | if ((mf == 1) && (frag == 0)) | ||
4776 | - alloc_sz = 1658;/*1658+6=1664, 1664 is 128 alignment.*/ | ||
4777 | + /*1658+6=1664, 1664 is 128 alignment.*/ | ||
4778 | + alloc_sz = max_t(u16, tmp_len, 1658); | ||
4779 | else | ||
4780 | alloc_sz = tmp_len; | ||
4781 | /* 2 is for IP header 4 bytes alignment in QoS packet case. | ||
4782 | diff --git a/drivers/staging/vt6655/device_main.c b/drivers/staging/vt6655/device_main.c | ||
4783 | index 54e16f40d8ed..ea240512cbbb 100644 | ||
4784 | --- a/drivers/staging/vt6655/device_main.c | ||
4785 | +++ b/drivers/staging/vt6655/device_main.c | ||
4786 | @@ -1340,6 +1340,10 @@ static int device_rx_srv(struct vnt_private *pDevice, unsigned int uIdx) | ||
4787 | pRD = pRD->next) { | ||
4788 | if (works++ > 15) | ||
4789 | break; | ||
4790 | + | ||
4791 | + if (!pRD->pRDInfo->skb) | ||
4792 | + break; | ||
4793 | + | ||
4794 | if (device_receive_frame(pDevice, pRD)) { | ||
4795 | if (!device_alloc_rx_buf(pDevice, pRD)) { | ||
4796 | dev_err(&pDevice->pcid->dev, | ||
4797 | diff --git a/drivers/tty/n_tty.c b/drivers/tty/n_tty.c | ||
4798 | index 72824659f628..e3ebb674a693 100644 | ||
4799 | --- a/drivers/tty/n_tty.c | ||
4800 | +++ b/drivers/tty/n_tty.c | ||
4801 | @@ -186,6 +186,17 @@ static int receive_room(struct tty_struct *tty) | ||
4802 | return left; | ||
4803 | } | ||
4804 | |||
4805 | +static inline int tty_copy_to_user(struct tty_struct *tty, | ||
4806 | + void __user *to, | ||
4807 | + const void *from, | ||
4808 | + unsigned long n) | ||
4809 | +{ | ||
4810 | + struct n_tty_data *ldata = tty->disc_data; | ||
4811 | + | ||
4812 | + tty_audit_add_data(tty, to, n, ldata->icanon); | ||
4813 | + return copy_to_user(to, from, n); | ||
4814 | +} | ||
4815 | + | ||
4816 | /** | ||
4817 | * n_tty_set_room - receive space | ||
4818 | * @tty: terminal | ||
4819 | @@ -2081,12 +2092,12 @@ static int canon_copy_from_read_buf(struct tty_struct *tty, | ||
4820 | __func__, eol, found, n, c, size, more); | ||
4821 | |||
4822 | if (n > size) { | ||
4823 | - ret = copy_to_user(*b, read_buf_addr(ldata, tail), size); | ||
4824 | + ret = tty_copy_to_user(tty, *b, read_buf_addr(ldata, tail), size); | ||
4825 | if (ret) | ||
4826 | return -EFAULT; | ||
4827 | - ret = copy_to_user(*b + size, ldata->read_buf, n - size); | ||
4828 | + ret = tty_copy_to_user(tty, *b + size, ldata->read_buf, n - size); | ||
4829 | } else | ||
4830 | - ret = copy_to_user(*b, read_buf_addr(ldata, tail), n); | ||
4831 | + ret = tty_copy_to_user(tty, *b, read_buf_addr(ldata, tail), n); | ||
4832 | |||
4833 | if (ret) | ||
4834 | return -EFAULT; | ||
4835 | diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c | ||
4836 | index 369e18d9ab48..696d4b5af293 100644 | ||
4837 | --- a/drivers/tty/serial/imx.c | ||
4838 | +++ b/drivers/tty/serial/imx.c | ||
4839 | @@ -900,6 +900,14 @@ static void dma_rx_callback(void *data) | ||
4840 | |||
4841 | status = dmaengine_tx_status(chan, (dma_cookie_t)0, &state); | ||
4842 | count = RX_BUF_SIZE - state.residue; | ||
4843 | + | ||
4844 | + if (readl(sport->port.membase + USR2) & USR2_IDLE) { | ||
4845 | + /* In condition [3] the SDMA counted up too early */ | ||
4846 | + count--; | ||
4847 | + | ||
4848 | + writel(USR2_IDLE, sport->port.membase + USR2); | ||
4849 | + } | ||
4850 | + | ||
4851 | dev_dbg(sport->port.dev, "We get %d bytes.\n", count); | ||
4852 | |||
4853 | if (count) { | ||
4854 | diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c | ||
4855 | index 12d37aedc66f..7d8c3d4ede20 100644 | ||
4856 | --- a/drivers/usb/class/cdc-acm.c | ||
4857 | +++ b/drivers/usb/class/cdc-acm.c | ||
4858 | @@ -1486,6 +1486,11 @@ skip_countries: | ||
4859 | goto alloc_fail8; | ||
4860 | } | ||
4861 | |||
4862 | + if (quirks & CLEAR_HALT_CONDITIONS) { | ||
4863 | + usb_clear_halt(usb_dev, usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress)); | ||
4864 | + usb_clear_halt(usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress)); | ||
4865 | + } | ||
4866 | + | ||
4867 | return 0; | ||
4868 | alloc_fail8: | ||
4869 | if (acm->country_codes) { | ||
4870 | @@ -1763,6 +1768,10 @@ static const struct usb_device_id acm_ids[] = { | ||
4871 | .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */ | ||
4872 | }, | ||
4873 | |||
4874 | + { USB_DEVICE(0x2912, 0x0001), /* ATOL FPrint */ | ||
4875 | + .driver_info = CLEAR_HALT_CONDITIONS, | ||
4876 | + }, | ||
4877 | + | ||
4878 | /* Nokia S60 phones expose two ACM channels. The first is | ||
4879 | * a modem and is picked up by the standard AT-command | ||
4880 | * information below. The second is 'vendor-specific' but | ||
4881 | diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h | ||
4882 | index d3251ebd09e2..9cca2e7280bb 100644 | ||
4883 | --- a/drivers/usb/class/cdc-acm.h | ||
4884 | +++ b/drivers/usb/class/cdc-acm.h | ||
4885 | @@ -134,3 +134,4 @@ struct acm { | ||
4886 | #define NO_DATA_INTERFACE BIT(4) | ||
4887 | #define IGNORE_DEVICE BIT(5) | ||
4888 | #define QUIRK_CONTROL_LINE_STATE BIT(6) | ||
4889 | +#define CLEAR_HALT_CONDITIONS BIT(7) | ||
4890 | diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c | ||
4891 | index 85e03cb0c418..2222899c4b69 100644 | ||
4892 | --- a/drivers/usb/core/hub.c | ||
4893 | +++ b/drivers/usb/core/hub.c | ||
4894 | @@ -2613,9 +2613,6 @@ static bool use_new_scheme(struct usb_device *udev, int retry) | ||
4895 | return USE_NEW_SCHEME(retry); | ||
4896 | } | ||
4897 | |||
4898 | -static int hub_port_reset(struct usb_hub *hub, int port1, | ||
4899 | - struct usb_device *udev, unsigned int delay, bool warm); | ||
4900 | - | ||
4901 | /* Is a USB 3.0 port in the Inactive or Compliance Mode state? | ||
4902 | * Port worm reset is required to recover | ||
4903 | */ | ||
4904 | @@ -2703,44 +2700,6 @@ static int hub_port_wait_reset(struct usb_hub *hub, int port1, | ||
4905 | return 0; | ||
4906 | } | ||
4907 | |||
4908 | -static void hub_port_finish_reset(struct usb_hub *hub, int port1, | ||
4909 | - struct usb_device *udev, int *status) | ||
4910 | -{ | ||
4911 | - switch (*status) { | ||
4912 | - case 0: | ||
4913 | - /* TRSTRCY = 10 ms; plus some extra */ | ||
4914 | - msleep(10 + 40); | ||
4915 | - if (udev) { | ||
4916 | - struct usb_hcd *hcd = bus_to_hcd(udev->bus); | ||
4917 | - | ||
4918 | - update_devnum(udev, 0); | ||
4919 | - /* The xHC may think the device is already reset, | ||
4920 | - * so ignore the status. | ||
4921 | - */ | ||
4922 | - if (hcd->driver->reset_device) | ||
4923 | - hcd->driver->reset_device(hcd, udev); | ||
4924 | - } | ||
4925 | - /* FALL THROUGH */ | ||
4926 | - case -ENOTCONN: | ||
4927 | - case -ENODEV: | ||
4928 | - usb_clear_port_feature(hub->hdev, | ||
4929 | - port1, USB_PORT_FEAT_C_RESET); | ||
4930 | - if (hub_is_superspeed(hub->hdev)) { | ||
4931 | - usb_clear_port_feature(hub->hdev, port1, | ||
4932 | - USB_PORT_FEAT_C_BH_PORT_RESET); | ||
4933 | - usb_clear_port_feature(hub->hdev, port1, | ||
4934 | - USB_PORT_FEAT_C_PORT_LINK_STATE); | ||
4935 | - usb_clear_port_feature(hub->hdev, port1, | ||
4936 | - USB_PORT_FEAT_C_CONNECTION); | ||
4937 | - } | ||
4938 | - if (udev) | ||
4939 | - usb_set_device_state(udev, *status | ||
4940 | - ? USB_STATE_NOTATTACHED | ||
4941 | - : USB_STATE_DEFAULT); | ||
4942 | - break; | ||
4943 | - } | ||
4944 | -} | ||
4945 | - | ||
4946 | /* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */ | ||
4947 | static int hub_port_reset(struct usb_hub *hub, int port1, | ||
4948 | struct usb_device *udev, unsigned int delay, bool warm) | ||
4949 | @@ -2764,13 +2723,10 @@ static int hub_port_reset(struct usb_hub *hub, int port1, | ||
4950 | * If the caller hasn't explicitly requested a warm reset, | ||
4951 | * double check and see if one is needed. | ||
4952 | */ | ||
4953 | - status = hub_port_status(hub, port1, | ||
4954 | - &portstatus, &portchange); | ||
4955 | - if (status < 0) | ||
4956 | - goto done; | ||
4957 | - | ||
4958 | - if (hub_port_warm_reset_required(hub, port1, portstatus)) | ||
4959 | - warm = true; | ||
4960 | + if (hub_port_status(hub, port1, &portstatus, &portchange) == 0) | ||
4961 | + if (hub_port_warm_reset_required(hub, port1, | ||
4962 | + portstatus)) | ||
4963 | + warm = true; | ||
4964 | } | ||
4965 | clear_bit(port1, hub->warm_reset_bits); | ||
4966 | |||
4967 | @@ -2796,11 +2752,19 @@ static int hub_port_reset(struct usb_hub *hub, int port1, | ||
4968 | |||
4969 | /* Check for disconnect or reset */ | ||
4970 | if (status == 0 || status == -ENOTCONN || status == -ENODEV) { | ||
4971 | - hub_port_finish_reset(hub, port1, udev, &status); | ||
4972 | + usb_clear_port_feature(hub->hdev, port1, | ||
4973 | + USB_PORT_FEAT_C_RESET); | ||
4974 | |||
4975 | if (!hub_is_superspeed(hub->hdev)) | ||
4976 | goto done; | ||
4977 | |||
4978 | + usb_clear_port_feature(hub->hdev, port1, | ||
4979 | + USB_PORT_FEAT_C_BH_PORT_RESET); | ||
4980 | + usb_clear_port_feature(hub->hdev, port1, | ||
4981 | + USB_PORT_FEAT_C_PORT_LINK_STATE); | ||
4982 | + usb_clear_port_feature(hub->hdev, port1, | ||
4983 | + USB_PORT_FEAT_C_CONNECTION); | ||
4984 | + | ||
4985 | /* | ||
4986 | * If a USB 3.0 device migrates from reset to an error | ||
4987 | * state, re-issue the warm reset. | ||
4988 | @@ -2833,6 +2797,26 @@ static int hub_port_reset(struct usb_hub *hub, int port1, | ||
4989 | dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n"); | ||
4990 | |||
4991 | done: | ||
4992 | + if (status == 0) { | ||
4993 | + /* TRSTRCY = 10 ms; plus some extra */ | ||
4994 | + msleep(10 + 40); | ||
4995 | + if (udev) { | ||
4996 | + struct usb_hcd *hcd = bus_to_hcd(udev->bus); | ||
4997 | + | ||
4998 | + update_devnum(udev, 0); | ||
4999 | + /* The xHC may think the device is already reset, | ||
5000 | + * so ignore the status. | ||
5001 | + */ | ||
5002 | + if (hcd->driver->reset_device) | ||
5003 | + hcd->driver->reset_device(hcd, udev); | ||
5004 | + | ||
5005 | + usb_set_device_state(udev, USB_STATE_DEFAULT); | ||
5006 | + } | ||
5007 | + } else { | ||
5008 | + if (udev) | ||
5009 | + usb_set_device_state(udev, USB_STATE_NOTATTACHED); | ||
5010 | + } | ||
5011 | + | ||
5012 | if (!hub_is_superspeed(hub->hdev)) | ||
5013 | up_read(&ehci_cf_port_reset_rwsem); | ||
5014 | |||
5015 | diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c | ||
5016 | index 272e0928736e..d98faf73d6b2 100644 | ||
5017 | --- a/drivers/usb/dwc3/gadget.c | ||
5018 | +++ b/drivers/usb/dwc3/gadget.c | ||
5019 | @@ -289,6 +289,8 @@ int dwc3_send_gadget_generic_command(struct dwc3 *dwc, unsigned cmd, u32 param) | ||
5020 | if (!(reg & DWC3_DGCMD_CMDACT)) { | ||
5021 | dev_vdbg(dwc->dev, "Command Complete --> %d\n", | ||
5022 | DWC3_DGCMD_STATUS(reg)); | ||
5023 | + if (DWC3_DGCMD_STATUS(reg)) | ||
5024 | + return -EINVAL; | ||
5025 | return 0; | ||
5026 | } | ||
5027 | |||
5028 | @@ -322,6 +324,8 @@ int dwc3_send_gadget_ep_cmd(struct dwc3 *dwc, unsigned ep, | ||
5029 | if (!(reg & DWC3_DEPCMD_CMDACT)) { | ||
5030 | dev_vdbg(dwc->dev, "Command Complete --> %d\n", | ||
5031 | DWC3_DEPCMD_STATUS(reg)); | ||
5032 | + if (DWC3_DEPCMD_STATUS(reg)) | ||
5033 | + return -EINVAL; | ||
5034 | return 0; | ||
5035 | } | ||
5036 | |||
5037 | @@ -1899,12 +1903,16 @@ static void dwc3_endpoint_transfer_complete(struct dwc3 *dwc, | ||
5038 | { | ||
5039 | unsigned status = 0; | ||
5040 | int clean_busy; | ||
5041 | + u32 is_xfer_complete; | ||
5042 | + | ||
5043 | + is_xfer_complete = (event->endpoint_event == DWC3_DEPEVT_XFERCOMPLETE); | ||
5044 | |||
5045 | if (event->status & DEPEVT_STATUS_BUSERR) | ||
5046 | status = -ECONNRESET; | ||
5047 | |||
5048 | clean_busy = dwc3_cleanup_done_reqs(dwc, dep, event, status); | ||
5049 | - if (clean_busy) | ||
5050 | + if (clean_busy && (is_xfer_complete || | ||
5051 | + usb_endpoint_xfer_isoc(dep->endpoint.desc))) | ||
5052 | dep->flags &= ~DWC3_EP_BUSY; | ||
5053 | |||
5054 | /* | ||
5055 | diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c | ||
5056 | index 9031750e7404..ffd739e31bfc 100644 | ||
5057 | --- a/drivers/usb/serial/cp210x.c | ||
5058 | +++ b/drivers/usb/serial/cp210x.c | ||
5059 | @@ -128,6 +128,7 @@ static const struct usb_device_id id_table[] = { | ||
5060 | { USB_DEVICE(0x10C4, 0x8946) }, /* Ketra N1 Wireless Interface */ | ||
5061 | { USB_DEVICE(0x10C4, 0x8977) }, /* CEL MeshWorks DevKit Device */ | ||
5062 | { USB_DEVICE(0x10C4, 0x8998) }, /* KCF Technologies PRN */ | ||
5063 | + { USB_DEVICE(0x10C4, 0x8A2A) }, /* HubZ dual ZigBee and Z-Wave dongle */ | ||
5064 | { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */ | ||
5065 | { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */ | ||
5066 | { USB_DEVICE(0x10C4, 0xEA70) }, /* Silicon Labs factory default */ | ||
5067 | diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c | ||
5068 | index 8eb68a31cab6..4c8b3b82103d 100644 | ||
5069 | --- a/drivers/usb/serial/ftdi_sio.c | ||
5070 | +++ b/drivers/usb/serial/ftdi_sio.c | ||
5071 | @@ -699,6 +699,7 @@ static const struct usb_device_id id_table_combined[] = { | ||
5072 | { USB_DEVICE(XSENS_VID, XSENS_AWINDA_DONGLE_PID) }, | ||
5073 | { USB_DEVICE(XSENS_VID, XSENS_AWINDA_STATION_PID) }, | ||
5074 | { USB_DEVICE(XSENS_VID, XSENS_CONVERTER_PID) }, | ||
5075 | + { USB_DEVICE(XSENS_VID, XSENS_MTDEVBOARD_PID) }, | ||
5076 | { USB_DEVICE(XSENS_VID, XSENS_MTW_PID) }, | ||
5077 | { USB_DEVICE(FTDI_VID, FTDI_OMNI1509) }, | ||
5078 | { USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) }, | ||
5079 | diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h | ||
5080 | index 4e4f46f3c89c..792e054126de 100644 | ||
5081 | --- a/drivers/usb/serial/ftdi_sio_ids.h | ||
5082 | +++ b/drivers/usb/serial/ftdi_sio_ids.h | ||
5083 | @@ -155,6 +155,7 @@ | ||
5084 | #define XSENS_AWINDA_STATION_PID 0x0101 | ||
5085 | #define XSENS_AWINDA_DONGLE_PID 0x0102 | ||
5086 | #define XSENS_MTW_PID 0x0200 /* Xsens MTw */ | ||
5087 | +#define XSENS_MTDEVBOARD_PID 0x0300 /* Motion Tracker Development Board */ | ||
5088 | #define XSENS_CONVERTER_PID 0xD00D /* Xsens USB-serial converter */ | ||
5089 | |||
5090 | /* Xsens devices using FTDI VID */ | ||
5091 | diff --git a/drivers/w1/slaves/w1_therm.c b/drivers/w1/slaves/w1_therm.c | ||
5092 | index 1f11a20a8ab9..55eb86c9e214 100644 | ||
5093 | --- a/drivers/w1/slaves/w1_therm.c | ||
5094 | +++ b/drivers/w1/slaves/w1_therm.c | ||
5095 | @@ -59,16 +59,32 @@ MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00)); | ||
5096 | static int w1_strong_pullup = 1; | ||
5097 | module_param_named(strong_pullup, w1_strong_pullup, int, 0); | ||
5098 | |||
5099 | +struct w1_therm_family_data { | ||
5100 | + uint8_t rom[9]; | ||
5101 | + atomic_t refcnt; | ||
5102 | +}; | ||
5103 | + | ||
5104 | +/* return the address of the refcnt in the family data */ | ||
5105 | +#define THERM_REFCNT(family_data) \ | ||
5106 | + (&((struct w1_therm_family_data*)family_data)->refcnt) | ||
5107 | + | ||
5108 | static int w1_therm_add_slave(struct w1_slave *sl) | ||
5109 | { | ||
5110 | - sl->family_data = kzalloc(9, GFP_KERNEL); | ||
5111 | + sl->family_data = kzalloc(sizeof(struct w1_therm_family_data), | ||
5112 | + GFP_KERNEL); | ||
5113 | if (!sl->family_data) | ||
5114 | return -ENOMEM; | ||
5115 | + atomic_set(THERM_REFCNT(sl->family_data), 1); | ||
5116 | return 0; | ||
5117 | } | ||
5118 | |||
5119 | static void w1_therm_remove_slave(struct w1_slave *sl) | ||
5120 | { | ||
5121 | + int refcnt = atomic_sub_return(1, THERM_REFCNT(sl->family_data)); | ||
5122 | + while(refcnt) { | ||
5123 | + msleep(1000); | ||
5124 | + refcnt = atomic_read(THERM_REFCNT(sl->family_data)); | ||
5125 | + } | ||
5126 | kfree(sl->family_data); | ||
5127 | sl->family_data = NULL; | ||
5128 | } | ||
5129 | @@ -194,13 +210,22 @@ static ssize_t w1_slave_show(struct device *device, | ||
5130 | struct w1_slave *sl = dev_to_w1_slave(device); | ||
5131 | struct w1_master *dev = sl->master; | ||
5132 | u8 rom[9], crc, verdict, external_power; | ||
5133 | - int i, max_trying = 10; | ||
5134 | + int i, ret, max_trying = 10; | ||
5135 | ssize_t c = PAGE_SIZE; | ||
5136 | + u8 *family_data = sl->family_data; | ||
5137 | + | ||
5138 | + ret = mutex_lock_interruptible(&dev->bus_mutex); | ||
5139 | + if (ret != 0) | ||
5140 | + goto post_unlock; | ||
5141 | |||
5142 | - i = mutex_lock_interruptible(&dev->bus_mutex); | ||
5143 | - if (i != 0) | ||
5144 | - return i; | ||
5145 | + if(!sl->family_data) | ||
5146 | + { | ||
5147 | + ret = -ENODEV; | ||
5148 | + goto pre_unlock; | ||
5149 | + } | ||
5150 | |||
5151 | + /* prevent the slave from going away in sleep */ | ||
5152 | + atomic_inc(THERM_REFCNT(family_data)); | ||
5153 | memset(rom, 0, sizeof(rom)); | ||
5154 | |||
5155 | while (max_trying--) { | ||
5156 | @@ -230,17 +255,19 @@ static ssize_t w1_slave_show(struct device *device, | ||
5157 | mutex_unlock(&dev->bus_mutex); | ||
5158 | |||
5159 | sleep_rem = msleep_interruptible(tm); | ||
5160 | - if (sleep_rem != 0) | ||
5161 | - return -EINTR; | ||
5162 | + if (sleep_rem != 0) { | ||
5163 | + ret = -EINTR; | ||
5164 | + goto post_unlock; | ||
5165 | + } | ||
5166 | |||
5167 | - i = mutex_lock_interruptible(&dev->bus_mutex); | ||
5168 | - if (i != 0) | ||
5169 | - return i; | ||
5170 | + ret = mutex_lock_interruptible(&dev->bus_mutex); | ||
5171 | + if (ret != 0) | ||
5172 | + goto post_unlock; | ||
5173 | } else if (!w1_strong_pullup) { | ||
5174 | sleep_rem = msleep_interruptible(tm); | ||
5175 | if (sleep_rem != 0) { | ||
5176 | - mutex_unlock(&dev->bus_mutex); | ||
5177 | - return -EINTR; | ||
5178 | + ret = -EINTR; | ||
5179 | + goto pre_unlock; | ||
5180 | } | ||
5181 | } | ||
5182 | |||
5183 | @@ -269,19 +296,24 @@ static ssize_t w1_slave_show(struct device *device, | ||
5184 | c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n", | ||
5185 | crc, (verdict) ? "YES" : "NO"); | ||
5186 | if (verdict) | ||
5187 | - memcpy(sl->family_data, rom, sizeof(rom)); | ||
5188 | + memcpy(family_data, rom, sizeof(rom)); | ||
5189 | else | ||
5190 | dev_warn(device, "Read failed CRC check\n"); | ||
5191 | |||
5192 | for (i = 0; i < 9; ++i) | ||
5193 | c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", | ||
5194 | - ((u8 *)sl->family_data)[i]); | ||
5195 | + ((u8 *)family_data)[i]); | ||
5196 | |||
5197 | c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n", | ||
5198 | w1_convert_temp(rom, sl->family->fid)); | ||
5199 | + ret = PAGE_SIZE - c; | ||
5200 | + | ||
5201 | +pre_unlock: | ||
5202 | mutex_unlock(&dev->bus_mutex); | ||
5203 | |||
5204 | - return PAGE_SIZE - c; | ||
5205 | +post_unlock: | ||
5206 | + atomic_dec(THERM_REFCNT(family_data)); | ||
5207 | + return ret; | ||
5208 | } | ||
5209 | |||
5210 | static int __init w1_therm_init(void) | ||
5211 | diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c | ||
5212 | index fce3b5b9a2bb..1cecf25fa14f 100644 | ||
5213 | --- a/fs/btrfs/ioctl.c | ||
5214 | +++ b/fs/btrfs/ioctl.c | ||
5215 | @@ -2434,8 +2434,6 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file, | ||
5216 | goto out_unlock_inode; | ||
5217 | } | ||
5218 | |||
5219 | - d_invalidate(dentry); | ||
5220 | - | ||
5221 | down_write(&root->fs_info->subvol_sem); | ||
5222 | |||
5223 | err = may_destroy_subvol(dest); | ||
5224 | @@ -2529,7 +2527,7 @@ out_up_write: | ||
5225 | out_unlock_inode: | ||
5226 | mutex_unlock(&inode->i_mutex); | ||
5227 | if (!err) { | ||
5228 | - shrink_dcache_sb(root->fs_info->sb); | ||
5229 | + d_invalidate(dentry); | ||
5230 | btrfs_invalidate_inodes(dest); | ||
5231 | d_delete(dentry); | ||
5232 | ASSERT(dest->send_in_progress == 0); | ||
5233 | diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c | ||
5234 | index 5e7af1c69577..11368881477c 100644 | ||
5235 | --- a/fs/ext4/indirect.c | ||
5236 | +++ b/fs/ext4/indirect.c | ||
5237 | @@ -565,7 +565,7 @@ int ext4_ind_map_blocks(handle_t *handle, struct inode *inode, | ||
5238 | EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { | ||
5239 | EXT4_ERROR_INODE(inode, "Can't allocate blocks for " | ||
5240 | "non-extent mapped inodes with bigalloc"); | ||
5241 | - return -ENOSPC; | ||
5242 | + return -EUCLEAN; | ||
5243 | } | ||
5244 | |||
5245 | /* Set up for the direct block allocation */ | ||
5246 | diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c | ||
5247 | index 842cdd153c20..120824664d32 100644 | ||
5248 | --- a/fs/ext4/inode.c | ||
5249 | +++ b/fs/ext4/inode.c | ||
5250 | @@ -1606,19 +1606,32 @@ static int __ext4_journalled_writepage(struct page *page, | ||
5251 | ext4_walk_page_buffers(handle, page_bufs, 0, len, | ||
5252 | NULL, bget_one); | ||
5253 | } | ||
5254 | - /* As soon as we unlock the page, it can go away, but we have | ||
5255 | - * references to buffers so we are safe */ | ||
5256 | + /* | ||
5257 | + * We need to release the page lock before we start the | ||
5258 | + * journal, so grab a reference so the page won't disappear | ||
5259 | + * out from under us. | ||
5260 | + */ | ||
5261 | + get_page(page); | ||
5262 | unlock_page(page); | ||
5263 | |||
5264 | handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, | ||
5265 | ext4_writepage_trans_blocks(inode)); | ||
5266 | if (IS_ERR(handle)) { | ||
5267 | ret = PTR_ERR(handle); | ||
5268 | - goto out; | ||
5269 | + put_page(page); | ||
5270 | + goto out_no_pagelock; | ||
5271 | } | ||
5272 | - | ||
5273 | BUG_ON(!ext4_handle_valid(handle)); | ||
5274 | |||
5275 | + lock_page(page); | ||
5276 | + put_page(page); | ||
5277 | + if (page->mapping != mapping) { | ||
5278 | + /* The page got truncated from under us */ | ||
5279 | + ext4_journal_stop(handle); | ||
5280 | + ret = 0; | ||
5281 | + goto out; | ||
5282 | + } | ||
5283 | + | ||
5284 | if (inline_data) { | ||
5285 | BUFFER_TRACE(inode_bh, "get write access"); | ||
5286 | ret = ext4_journal_get_write_access(handle, inode_bh); | ||
5287 | @@ -1644,6 +1657,8 @@ static int __ext4_journalled_writepage(struct page *page, | ||
5288 | NULL, bput_one); | ||
5289 | ext4_set_inode_state(inode, EXT4_STATE_JDATA); | ||
5290 | out: | ||
5291 | + unlock_page(page); | ||
5292 | +out_no_pagelock: | ||
5293 | brelse(inode_bh); | ||
5294 | return ret; | ||
5295 | } | ||
5296 | diff --git a/fs/ext4/super.c b/fs/ext4/super.c | ||
5297 | index fc7391e14c2a..bf038468d752 100644 | ||
5298 | --- a/fs/ext4/super.c | ||
5299 | +++ b/fs/ext4/super.c | ||
5300 | @@ -831,6 +831,7 @@ static void ext4_put_super(struct super_block *sb) | ||
5301 | dump_orphan_list(sb, sbi); | ||
5302 | J_ASSERT(list_empty(&sbi->s_orphan)); | ||
5303 | |||
5304 | + sync_blockdev(sb->s_bdev); | ||
5305 | invalidate_bdev(sb->s_bdev); | ||
5306 | if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) { | ||
5307 | /* | ||
5308 | diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c | ||
5309 | index 03246cd9d47a..9e3f6cfee2fb 100644 | ||
5310 | --- a/fs/fuse/inode.c | ||
5311 | +++ b/fs/fuse/inode.c | ||
5312 | @@ -1049,6 +1049,7 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent) | ||
5313 | goto err_fput; | ||
5314 | |||
5315 | fuse_conn_init(fc); | ||
5316 | + fc->release = fuse_free_conn; | ||
5317 | |||
5318 | fc->dev = sb->s_dev; | ||
5319 | fc->sb = sb; | ||
5320 | @@ -1063,7 +1064,6 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent) | ||
5321 | fc->dont_mask = 1; | ||
5322 | sb->s_flags |= MS_POSIXACL; | ||
5323 | |||
5324 | - fc->release = fuse_free_conn; | ||
5325 | fc->flags = d.flags; | ||
5326 | fc->user_id = d.user_id; | ||
5327 | fc->group_id = d.group_id; | ||
5328 | diff --git a/fs/jbd2/checkpoint.c b/fs/jbd2/checkpoint.c | ||
5329 | index 988b32ed4c87..4227dc4f7437 100644 | ||
5330 | --- a/fs/jbd2/checkpoint.c | ||
5331 | +++ b/fs/jbd2/checkpoint.c | ||
5332 | @@ -390,7 +390,7 @@ int jbd2_cleanup_journal_tail(journal_t *journal) | ||
5333 | unsigned long blocknr; | ||
5334 | |||
5335 | if (is_journal_aborted(journal)) | ||
5336 | - return 1; | ||
5337 | + return -EIO; | ||
5338 | |||
5339 | if (!jbd2_journal_get_log_tail(journal, &first_tid, &blocknr)) | ||
5340 | return 1; | ||
5341 | @@ -405,10 +405,9 @@ int jbd2_cleanup_journal_tail(journal_t *journal) | ||
5342 | * jbd2_cleanup_journal_tail() doesn't get called all that often. | ||
5343 | */ | ||
5344 | if (journal->j_flags & JBD2_BARRIER) | ||
5345 | - blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL); | ||
5346 | + blkdev_issue_flush(journal->j_fs_dev, GFP_NOFS, NULL); | ||
5347 | |||
5348 | - __jbd2_update_log_tail(journal, first_tid, blocknr); | ||
5349 | - return 0; | ||
5350 | + return __jbd2_update_log_tail(journal, first_tid, blocknr); | ||
5351 | } | ||
5352 | |||
5353 | |||
5354 | diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c | ||
5355 | index 1df94fabe4eb..be6f7178d23a 100644 | ||
5356 | --- a/fs/jbd2/journal.c | ||
5357 | +++ b/fs/jbd2/journal.c | ||
5358 | @@ -885,9 +885,10 @@ int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid, | ||
5359 | * | ||
5360 | * Requires j_checkpoint_mutex | ||
5361 | */ | ||
5362 | -void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block) | ||
5363 | +int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block) | ||
5364 | { | ||
5365 | unsigned long freed; | ||
5366 | + int ret; | ||
5367 | |||
5368 | BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); | ||
5369 | |||
5370 | @@ -897,7 +898,10 @@ void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block) | ||
5371 | * space and if we lose sb update during power failure we'd replay | ||
5372 | * old transaction with possibly newly overwritten data. | ||
5373 | */ | ||
5374 | - jbd2_journal_update_sb_log_tail(journal, tid, block, WRITE_FUA); | ||
5375 | + ret = jbd2_journal_update_sb_log_tail(journal, tid, block, WRITE_FUA); | ||
5376 | + if (ret) | ||
5377 | + goto out; | ||
5378 | + | ||
5379 | write_lock(&journal->j_state_lock); | ||
5380 | freed = block - journal->j_tail; | ||
5381 | if (block < journal->j_tail) | ||
5382 | @@ -913,6 +917,9 @@ void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block) | ||
5383 | journal->j_tail_sequence = tid; | ||
5384 | journal->j_tail = block; | ||
5385 | write_unlock(&journal->j_state_lock); | ||
5386 | + | ||
5387 | +out: | ||
5388 | + return ret; | ||
5389 | } | ||
5390 | |||
5391 | /* | ||
5392 | @@ -1331,7 +1338,7 @@ static int journal_reset(journal_t *journal) | ||
5393 | return jbd2_journal_start_thread(journal); | ||
5394 | } | ||
5395 | |||
5396 | -static void jbd2_write_superblock(journal_t *journal, int write_op) | ||
5397 | +static int jbd2_write_superblock(journal_t *journal, int write_op) | ||
5398 | { | ||
5399 | struct buffer_head *bh = journal->j_sb_buffer; | ||
5400 | journal_superblock_t *sb = journal->j_superblock; | ||
5401 | @@ -1370,7 +1377,10 @@ static void jbd2_write_superblock(journal_t *journal, int write_op) | ||
5402 | printk(KERN_ERR "JBD2: Error %d detected when updating " | ||
5403 | "journal superblock for %s.\n", ret, | ||
5404 | journal->j_devname); | ||
5405 | + jbd2_journal_abort(journal, ret); | ||
5406 | } | ||
5407 | + | ||
5408 | + return ret; | ||
5409 | } | ||
5410 | |||
5411 | /** | ||
5412 | @@ -1383,10 +1393,11 @@ static void jbd2_write_superblock(journal_t *journal, int write_op) | ||
5413 | * Update a journal's superblock information about log tail and write it to | ||
5414 | * disk, waiting for the IO to complete. | ||
5415 | */ | ||
5416 | -void jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid, | ||
5417 | +int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid, | ||
5418 | unsigned long tail_block, int write_op) | ||
5419 | { | ||
5420 | journal_superblock_t *sb = journal->j_superblock; | ||
5421 | + int ret; | ||
5422 | |||
5423 | BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); | ||
5424 | jbd_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n", | ||
5425 | @@ -1395,13 +1406,18 @@ void jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid, | ||
5426 | sb->s_sequence = cpu_to_be32(tail_tid); | ||
5427 | sb->s_start = cpu_to_be32(tail_block); | ||
5428 | |||
5429 | - jbd2_write_superblock(journal, write_op); | ||
5430 | + ret = jbd2_write_superblock(journal, write_op); | ||
5431 | + if (ret) | ||
5432 | + goto out; | ||
5433 | |||
5434 | /* Log is no longer empty */ | ||
5435 | write_lock(&journal->j_state_lock); | ||
5436 | WARN_ON(!sb->s_sequence); | ||
5437 | journal->j_flags &= ~JBD2_FLUSHED; | ||
5438 | write_unlock(&journal->j_state_lock); | ||
5439 | + | ||
5440 | +out: | ||
5441 | + return ret; | ||
5442 | } | ||
5443 | |||
5444 | /** | ||
5445 | @@ -1951,7 +1967,14 @@ int jbd2_journal_flush(journal_t *journal) | ||
5446 | return -EIO; | ||
5447 | |||
5448 | mutex_lock(&journal->j_checkpoint_mutex); | ||
5449 | - jbd2_cleanup_journal_tail(journal); | ||
5450 | + if (!err) { | ||
5451 | + err = jbd2_cleanup_journal_tail(journal); | ||
5452 | + if (err < 0) { | ||
5453 | + mutex_unlock(&journal->j_checkpoint_mutex); | ||
5454 | + goto out; | ||
5455 | + } | ||
5456 | + err = 0; | ||
5457 | + } | ||
5458 | |||
5459 | /* Finally, mark the journal as really needing no recovery. | ||
5460 | * This sets s_start==0 in the underlying superblock, which is | ||
5461 | @@ -1967,7 +1990,8 @@ int jbd2_journal_flush(journal_t *journal) | ||
5462 | J_ASSERT(journal->j_head == journal->j_tail); | ||
5463 | J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence); | ||
5464 | write_unlock(&journal->j_state_lock); | ||
5465 | - return 0; | ||
5466 | +out: | ||
5467 | + return err; | ||
5468 | } | ||
5469 | |||
5470 | /** | ||
5471 | diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c | ||
5472 | index cd617076aeca..b13edc0865f7 100644 | ||
5473 | --- a/fs/nfs/nfs4proc.c | ||
5474 | +++ b/fs/nfs/nfs4proc.c | ||
5475 | @@ -38,6 +38,7 @@ | ||
5476 | #include <linux/mm.h> | ||
5477 | #include <linux/delay.h> | ||
5478 | #include <linux/errno.h> | ||
5479 | +#include <linux/file.h> | ||
5480 | #include <linux/string.h> | ||
5481 | #include <linux/ratelimit.h> | ||
5482 | #include <linux/printk.h> | ||
5483 | @@ -5355,6 +5356,7 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, | ||
5484 | atomic_inc(&lsp->ls_count); | ||
5485 | /* Ensure we don't close file until we're done freeing locks! */ | ||
5486 | p->ctx = get_nfs_open_context(ctx); | ||
5487 | + get_file(fl->fl_file); | ||
5488 | memcpy(&p->fl, fl, sizeof(p->fl)); | ||
5489 | p->server = NFS_SERVER(inode); | ||
5490 | return p; | ||
5491 | @@ -5366,6 +5368,7 @@ static void nfs4_locku_release_calldata(void *data) | ||
5492 | nfs_free_seqid(calldata->arg.seqid); | ||
5493 | nfs4_put_lock_state(calldata->lsp); | ||
5494 | put_nfs_open_context(calldata->ctx); | ||
5495 | + fput(calldata->fl.fl_file); | ||
5496 | kfree(calldata); | ||
5497 | } | ||
5498 | |||
5499 | @@ -5550,6 +5553,7 @@ static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl, | ||
5500 | p->server = server; | ||
5501 | atomic_inc(&lsp->ls_count); | ||
5502 | p->ctx = get_nfs_open_context(ctx); | ||
5503 | + get_file(fl->fl_file); | ||
5504 | memcpy(&p->fl, fl, sizeof(p->fl)); | ||
5505 | return p; | ||
5506 | out_free_seqid: | ||
5507 | @@ -5639,6 +5643,7 @@ static void nfs4_lock_release(void *calldata) | ||
5508 | nfs_free_seqid(data->arg.lock_seqid); | ||
5509 | nfs4_put_lock_state(data->lsp); | ||
5510 | put_nfs_open_context(data->ctx); | ||
5511 | + fput(data->fl.fl_file); | ||
5512 | kfree(data); | ||
5513 | dprintk("%s: done!\n", __func__); | ||
5514 | } | ||
5515 | diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c | ||
5516 | index 5194933ed419..1f9d57ab8df4 100644 | ||
5517 | --- a/fs/nfs/nfs4state.c | ||
5518 | +++ b/fs/nfs/nfs4state.c | ||
5519 | @@ -1455,6 +1455,8 @@ restart: | ||
5520 | spin_unlock(&state->state_lock); | ||
5521 | } | ||
5522 | nfs4_put_open_state(state); | ||
5523 | + clear_bit(NFS4CLNT_RECLAIM_NOGRACE, | ||
5524 | + &state->flags); | ||
5525 | spin_lock(&sp->so_lock); | ||
5526 | goto restart; | ||
5527 | } | ||
5528 | diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c | ||
5529 | index 883ee88e5f5e..354f66609316 100644 | ||
5530 | --- a/fs/nfs/pnfs.c | ||
5531 | +++ b/fs/nfs/pnfs.c | ||
5532 | @@ -1535,6 +1535,7 @@ int pnfs_write_done_resend_to_mds(struct nfs_pgio_header *hdr) | ||
5533 | /* Resend all requests through the MDS */ | ||
5534 | nfs_pageio_init_write(&pgio, hdr->inode, FLUSH_STABLE, true, | ||
5535 | hdr->completion_ops); | ||
5536 | + set_bit(NFS_CONTEXT_RESEND_WRITES, &hdr->args.context->flags); | ||
5537 | return nfs_pageio_resend(&pgio, hdr); | ||
5538 | } | ||
5539 | EXPORT_SYMBOL_GPL(pnfs_write_done_resend_to_mds); | ||
5540 | @@ -1576,6 +1577,7 @@ pnfs_write_through_mds(struct nfs_pageio_descriptor *desc, | ||
5541 | desc->pg_recoalesce = 1; | ||
5542 | } | ||
5543 | nfs_pgio_data_destroy(hdr); | ||
5544 | + hdr->release(hdr); | ||
5545 | } | ||
5546 | |||
5547 | static enum pnfs_try_status | ||
5548 | @@ -1692,6 +1694,7 @@ pnfs_read_through_mds(struct nfs_pageio_descriptor *desc, | ||
5549 | desc->pg_recoalesce = 1; | ||
5550 | } | ||
5551 | nfs_pgio_data_destroy(hdr); | ||
5552 | + hdr->release(hdr); | ||
5553 | } | ||
5554 | |||
5555 | /* | ||
5556 | diff --git a/fs/nfs/write.c b/fs/nfs/write.c | ||
5557 | index f83b02dc9166..6067f2a0b493 100644 | ||
5558 | --- a/fs/nfs/write.c | ||
5559 | +++ b/fs/nfs/write.c | ||
5560 | @@ -1252,6 +1252,7 @@ static void nfs_initiate_write(struct nfs_pgio_header *hdr, | ||
5561 | static void nfs_redirty_request(struct nfs_page *req) | ||
5562 | { | ||
5563 | nfs_mark_request_dirty(req); | ||
5564 | + set_bit(NFS_CONTEXT_RESEND_WRITES, &req->wb_context->flags); | ||
5565 | nfs_unlock_request(req); | ||
5566 | nfs_end_page_writeback(req); | ||
5567 | nfs_release_request(req); | ||
5568 | diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c | ||
5569 | index 02ae62a998e0..6a93fd583ec0 100644 | ||
5570 | --- a/fs/xfs/xfs_symlink.c | ||
5571 | +++ b/fs/xfs/xfs_symlink.c | ||
5572 | @@ -107,7 +107,7 @@ xfs_readlink_bmap( | ||
5573 | cur_chunk += sizeof(struct xfs_dsymlink_hdr); | ||
5574 | } | ||
5575 | |||
5576 | - memcpy(link + offset, bp->b_addr, byte_cnt); | ||
5577 | + memcpy(link + offset, cur_chunk, byte_cnt); | ||
5578 | |||
5579 | pathlen -= byte_cnt; | ||
5580 | offset += byte_cnt; | ||
5581 | diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h | ||
5582 | index 704b9a599b26..dadb42109dec 100644 | ||
5583 | --- a/include/linux/jbd2.h | ||
5584 | +++ b/include/linux/jbd2.h | ||
5585 | @@ -1035,7 +1035,7 @@ struct buffer_head *jbd2_journal_get_descriptor_buffer(journal_t *journal); | ||
5586 | int jbd2_journal_next_log_block(journal_t *, unsigned long long *); | ||
5587 | int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid, | ||
5588 | unsigned long *block); | ||
5589 | -void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block); | ||
5590 | +int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block); | ||
5591 | void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block); | ||
5592 | |||
5593 | /* Commit management */ | ||
5594 | @@ -1157,7 +1157,7 @@ extern int jbd2_journal_recover (journal_t *journal); | ||
5595 | extern int jbd2_journal_wipe (journal_t *, int); | ||
5596 | extern int jbd2_journal_skip_recovery (journal_t *); | ||
5597 | extern void jbd2_journal_update_sb_errno(journal_t *); | ||
5598 | -extern void jbd2_journal_update_sb_log_tail (journal_t *, tid_t, | ||
5599 | +extern int jbd2_journal_update_sb_log_tail (journal_t *, tid_t, | ||
5600 | unsigned long, int); | ||
5601 | extern void __jbd2_journal_abort_hard (journal_t *); | ||
5602 | extern void jbd2_journal_abort (journal_t *, int); | ||
5603 | diff --git a/include/linux/kmemleak.h b/include/linux/kmemleak.h | ||
5604 | index 057e95971014..19acfdc3828f 100644 | ||
5605 | --- a/include/linux/kmemleak.h | ||
5606 | +++ b/include/linux/kmemleak.h | ||
5607 | @@ -26,7 +26,8 @@ | ||
5608 | extern void kmemleak_init(void) __ref; | ||
5609 | extern void kmemleak_alloc(const void *ptr, size_t size, int min_count, | ||
5610 | gfp_t gfp) __ref; | ||
5611 | -extern void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size) __ref; | ||
5612 | +extern void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size, | ||
5613 | + gfp_t gfp) __ref; | ||
5614 | extern void kmemleak_free(const void *ptr) __ref; | ||
5615 | extern void kmemleak_free_part(const void *ptr, size_t size) __ref; | ||
5616 | extern void kmemleak_free_percpu(const void __percpu *ptr) __ref; | ||
5617 | @@ -69,7 +70,8 @@ static inline void kmemleak_alloc_recursive(const void *ptr, size_t size, | ||
5618 | gfp_t gfp) | ||
5619 | { | ||
5620 | } | ||
5621 | -static inline void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size) | ||
5622 | +static inline void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size, | ||
5623 | + gfp_t gfp) | ||
5624 | { | ||
5625 | } | ||
5626 | static inline void kmemleak_free(const void *ptr) | ||
5627 | diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h | ||
5628 | index d77a08d25223..d71682435f4a 100644 | ||
5629 | --- a/include/linux/nfs_xdr.h | ||
5630 | +++ b/include/linux/nfs_xdr.h | ||
5631 | @@ -1132,7 +1132,7 @@ struct nfs41_state_protection { | ||
5632 | struct nfs4_op_map allow; | ||
5633 | }; | ||
5634 | |||
5635 | -#define NFS4_EXCHANGE_ID_LEN (48) | ||
5636 | +#define NFS4_EXCHANGE_ID_LEN (127) | ||
5637 | struct nfs41_exchange_id_args { | ||
5638 | struct nfs_client *client; | ||
5639 | nfs4_verifier *verifier; | ||
5640 | diff --git a/include/linux/pci.h b/include/linux/pci.h | ||
5641 | index 2882c13c6391..e92cdad3240d 100644 | ||
5642 | --- a/include/linux/pci.h | ||
5643 | +++ b/include/linux/pci.h | ||
5644 | @@ -993,6 +993,7 @@ int __must_check pci_assign_resource(struct pci_dev *dev, int i); | ||
5645 | int __must_check pci_reassign_resource(struct pci_dev *dev, int i, resource_size_t add_size, resource_size_t align); | ||
5646 | int pci_select_bars(struct pci_dev *dev, unsigned long flags); | ||
5647 | bool pci_device_is_present(struct pci_dev *pdev); | ||
5648 | +void pci_ignore_hotplug(struct pci_dev *dev); | ||
5649 | |||
5650 | /* ROM control related routines */ | ||
5651 | int pci_enable_rom(struct pci_dev *pdev); | ||
5652 | @@ -1028,11 +1029,6 @@ bool pci_dev_run_wake(struct pci_dev *dev); | ||
5653 | bool pci_check_pme_status(struct pci_dev *dev); | ||
5654 | void pci_pme_wakeup_bus(struct pci_bus *bus); | ||
5655 | |||
5656 | -static inline void pci_ignore_hotplug(struct pci_dev *dev) | ||
5657 | -{ | ||
5658 | - dev->ignore_hotplug = 1; | ||
5659 | -} | ||
5660 | - | ||
5661 | static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state, | ||
5662 | bool enable) | ||
5663 | { | ||
5664 | diff --git a/include/linux/rhashtable.h b/include/linux/rhashtable.h | ||
5665 | index fb298e9d6d3a..84056743780a 100644 | ||
5666 | --- a/include/linux/rhashtable.h | ||
5667 | +++ b/include/linux/rhashtable.h | ||
5668 | @@ -108,7 +108,7 @@ int rhashtable_expand(struct rhashtable *ht, gfp_t flags); | ||
5669 | int rhashtable_shrink(struct rhashtable *ht, gfp_t flags); | ||
5670 | |||
5671 | void *rhashtable_lookup(const struct rhashtable *ht, const void *key); | ||
5672 | -void *rhashtable_lookup_compare(const struct rhashtable *ht, u32 hash, | ||
5673 | +void *rhashtable_lookup_compare(const struct rhashtable *ht, void *key, | ||
5674 | bool (*compare)(void *, void *), void *arg); | ||
5675 | |||
5676 | void rhashtable_destroy(const struct rhashtable *ht); | ||
5677 | diff --git a/include/net/netfilter/nf_queue.h b/include/net/netfilter/nf_queue.h | ||
5678 | index 84a53d780306..1a91f979160e 100644 | ||
5679 | --- a/include/net/netfilter/nf_queue.h | ||
5680 | +++ b/include/net/netfilter/nf_queue.h | ||
5681 | @@ -28,6 +28,8 @@ struct nf_queue_entry { | ||
5682 | struct nf_queue_handler { | ||
5683 | int (*outfn)(struct nf_queue_entry *entry, | ||
5684 | unsigned int queuenum); | ||
5685 | + void (*nf_hook_drop)(struct net *net, | ||
5686 | + struct nf_hook_ops *ops); | ||
5687 | }; | ||
5688 | |||
5689 | void nf_register_queue_handler(const struct nf_queue_handler *qh); | ||
5690 | diff --git a/include/net/netns/sctp.h b/include/net/netns/sctp.h | ||
5691 | index 3573a81815ad..8ba379f9e467 100644 | ||
5692 | --- a/include/net/netns/sctp.h | ||
5693 | +++ b/include/net/netns/sctp.h | ||
5694 | @@ -31,6 +31,7 @@ struct netns_sctp { | ||
5695 | struct list_head addr_waitq; | ||
5696 | struct timer_list addr_wq_timer; | ||
5697 | struct list_head auto_asconf_splist; | ||
5698 | + /* Lock that protects both addr_waitq and auto_asconf_splist */ | ||
5699 | spinlock_t addr_wq_lock; | ||
5700 | |||
5701 | /* Lock that protects the local_addr_list writers */ | ||
5702 | diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h | ||
5703 | index 4ff3f67be62c..2ad3a7bc8385 100644 | ||
5704 | --- a/include/net/sctp/structs.h | ||
5705 | +++ b/include/net/sctp/structs.h | ||
5706 | @@ -223,6 +223,10 @@ struct sctp_sock { | ||
5707 | atomic_t pd_mode; | ||
5708 | /* Receive to here while partial delivery is in effect. */ | ||
5709 | struct sk_buff_head pd_lobby; | ||
5710 | + | ||
5711 | + /* These must be the last fields, as they will skipped on copies, | ||
5712 | + * like on accept and peeloff operations | ||
5713 | + */ | ||
5714 | struct list_head auto_asconf_list; | ||
5715 | int do_auto_asconf; | ||
5716 | }; | ||
5717 | diff --git a/include/uapi/drm/radeon_drm.h b/include/uapi/drm/radeon_drm.h | ||
5718 | index 50d0fb41a3bf..76d2edea5bd1 100644 | ||
5719 | --- a/include/uapi/drm/radeon_drm.h | ||
5720 | +++ b/include/uapi/drm/radeon_drm.h | ||
5721 | @@ -1034,6 +1034,7 @@ struct drm_radeon_cs { | ||
5722 | #define RADEON_INFO_VRAM_USAGE 0x1e | ||
5723 | #define RADEON_INFO_GTT_USAGE 0x1f | ||
5724 | #define RADEON_INFO_ACTIVE_CU_COUNT 0x20 | ||
5725 | +#define RADEON_INFO_VA_UNMAP_WORKING 0x25 | ||
5726 | |||
5727 | struct drm_radeon_info { | ||
5728 | uint32_t request; | ||
5729 | diff --git a/kernel/irq/devres.c b/kernel/irq/devres.c | ||
5730 | index d5d0f7345c54..74d90a754268 100644 | ||
5731 | --- a/kernel/irq/devres.c | ||
5732 | +++ b/kernel/irq/devres.c | ||
5733 | @@ -104,7 +104,7 @@ int devm_request_any_context_irq(struct device *dev, unsigned int irq, | ||
5734 | return -ENOMEM; | ||
5735 | |||
5736 | rc = request_any_context_irq(irq, handler, irqflags, devname, dev_id); | ||
5737 | - if (rc) { | ||
5738 | + if (rc < 0) { | ||
5739 | devres_free(dr); | ||
5740 | return rc; | ||
5741 | } | ||
5742 | @@ -113,7 +113,7 @@ int devm_request_any_context_irq(struct device *dev, unsigned int irq, | ||
5743 | dr->dev_id = dev_id; | ||
5744 | devres_add(dev, dr); | ||
5745 | |||
5746 | - return 0; | ||
5747 | + return rc; | ||
5748 | } | ||
5749 | EXPORT_SYMBOL(devm_request_any_context_irq); | ||
5750 | |||
5751 | diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig | ||
5752 | index bbef57f5bdfd..c2ae4618a159 100644 | ||
5753 | --- a/kernel/power/Kconfig | ||
5754 | +++ b/kernel/power/Kconfig | ||
5755 | @@ -191,7 +191,7 @@ config DPM_WATCHDOG | ||
5756 | config DPM_WATCHDOG_TIMEOUT | ||
5757 | int "Watchdog timeout in seconds" | ||
5758 | range 1 120 | ||
5759 | - default 12 | ||
5760 | + default 60 | ||
5761 | depends on DPM_WATCHDOG | ||
5762 | |||
5763 | config PM_TRACE | ||
5764 | diff --git a/kernel/rcu/tiny.c b/kernel/rcu/tiny.c | ||
5765 | index c0623fc47125..da80f2f73b50 100644 | ||
5766 | --- a/kernel/rcu/tiny.c | ||
5767 | +++ b/kernel/rcu/tiny.c | ||
5768 | @@ -282,6 +282,11 @@ static void __rcu_process_callbacks(struct rcu_ctrlblk *rcp) | ||
5769 | |||
5770 | /* Move the ready-to-invoke callbacks to a local list. */ | ||
5771 | local_irq_save(flags); | ||
5772 | + if (rcp->donetail == &rcp->rcucblist) { | ||
5773 | + /* No callbacks ready, so just leave. */ | ||
5774 | + local_irq_restore(flags); | ||
5775 | + return; | ||
5776 | + } | ||
5777 | RCU_TRACE(trace_rcu_batch_start(rcp->name, 0, rcp->qlen, -1)); | ||
5778 | list = rcp->rcucblist; | ||
5779 | rcp->rcucblist = *rcp->donetail; | ||
5780 | diff --git a/kernel/softirq.c b/kernel/softirq.c | ||
5781 | index 0699add19164..9e787d8311b5 100644 | ||
5782 | --- a/kernel/softirq.c | ||
5783 | +++ b/kernel/softirq.c | ||
5784 | @@ -656,9 +656,13 @@ static void run_ksoftirqd(unsigned int cpu) | ||
5785 | * in the task stack here. | ||
5786 | */ | ||
5787 | __do_softirq(); | ||
5788 | - rcu_note_context_switch(cpu); | ||
5789 | local_irq_enable(); | ||
5790 | cond_resched(); | ||
5791 | + | ||
5792 | + preempt_disable(); | ||
5793 | + rcu_note_context_switch(cpu); | ||
5794 | + preempt_enable(); | ||
5795 | + | ||
5796 | return; | ||
5797 | } | ||
5798 | local_irq_enable(); | ||
5799 | diff --git a/kernel/trace/ring_buffer_benchmark.c b/kernel/trace/ring_buffer_benchmark.c | ||
5800 | index 3f9e328c30b5..728f99b4533d 100644 | ||
5801 | --- a/kernel/trace/ring_buffer_benchmark.c | ||
5802 | +++ b/kernel/trace/ring_buffer_benchmark.c | ||
5803 | @@ -452,7 +452,7 @@ static int __init ring_buffer_benchmark_init(void) | ||
5804 | |||
5805 | if (producer_fifo >= 0) { | ||
5806 | struct sched_param param = { | ||
5807 | - .sched_priority = consumer_fifo | ||
5808 | + .sched_priority = producer_fifo | ||
5809 | }; | ||
5810 | sched_setscheduler(producer, SCHED_FIFO, ¶m); | ||
5811 | } else | ||
5812 | diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c | ||
5813 | index 7a8c1528e141..bcb9145a7913 100644 | ||
5814 | --- a/kernel/trace/trace_events_filter.c | ||
5815 | +++ b/kernel/trace/trace_events_filter.c | ||
5816 | @@ -1050,6 +1050,9 @@ static void parse_init(struct filter_parse_state *ps, | ||
5817 | |||
5818 | static char infix_next(struct filter_parse_state *ps) | ||
5819 | { | ||
5820 | + if (!ps->infix.cnt) | ||
5821 | + return 0; | ||
5822 | + | ||
5823 | ps->infix.cnt--; | ||
5824 | |||
5825 | return ps->infix.string[ps->infix.tail++]; | ||
5826 | @@ -1065,6 +1068,9 @@ static char infix_peek(struct filter_parse_state *ps) | ||
5827 | |||
5828 | static void infix_advance(struct filter_parse_state *ps) | ||
5829 | { | ||
5830 | + if (!ps->infix.cnt) | ||
5831 | + return; | ||
5832 | + | ||
5833 | ps->infix.cnt--; | ||
5834 | ps->infix.tail++; | ||
5835 | } | ||
5836 | diff --git a/lib/rhashtable.c b/lib/rhashtable.c | ||
5837 | index 624a0b7c05ef..cb22073fe687 100644 | ||
5838 | --- a/lib/rhashtable.c | ||
5839 | +++ b/lib/rhashtable.c | ||
5840 | @@ -61,6 +61,8 @@ static u32 __hashfn(const struct rhashtable *ht, const void *key, | ||
5841 | * Computes the hash value using the hash function provided in the 'hashfn' | ||
5842 | * of struct rhashtable_params. The returned value is guaranteed to be | ||
5843 | * smaller than the number of buckets in the hash table. | ||
5844 | + * | ||
5845 | + * The caller must ensure that no concurrent table mutations occur. | ||
5846 | */ | ||
5847 | u32 rhashtable_hashfn(const struct rhashtable *ht, const void *key, u32 len) | ||
5848 | { | ||
5849 | @@ -92,6 +94,8 @@ static u32 obj_hashfn(const struct rhashtable *ht, const void *ptr, u32 hsize) | ||
5850 | * 'obj_hashfn' depending on whether the hash table is set up to work with | ||
5851 | * a fixed length key. The returned value is guaranteed to be smaller than | ||
5852 | * the number of buckets in the hash table. | ||
5853 | + * | ||
5854 | + * The caller must ensure that no concurrent table mutations occur. | ||
5855 | */ | ||
5856 | u32 rhashtable_obj_hashfn(const struct rhashtable *ht, void *ptr) | ||
5857 | { | ||
5858 | @@ -474,7 +478,7 @@ EXPORT_SYMBOL_GPL(rhashtable_lookup); | ||
5859 | /** | ||
5860 | * rhashtable_lookup_compare - search hash table with compare function | ||
5861 | * @ht: hash table | ||
5862 | - * @hash: hash value of desired entry | ||
5863 | + * @key: pointer to key | ||
5864 | * @compare: compare function, must return true on match | ||
5865 | * @arg: argument passed on to compare function | ||
5866 | * | ||
5867 | @@ -486,14 +490,14 @@ EXPORT_SYMBOL_GPL(rhashtable_lookup); | ||
5868 | * | ||
5869 | * Returns the first entry on which the compare function returned true. | ||
5870 | */ | ||
5871 | -void *rhashtable_lookup_compare(const struct rhashtable *ht, u32 hash, | ||
5872 | +void *rhashtable_lookup_compare(const struct rhashtable *ht, void *key, | ||
5873 | bool (*compare)(void *, void *), void *arg) | ||
5874 | { | ||
5875 | const struct bucket_table *tbl = rht_dereference_rcu(ht->tbl, ht); | ||
5876 | struct rhash_head *he; | ||
5877 | + u32 hash; | ||
5878 | |||
5879 | - if (unlikely(hash >= tbl->size)) | ||
5880 | - return NULL; | ||
5881 | + hash = __hashfn(ht, key, ht->p.key_len, tbl->size); | ||
5882 | |||
5883 | rht_for_each_rcu(he, tbl->buckets[hash], ht) { | ||
5884 | if (!compare(rht_obj(ht, he), arg)) | ||
5885 | diff --git a/mm/kmemleak.c b/mm/kmemleak.c | ||
5886 | index 3cda50c1e394..1f14ef68a5c8 100644 | ||
5887 | --- a/mm/kmemleak.c | ||
5888 | +++ b/mm/kmemleak.c | ||
5889 | @@ -193,6 +193,8 @@ static struct kmem_cache *scan_area_cache; | ||
5890 | |||
5891 | /* set if tracing memory operations is enabled */ | ||
5892 | static int kmemleak_enabled; | ||
5893 | +/* same as above but only for the kmemleak_free() callback */ | ||
5894 | +static int kmemleak_free_enabled; | ||
5895 | /* set in the late_initcall if there were no errors */ | ||
5896 | static int kmemleak_initialized; | ||
5897 | /* enables or disables early logging of the memory operations */ | ||
5898 | @@ -905,12 +907,13 @@ EXPORT_SYMBOL_GPL(kmemleak_alloc); | ||
5899 | * kmemleak_alloc_percpu - register a newly allocated __percpu object | ||
5900 | * @ptr: __percpu pointer to beginning of the object | ||
5901 | * @size: size of the object | ||
5902 | + * @gfp: flags used for kmemleak internal memory allocations | ||
5903 | * | ||
5904 | * This function is called from the kernel percpu allocator when a new object | ||
5905 | - * (memory block) is allocated (alloc_percpu). It assumes GFP_KERNEL | ||
5906 | - * allocation. | ||
5907 | + * (memory block) is allocated (alloc_percpu). | ||
5908 | */ | ||
5909 | -void __ref kmemleak_alloc_percpu(const void __percpu *ptr, size_t size) | ||
5910 | +void __ref kmemleak_alloc_percpu(const void __percpu *ptr, size_t size, | ||
5911 | + gfp_t gfp) | ||
5912 | { | ||
5913 | unsigned int cpu; | ||
5914 | |||
5915 | @@ -923,7 +926,7 @@ void __ref kmemleak_alloc_percpu(const void __percpu *ptr, size_t size) | ||
5916 | if (kmemleak_enabled && ptr && !IS_ERR(ptr)) | ||
5917 | for_each_possible_cpu(cpu) | ||
5918 | create_object((unsigned long)per_cpu_ptr(ptr, cpu), | ||
5919 | - size, 0, GFP_KERNEL); | ||
5920 | + size, 0, gfp); | ||
5921 | else if (kmemleak_early_log) | ||
5922 | log_early(KMEMLEAK_ALLOC_PERCPU, ptr, size, 0); | ||
5923 | } | ||
5924 | @@ -940,7 +943,7 @@ void __ref kmemleak_free(const void *ptr) | ||
5925 | { | ||
5926 | pr_debug("%s(0x%p)\n", __func__, ptr); | ||
5927 | |||
5928 | - if (kmemleak_enabled && ptr && !IS_ERR(ptr)) | ||
5929 | + if (kmemleak_free_enabled && ptr && !IS_ERR(ptr)) | ||
5930 | delete_object_full((unsigned long)ptr); | ||
5931 | else if (kmemleak_early_log) | ||
5932 | log_early(KMEMLEAK_FREE, ptr, 0, 0); | ||
5933 | @@ -980,7 +983,7 @@ void __ref kmemleak_free_percpu(const void __percpu *ptr) | ||
5934 | |||
5935 | pr_debug("%s(0x%p)\n", __func__, ptr); | ||
5936 | |||
5937 | - if (kmemleak_enabled && ptr && !IS_ERR(ptr)) | ||
5938 | + if (kmemleak_free_enabled && ptr && !IS_ERR(ptr)) | ||
5939 | for_each_possible_cpu(cpu) | ||
5940 | delete_object_full((unsigned long)per_cpu_ptr(ptr, | ||
5941 | cpu)); | ||
5942 | @@ -1743,6 +1746,13 @@ static void kmemleak_do_cleanup(struct work_struct *work) | ||
5943 | mutex_lock(&scan_mutex); | ||
5944 | stop_scan_thread(); | ||
5945 | |||
5946 | + /* | ||
5947 | + * Once the scan thread has stopped, it is safe to no longer track | ||
5948 | + * object freeing. Ordering of the scan thread stopping and the memory | ||
5949 | + * accesses below is guaranteed by the kthread_stop() function. | ||
5950 | + */ | ||
5951 | + kmemleak_free_enabled = 0; | ||
5952 | + | ||
5953 | if (!kmemleak_found_leaks) | ||
5954 | __kmemleak_do_cleanup(); | ||
5955 | else | ||
5956 | @@ -1769,6 +1779,8 @@ static void kmemleak_disable(void) | ||
5957 | /* check whether it is too early for a kernel thread */ | ||
5958 | if (kmemleak_initialized) | ||
5959 | schedule_work(&cleanup_work); | ||
5960 | + else | ||
5961 | + kmemleak_free_enabled = 0; | ||
5962 | |||
5963 | pr_info("Kernel memory leak detector disabled\n"); | ||
5964 | } | ||
5965 | @@ -1833,8 +1845,10 @@ void __init kmemleak_init(void) | ||
5966 | if (kmemleak_error) { | ||
5967 | local_irq_restore(flags); | ||
5968 | return; | ||
5969 | - } else | ||
5970 | + } else { | ||
5971 | kmemleak_enabled = 1; | ||
5972 | + kmemleak_free_enabled = 1; | ||
5973 | + } | ||
5974 | local_irq_restore(flags); | ||
5975 | |||
5976 | /* | ||
5977 | diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c | ||
5978 | index 8c71654e261f..05014e89efae 100644 | ||
5979 | --- a/mm/memory_hotplug.c | ||
5980 | +++ b/mm/memory_hotplug.c | ||
5981 | @@ -1978,8 +1978,10 @@ void try_offline_node(int nid) | ||
5982 | * wait_table may be allocated from boot memory, | ||
5983 | * here only free if it's allocated by vmalloc. | ||
5984 | */ | ||
5985 | - if (is_vmalloc_addr(zone->wait_table)) | ||
5986 | + if (is_vmalloc_addr(zone->wait_table)) { | ||
5987 | vfree(zone->wait_table); | ||
5988 | + zone->wait_table = NULL; | ||
5989 | + } | ||
5990 | } | ||
5991 | } | ||
5992 | EXPORT_SYMBOL(try_offline_node); | ||
5993 | diff --git a/mm/percpu.c b/mm/percpu.c | ||
5994 | index 014bab65e0ff..88bb6c92d83a 100644 | ||
5995 | --- a/mm/percpu.c | ||
5996 | +++ b/mm/percpu.c | ||
5997 | @@ -1030,7 +1030,7 @@ area_found: | ||
5998 | memset((void *)pcpu_chunk_addr(chunk, cpu, 0) + off, 0, size); | ||
5999 | |||
6000 | ptr = __addr_to_pcpu_ptr(chunk->base_addr + off); | ||
6001 | - kmemleak_alloc_percpu(ptr, size); | ||
6002 | + kmemleak_alloc_percpu(ptr, size, gfp); | ||
6003 | return ptr; | ||
6004 | |||
6005 | fail_unlock: | ||
6006 | diff --git a/net/bridge/br_ioctl.c b/net/bridge/br_ioctl.c | ||
6007 | index a9a4a1b7863d..8d423bc649b9 100644 | ||
6008 | --- a/net/bridge/br_ioctl.c | ||
6009 | +++ b/net/bridge/br_ioctl.c | ||
6010 | @@ -247,9 +247,7 @@ static int old_dev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) | ||
6011 | if (!ns_capable(dev_net(dev)->user_ns, CAP_NET_ADMIN)) | ||
6012 | return -EPERM; | ||
6013 | |||
6014 | - spin_lock_bh(&br->lock); | ||
6015 | br_stp_set_bridge_priority(br, args[1]); | ||
6016 | - spin_unlock_bh(&br->lock); | ||
6017 | return 0; | ||
6018 | |||
6019 | case BRCTL_SET_PORT_PRIORITY: | ||
6020 | diff --git a/net/bridge/br_multicast.c b/net/bridge/br_multicast.c | ||
6021 | index b0aee78dba41..c08f510fce30 100644 | ||
6022 | --- a/net/bridge/br_multicast.c | ||
6023 | +++ b/net/bridge/br_multicast.c | ||
6024 | @@ -1166,6 +1166,9 @@ static void br_multicast_add_router(struct net_bridge *br, | ||
6025 | struct net_bridge_port *p; | ||
6026 | struct hlist_node *slot = NULL; | ||
6027 | |||
6028 | + if (!hlist_unhashed(&port->rlist)) | ||
6029 | + return; | ||
6030 | + | ||
6031 | hlist_for_each_entry(p, &br->router_list, rlist) { | ||
6032 | if ((unsigned long) port >= (unsigned long) p) | ||
6033 | break; | ||
6034 | @@ -1193,12 +1196,8 @@ static void br_multicast_mark_router(struct net_bridge *br, | ||
6035 | if (port->multicast_router != 1) | ||
6036 | return; | ||
6037 | |||
6038 | - if (!hlist_unhashed(&port->rlist)) | ||
6039 | - goto timer; | ||
6040 | - | ||
6041 | br_multicast_add_router(br, port); | ||
6042 | |||
6043 | -timer: | ||
6044 | mod_timer(&port->multicast_router_timer, | ||
6045 | now + br->multicast_querier_interval); | ||
6046 | } | ||
6047 | diff --git a/net/bridge/br_stp_if.c b/net/bridge/br_stp_if.c | ||
6048 | index 41146872c1b4..7832d07f48f6 100644 | ||
6049 | --- a/net/bridge/br_stp_if.c | ||
6050 | +++ b/net/bridge/br_stp_if.c | ||
6051 | @@ -243,12 +243,13 @@ bool br_stp_recalculate_bridge_id(struct net_bridge *br) | ||
6052 | return true; | ||
6053 | } | ||
6054 | |||
6055 | -/* called under bridge lock */ | ||
6056 | +/* Acquires and releases bridge lock */ | ||
6057 | void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio) | ||
6058 | { | ||
6059 | struct net_bridge_port *p; | ||
6060 | int wasroot; | ||
6061 | |||
6062 | + spin_lock_bh(&br->lock); | ||
6063 | wasroot = br_is_root_bridge(br); | ||
6064 | |||
6065 | list_for_each_entry(p, &br->port_list, list) { | ||
6066 | @@ -266,6 +267,7 @@ void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio) | ||
6067 | br_port_state_selection(br); | ||
6068 | if (br_is_root_bridge(br) && !wasroot) | ||
6069 | br_become_root_bridge(br); | ||
6070 | + spin_unlock_bh(&br->lock); | ||
6071 | } | ||
6072 | |||
6073 | /* called under bridge lock */ | ||
6074 | diff --git a/net/core/neighbour.c b/net/core/neighbour.c | ||
6075 | index ef31fef25e5a..2b0d99dad8be 100644 | ||
6076 | --- a/net/core/neighbour.c | ||
6077 | +++ b/net/core/neighbour.c | ||
6078 | @@ -977,6 +977,8 @@ int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) | ||
6079 | rc = 0; | ||
6080 | if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE)) | ||
6081 | goto out_unlock_bh; | ||
6082 | + if (neigh->dead) | ||
6083 | + goto out_dead; | ||
6084 | |||
6085 | if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) { | ||
6086 | if (NEIGH_VAR(neigh->parms, MCAST_PROBES) + | ||
6087 | @@ -1033,6 +1035,13 @@ out_unlock_bh: | ||
6088 | write_unlock(&neigh->lock); | ||
6089 | local_bh_enable(); | ||
6090 | return rc; | ||
6091 | + | ||
6092 | +out_dead: | ||
6093 | + if (neigh->nud_state & NUD_STALE) | ||
6094 | + goto out_unlock_bh; | ||
6095 | + write_unlock_bh(&neigh->lock); | ||
6096 | + kfree_skb(skb); | ||
6097 | + return 1; | ||
6098 | } | ||
6099 | EXPORT_SYMBOL(__neigh_event_send); | ||
6100 | |||
6101 | @@ -1096,6 +1105,8 @@ int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, | ||
6102 | if (!(flags & NEIGH_UPDATE_F_ADMIN) && | ||
6103 | (old & (NUD_NOARP | NUD_PERMANENT))) | ||
6104 | goto out; | ||
6105 | + if (neigh->dead) | ||
6106 | + goto out; | ||
6107 | |||
6108 | if (!(new & NUD_VALID)) { | ||
6109 | neigh_del_timer(neigh); | ||
6110 | @@ -1245,6 +1256,8 @@ EXPORT_SYMBOL(neigh_update); | ||
6111 | */ | ||
6112 | void __neigh_set_probe_once(struct neighbour *neigh) | ||
6113 | { | ||
6114 | + if (neigh->dead) | ||
6115 | + return; | ||
6116 | neigh->updated = jiffies; | ||
6117 | if (!(neigh->nud_state & NUD_FAILED)) | ||
6118 | return; | ||
6119 | diff --git a/net/core/skbuff.c b/net/core/skbuff.c | ||
6120 | index 02ebb7133312..72400a1bb439 100644 | ||
6121 | --- a/net/core/skbuff.c | ||
6122 | +++ b/net/core/skbuff.c | ||
6123 | @@ -4199,7 +4199,7 @@ struct sk_buff *alloc_skb_with_frags(unsigned long header_len, | ||
6124 | |||
6125 | while (order) { | ||
6126 | if (npages >= 1 << order) { | ||
6127 | - page = alloc_pages(gfp_mask | | ||
6128 | + page = alloc_pages((gfp_mask & ~__GFP_WAIT) | | ||
6129 | __GFP_COMP | | ||
6130 | __GFP_NOWARN | | ||
6131 | __GFP_NORETRY, | ||
6132 | diff --git a/net/core/sock.c b/net/core/sock.c | ||
6133 | index 852acbc52f96..1e5130de31b6 100644 | ||
6134 | --- a/net/core/sock.c | ||
6135 | +++ b/net/core/sock.c | ||
6136 | @@ -1854,7 +1854,7 @@ bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp) | ||
6137 | |||
6138 | pfrag->offset = 0; | ||
6139 | if (SKB_FRAG_PAGE_ORDER) { | ||
6140 | - pfrag->page = alloc_pages(gfp | __GFP_COMP | | ||
6141 | + pfrag->page = alloc_pages((gfp & ~__GFP_WAIT) | __GFP_COMP | | ||
6142 | __GFP_NOWARN | __GFP_NORETRY, | ||
6143 | SKB_FRAG_PAGE_ORDER); | ||
6144 | if (likely(pfrag->page)) { | ||
6145 | diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c | ||
6146 | index e67da4e6c324..9a173577a790 100644 | ||
6147 | --- a/net/ipv4/af_inet.c | ||
6148 | +++ b/net/ipv4/af_inet.c | ||
6149 | @@ -228,6 +228,8 @@ int inet_listen(struct socket *sock, int backlog) | ||
6150 | err = 0; | ||
6151 | if (err) | ||
6152 | goto out; | ||
6153 | + | ||
6154 | + tcp_fastopen_init_key_once(true); | ||
6155 | } | ||
6156 | err = inet_csk_listen_start(sk, backlog); | ||
6157 | if (err) | ||
6158 | diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c | ||
6159 | index de6195485b31..32b25cc96fff 100644 | ||
6160 | --- a/net/ipv4/tcp.c | ||
6161 | +++ b/net/ipv4/tcp.c | ||
6162 | @@ -2585,10 +2585,13 @@ static int do_tcp_setsockopt(struct sock *sk, int level, | ||
6163 | |||
6164 | case TCP_FASTOPEN: | ||
6165 | if (val >= 0 && ((1 << sk->sk_state) & (TCPF_CLOSE | | ||
6166 | - TCPF_LISTEN))) | ||
6167 | + TCPF_LISTEN))) { | ||
6168 | + tcp_fastopen_init_key_once(true); | ||
6169 | + | ||
6170 | err = fastopen_init_queue(sk, val); | ||
6171 | - else | ||
6172 | + } else { | ||
6173 | err = -EINVAL; | ||
6174 | + } | ||
6175 | break; | ||
6176 | case TCP_TIMESTAMP: | ||
6177 | if (!tp->repair) | ||
6178 | diff --git a/net/ipv4/tcp_fastopen.c b/net/ipv4/tcp_fastopen.c | ||
6179 | index c73077280ad4..b01d5bd6d6ca 100644 | ||
6180 | --- a/net/ipv4/tcp_fastopen.c | ||
6181 | +++ b/net/ipv4/tcp_fastopen.c | ||
6182 | @@ -78,8 +78,6 @@ static bool __tcp_fastopen_cookie_gen(const void *path, | ||
6183 | struct tcp_fastopen_context *ctx; | ||
6184 | bool ok = false; | ||
6185 | |||
6186 | - tcp_fastopen_init_key_once(true); | ||
6187 | - | ||
6188 | rcu_read_lock(); | ||
6189 | ctx = rcu_dereference(tcp_fastopen_ctx); | ||
6190 | if (ctx) { | ||
6191 | diff --git a/net/netfilter/core.c b/net/netfilter/core.c | ||
6192 | index 024a2e25c8a4..d047a6679ff2 100644 | ||
6193 | --- a/net/netfilter/core.c | ||
6194 | +++ b/net/netfilter/core.c | ||
6195 | @@ -88,6 +88,7 @@ void nf_unregister_hook(struct nf_hook_ops *reg) | ||
6196 | static_key_slow_dec(&nf_hooks_needed[reg->pf][reg->hooknum]); | ||
6197 | #endif | ||
6198 | synchronize_net(); | ||
6199 | + nf_queue_nf_hook_drop(reg); | ||
6200 | } | ||
6201 | EXPORT_SYMBOL(nf_unregister_hook); | ||
6202 | |||
6203 | diff --git a/net/netfilter/nf_internals.h b/net/netfilter/nf_internals.h | ||
6204 | index 61a3c927e63c..aba1d7dac17c 100644 | ||
6205 | --- a/net/netfilter/nf_internals.h | ||
6206 | +++ b/net/netfilter/nf_internals.h | ||
6207 | @@ -24,6 +24,7 @@ int nf_queue(struct sk_buff *skb, struct nf_hook_ops *elem, u_int8_t pf, | ||
6208 | unsigned int hook, struct net_device *indev, | ||
6209 | struct net_device *outdev, int (*okfn)(struct sk_buff *), | ||
6210 | unsigned int queuenum); | ||
6211 | +void nf_queue_nf_hook_drop(struct nf_hook_ops *ops); | ||
6212 | int __init netfilter_queue_init(void); | ||
6213 | |||
6214 | /* nf_log.c */ | ||
6215 | diff --git a/net/netfilter/nf_queue.c b/net/netfilter/nf_queue.c | ||
6216 | index 4c8b68e5fa16..77ee2d4d5046 100644 | ||
6217 | --- a/net/netfilter/nf_queue.c | ||
6218 | +++ b/net/netfilter/nf_queue.c | ||
6219 | @@ -95,6 +95,23 @@ bool nf_queue_entry_get_refs(struct nf_queue_entry *entry) | ||
6220 | } | ||
6221 | EXPORT_SYMBOL_GPL(nf_queue_entry_get_refs); | ||
6222 | |||
6223 | +void nf_queue_nf_hook_drop(struct nf_hook_ops *ops) | ||
6224 | +{ | ||
6225 | + const struct nf_queue_handler *qh; | ||
6226 | + struct net *net; | ||
6227 | + | ||
6228 | + rtnl_lock(); | ||
6229 | + rcu_read_lock(); | ||
6230 | + qh = rcu_dereference(queue_handler); | ||
6231 | + if (qh) { | ||
6232 | + for_each_net(net) { | ||
6233 | + qh->nf_hook_drop(net, ops); | ||
6234 | + } | ||
6235 | + } | ||
6236 | + rcu_read_unlock(); | ||
6237 | + rtnl_unlock(); | ||
6238 | +} | ||
6239 | + | ||
6240 | /* | ||
6241 | * Any packet that leaves via this function must come back | ||
6242 | * through nf_reinject(). | ||
6243 | diff --git a/net/netfilter/nfnetlink_queue_core.c b/net/netfilter/nfnetlink_queue_core.c | ||
6244 | index 7c60ccd61a3e..8add272654f6 100644 | ||
6245 | --- a/net/netfilter/nfnetlink_queue_core.c | ||
6246 | +++ b/net/netfilter/nfnetlink_queue_core.c | ||
6247 | @@ -815,6 +815,27 @@ static struct notifier_block nfqnl_dev_notifier = { | ||
6248 | .notifier_call = nfqnl_rcv_dev_event, | ||
6249 | }; | ||
6250 | |||
6251 | +static int nf_hook_cmp(struct nf_queue_entry *entry, unsigned long ops_ptr) | ||
6252 | +{ | ||
6253 | + return entry->elem == (struct nf_hook_ops *)ops_ptr; | ||
6254 | +} | ||
6255 | + | ||
6256 | +static void nfqnl_nf_hook_drop(struct net *net, struct nf_hook_ops *hook) | ||
6257 | +{ | ||
6258 | + struct nfnl_queue_net *q = nfnl_queue_pernet(net); | ||
6259 | + int i; | ||
6260 | + | ||
6261 | + rcu_read_lock(); | ||
6262 | + for (i = 0; i < INSTANCE_BUCKETS; i++) { | ||
6263 | + struct nfqnl_instance *inst; | ||
6264 | + struct hlist_head *head = &q->instance_table[i]; | ||
6265 | + | ||
6266 | + hlist_for_each_entry_rcu(inst, head, hlist) | ||
6267 | + nfqnl_flush(inst, nf_hook_cmp, (unsigned long)hook); | ||
6268 | + } | ||
6269 | + rcu_read_unlock(); | ||
6270 | +} | ||
6271 | + | ||
6272 | static int | ||
6273 | nfqnl_rcv_nl_event(struct notifier_block *this, | ||
6274 | unsigned long event, void *ptr) | ||
6275 | @@ -1022,7 +1043,8 @@ static const struct nla_policy nfqa_cfg_policy[NFQA_CFG_MAX+1] = { | ||
6276 | }; | ||
6277 | |||
6278 | static const struct nf_queue_handler nfqh = { | ||
6279 | - .outfn = &nfqnl_enqueue_packet, | ||
6280 | + .outfn = &nfqnl_enqueue_packet, | ||
6281 | + .nf_hook_drop = &nfqnl_nf_hook_drop, | ||
6282 | }; | ||
6283 | |||
6284 | static int | ||
6285 | diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c | ||
6286 | index c0a418766f9c..c82b2e37e652 100644 | ||
6287 | --- a/net/netlink/af_netlink.c | ||
6288 | +++ b/net/netlink/af_netlink.c | ||
6289 | @@ -1003,11 +1003,8 @@ static struct sock *__netlink_lookup(struct netlink_table *table, u32 portid, | ||
6290 | .net = net, | ||
6291 | .portid = portid, | ||
6292 | }; | ||
6293 | - u32 hash; | ||
6294 | |||
6295 | - hash = rhashtable_hashfn(&table->hash, &portid, sizeof(portid)); | ||
6296 | - | ||
6297 | - return rhashtable_lookup_compare(&table->hash, hash, | ||
6298 | + return rhashtable_lookup_compare(&table->hash, &portid, | ||
6299 | &netlink_compare, &arg); | ||
6300 | } | ||
6301 | |||
6302 | diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c | ||
6303 | index 07c04a841ba0..5dcfe05ea232 100644 | ||
6304 | --- a/net/packet/af_packet.c | ||
6305 | +++ b/net/packet/af_packet.c | ||
6306 | @@ -1255,16 +1255,6 @@ static void packet_sock_destruct(struct sock *sk) | ||
6307 | sk_refcnt_debug_dec(sk); | ||
6308 | } | ||
6309 | |||
6310 | -static int fanout_rr_next(struct packet_fanout *f, unsigned int num) | ||
6311 | -{ | ||
6312 | - int x = atomic_read(&f->rr_cur) + 1; | ||
6313 | - | ||
6314 | - if (x >= num) | ||
6315 | - x = 0; | ||
6316 | - | ||
6317 | - return x; | ||
6318 | -} | ||
6319 | - | ||
6320 | static unsigned int fanout_demux_hash(struct packet_fanout *f, | ||
6321 | struct sk_buff *skb, | ||
6322 | unsigned int num) | ||
6323 | @@ -1276,13 +1266,9 @@ static unsigned int fanout_demux_lb(struct packet_fanout *f, | ||
6324 | struct sk_buff *skb, | ||
6325 | unsigned int num) | ||
6326 | { | ||
6327 | - int cur, old; | ||
6328 | + unsigned int val = atomic_inc_return(&f->rr_cur); | ||
6329 | |||
6330 | - cur = atomic_read(&f->rr_cur); | ||
6331 | - while ((old = atomic_cmpxchg(&f->rr_cur, cur, | ||
6332 | - fanout_rr_next(f, num))) != cur) | ||
6333 | - cur = old; | ||
6334 | - return cur; | ||
6335 | + return val % num; | ||
6336 | } | ||
6337 | |||
6338 | static unsigned int fanout_demux_cpu(struct packet_fanout *f, | ||
6339 | @@ -1336,7 +1322,7 @@ static int packet_rcv_fanout(struct sk_buff *skb, struct net_device *dev, | ||
6340 | struct packet_type *pt, struct net_device *orig_dev) | ||
6341 | { | ||
6342 | struct packet_fanout *f = pt->af_packet_priv; | ||
6343 | - unsigned int num = f->num_members; | ||
6344 | + unsigned int num = READ_ONCE(f->num_members); | ||
6345 | struct packet_sock *po; | ||
6346 | unsigned int idx; | ||
6347 | |||
6348 | diff --git a/net/rose/af_rose.c b/net/rose/af_rose.c | ||
6349 | index a85c1a086ae4..67984fb42f14 100644 | ||
6350 | --- a/net/rose/af_rose.c | ||
6351 | +++ b/net/rose/af_rose.c | ||
6352 | @@ -192,7 +192,8 @@ static void rose_kill_by_device(struct net_device *dev) | ||
6353 | |||
6354 | if (rose->device == dev) { | ||
6355 | rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0); | ||
6356 | - rose->neighbour->use--; | ||
6357 | + if (rose->neighbour) | ||
6358 | + rose->neighbour->use--; | ||
6359 | rose->device = NULL; | ||
6360 | } | ||
6361 | } | ||
6362 | diff --git a/net/sctp/output.c b/net/sctp/output.c | ||
6363 | index fc5e45b8a832..abe7c2db2412 100644 | ||
6364 | --- a/net/sctp/output.c | ||
6365 | +++ b/net/sctp/output.c | ||
6366 | @@ -599,7 +599,9 @@ out: | ||
6367 | return err; | ||
6368 | no_route: | ||
6369 | kfree_skb(nskb); | ||
6370 | - IP_INC_STATS(sock_net(asoc->base.sk), IPSTATS_MIB_OUTNOROUTES); | ||
6371 | + | ||
6372 | + if (asoc) | ||
6373 | + IP_INC_STATS(sock_net(asoc->base.sk), IPSTATS_MIB_OUTNOROUTES); | ||
6374 | |||
6375 | /* FIXME: Returning the 'err' will effect all the associations | ||
6376 | * associated with a socket, although only one of the paths of the | ||
6377 | diff --git a/net/sctp/socket.c b/net/sctp/socket.c | ||
6378 | index 634a2abb5f3a..99e640c46ab2 100644 | ||
6379 | --- a/net/sctp/socket.c | ||
6380 | +++ b/net/sctp/socket.c | ||
6381 | @@ -1533,8 +1533,10 @@ static void sctp_close(struct sock *sk, long timeout) | ||
6382 | |||
6383 | /* Supposedly, no process has access to the socket, but | ||
6384 | * the net layers still may. | ||
6385 | + * Also, sctp_destroy_sock() needs to be called with addr_wq_lock | ||
6386 | + * held and that should be grabbed before socket lock. | ||
6387 | */ | ||
6388 | - local_bh_disable(); | ||
6389 | + spin_lock_bh(&net->sctp.addr_wq_lock); | ||
6390 | bh_lock_sock(sk); | ||
6391 | |||
6392 | /* Hold the sock, since sk_common_release() will put sock_put() | ||
6393 | @@ -1544,7 +1546,7 @@ static void sctp_close(struct sock *sk, long timeout) | ||
6394 | sk_common_release(sk); | ||
6395 | |||
6396 | bh_unlock_sock(sk); | ||
6397 | - local_bh_enable(); | ||
6398 | + spin_unlock_bh(&net->sctp.addr_wq_lock); | ||
6399 | |||
6400 | sock_put(sk); | ||
6401 | |||
6402 | @@ -3581,6 +3583,7 @@ static int sctp_setsockopt_auto_asconf(struct sock *sk, char __user *optval, | ||
6403 | if ((val && sp->do_auto_asconf) || (!val && !sp->do_auto_asconf)) | ||
6404 | return 0; | ||
6405 | |||
6406 | + spin_lock_bh(&sock_net(sk)->sctp.addr_wq_lock); | ||
6407 | if (val == 0 && sp->do_auto_asconf) { | ||
6408 | list_del(&sp->auto_asconf_list); | ||
6409 | sp->do_auto_asconf = 0; | ||
6410 | @@ -3589,6 +3592,7 @@ static int sctp_setsockopt_auto_asconf(struct sock *sk, char __user *optval, | ||
6411 | &sock_net(sk)->sctp.auto_asconf_splist); | ||
6412 | sp->do_auto_asconf = 1; | ||
6413 | } | ||
6414 | + spin_unlock_bh(&sock_net(sk)->sctp.addr_wq_lock); | ||
6415 | return 0; | ||
6416 | } | ||
6417 | |||
6418 | @@ -4122,18 +4126,28 @@ static int sctp_init_sock(struct sock *sk) | ||
6419 | local_bh_disable(); | ||
6420 | percpu_counter_inc(&sctp_sockets_allocated); | ||
6421 | sock_prot_inuse_add(net, sk->sk_prot, 1); | ||
6422 | + | ||
6423 | + /* Nothing can fail after this block, otherwise | ||
6424 | + * sctp_destroy_sock() will be called without addr_wq_lock held | ||
6425 | + */ | ||
6426 | if (net->sctp.default_auto_asconf) { | ||
6427 | + spin_lock(&sock_net(sk)->sctp.addr_wq_lock); | ||
6428 | list_add_tail(&sp->auto_asconf_list, | ||
6429 | &net->sctp.auto_asconf_splist); | ||
6430 | sp->do_auto_asconf = 1; | ||
6431 | - } else | ||
6432 | + spin_unlock(&sock_net(sk)->sctp.addr_wq_lock); | ||
6433 | + } else { | ||
6434 | sp->do_auto_asconf = 0; | ||
6435 | + } | ||
6436 | + | ||
6437 | local_bh_enable(); | ||
6438 | |||
6439 | return 0; | ||
6440 | } | ||
6441 | |||
6442 | -/* Cleanup any SCTP per socket resources. */ | ||
6443 | +/* Cleanup any SCTP per socket resources. Must be called with | ||
6444 | + * sock_net(sk)->sctp.addr_wq_lock held if sp->do_auto_asconf is true | ||
6445 | + */ | ||
6446 | static void sctp_destroy_sock(struct sock *sk) | ||
6447 | { | ||
6448 | struct sctp_sock *sp; | ||
6449 | @@ -7201,6 +7215,19 @@ void sctp_copy_sock(struct sock *newsk, struct sock *sk, | ||
6450 | newinet->mc_list = NULL; | ||
6451 | } | ||
6452 | |||
6453 | +static inline void sctp_copy_descendant(struct sock *sk_to, | ||
6454 | + const struct sock *sk_from) | ||
6455 | +{ | ||
6456 | + int ancestor_size = sizeof(struct inet_sock) + | ||
6457 | + sizeof(struct sctp_sock) - | ||
6458 | + offsetof(struct sctp_sock, auto_asconf_list); | ||
6459 | + | ||
6460 | + if (sk_from->sk_family == PF_INET6) | ||
6461 | + ancestor_size += sizeof(struct ipv6_pinfo); | ||
6462 | + | ||
6463 | + __inet_sk_copy_descendant(sk_to, sk_from, ancestor_size); | ||
6464 | +} | ||
6465 | + | ||
6466 | /* Populate the fields of the newsk from the oldsk and migrate the assoc | ||
6467 | * and its messages to the newsk. | ||
6468 | */ | ||
6469 | @@ -7215,7 +7242,6 @@ static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk, | ||
6470 | struct sk_buff *skb, *tmp; | ||
6471 | struct sctp_ulpevent *event; | ||
6472 | struct sctp_bind_hashbucket *head; | ||
6473 | - struct list_head tmplist; | ||
6474 | |||
6475 | /* Migrate socket buffer sizes and all the socket level options to the | ||
6476 | * new socket. | ||
6477 | @@ -7223,12 +7249,7 @@ static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk, | ||
6478 | newsk->sk_sndbuf = oldsk->sk_sndbuf; | ||
6479 | newsk->sk_rcvbuf = oldsk->sk_rcvbuf; | ||
6480 | /* Brute force copy old sctp opt. */ | ||
6481 | - if (oldsp->do_auto_asconf) { | ||
6482 | - memcpy(&tmplist, &newsp->auto_asconf_list, sizeof(tmplist)); | ||
6483 | - inet_sk_copy_descendant(newsk, oldsk); | ||
6484 | - memcpy(&newsp->auto_asconf_list, &tmplist, sizeof(tmplist)); | ||
6485 | - } else | ||
6486 | - inet_sk_copy_descendant(newsk, oldsk); | ||
6487 | + sctp_copy_descendant(newsk, oldsk); | ||
6488 | |||
6489 | /* Restore the ep value that was overwritten with the above structure | ||
6490 | * copy. | ||
6491 | diff --git a/net/socket.c b/net/socket.c | ||
6492 | index cf9ebf10c841..02fc7c8ea9ed 100644 | ||
6493 | --- a/net/socket.c | ||
6494 | +++ b/net/socket.c | ||
6495 | @@ -2017,14 +2017,12 @@ static int ___sys_sendmsg(struct socket *sock, struct msghdr __user *msg, | ||
6496 | int err, ctl_len, total_len; | ||
6497 | |||
6498 | err = -EFAULT; | ||
6499 | - if (MSG_CMSG_COMPAT & flags) { | ||
6500 | - if (get_compat_msghdr(msg_sys, msg_compat)) | ||
6501 | - return -EFAULT; | ||
6502 | - } else { | ||
6503 | + if (MSG_CMSG_COMPAT & flags) | ||
6504 | + err = get_compat_msghdr(msg_sys, msg_compat); | ||
6505 | + else | ||
6506 | err = copy_msghdr_from_user(msg_sys, msg); | ||
6507 | - if (err) | ||
6508 | - return err; | ||
6509 | - } | ||
6510 | + if (err) | ||
6511 | + return err; | ||
6512 | |||
6513 | if (msg_sys->msg_iovlen > UIO_FASTIOV) { | ||
6514 | err = -EMSGSIZE; | ||
6515 | @@ -2229,14 +2227,12 @@ static int ___sys_recvmsg(struct socket *sock, struct msghdr __user *msg, | ||
6516 | struct sockaddr __user *uaddr; | ||
6517 | int __user *uaddr_len; | ||
6518 | |||
6519 | - if (MSG_CMSG_COMPAT & flags) { | ||
6520 | - if (get_compat_msghdr(msg_sys, msg_compat)) | ||
6521 | - return -EFAULT; | ||
6522 | - } else { | ||
6523 | + if (MSG_CMSG_COMPAT & flags) | ||
6524 | + err = get_compat_msghdr(msg_sys, msg_compat); | ||
6525 | + else | ||
6526 | err = copy_msghdr_from_user(msg_sys, msg); | ||
6527 | - if (err) | ||
6528 | - return err; | ||
6529 | - } | ||
6530 | + if (err) | ||
6531 | + return err; | ||
6532 | |||
6533 | if (msg_sys->msg_iovlen > UIO_FASTIOV) { | ||
6534 | err = -EMSGSIZE; | ||
6535 | diff --git a/net/sunrpc/backchannel_rqst.c b/net/sunrpc/backchannel_rqst.c | ||
6536 | index 1bb4d26fbd6b..ca9ff71134f9 100644 | ||
6537 | --- a/net/sunrpc/backchannel_rqst.c | ||
6538 | +++ b/net/sunrpc/backchannel_rqst.c | ||
6539 | @@ -60,7 +60,7 @@ static void xprt_free_allocation(struct rpc_rqst *req) | ||
6540 | |||
6541 | dprintk("RPC: free allocations for req= %p\n", req); | ||
6542 | WARN_ON_ONCE(test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state)); | ||
6543 | - xbufp = &req->rq_private_buf; | ||
6544 | + xbufp = &req->rq_rcv_buf; | ||
6545 | free_page((unsigned long)xbufp->head[0].iov_base); | ||
6546 | xbufp = &req->rq_snd_buf; | ||
6547 | free_page((unsigned long)xbufp->head[0].iov_base); | ||
6548 | diff --git a/net/wireless/wext-compat.c b/net/wireless/wext-compat.c | ||
6549 | index 0f47948c572f..d2c77d5707b2 100644 | ||
6550 | --- a/net/wireless/wext-compat.c | ||
6551 | +++ b/net/wireless/wext-compat.c | ||
6552 | @@ -1333,6 +1333,8 @@ static struct iw_statistics *cfg80211_wireless_stats(struct net_device *dev) | ||
6553 | memcpy(bssid, wdev->current_bss->pub.bssid, ETH_ALEN); | ||
6554 | wdev_unlock(wdev); | ||
6555 | |||
6556 | + memset(&sinfo, 0, sizeof(sinfo)); | ||
6557 | + | ||
6558 | if (rdev_get_station(rdev, dev, bssid, &sinfo)) | ||
6559 | return NULL; | ||
6560 | |||
6561 | diff --git a/security/integrity/ima/ima.h b/security/integrity/ima/ima.h | ||
6562 | index 8ee997dff139..fc56d4dfa954 100644 | ||
6563 | --- a/security/integrity/ima/ima.h | ||
6564 | +++ b/security/integrity/ima/ima.h | ||
6565 | @@ -106,7 +106,7 @@ void ima_add_violation(struct file *file, const unsigned char *filename, | ||
6566 | const char *op, const char *cause); | ||
6567 | int ima_init_crypto(void); | ||
6568 | void ima_putc(struct seq_file *m, void *data, int datalen); | ||
6569 | -void ima_print_digest(struct seq_file *m, u8 *digest, int size); | ||
6570 | +void ima_print_digest(struct seq_file *m, u8 *digest, u32 size); | ||
6571 | struct ima_template_desc *ima_template_desc_current(void); | ||
6572 | int ima_init_template(void); | ||
6573 | |||
6574 | diff --git a/security/integrity/ima/ima_fs.c b/security/integrity/ima/ima_fs.c | ||
6575 | index da92fcc08d15..d30afe461070 100644 | ||
6576 | --- a/security/integrity/ima/ima_fs.c | ||
6577 | +++ b/security/integrity/ima/ima_fs.c | ||
6578 | @@ -186,9 +186,9 @@ static const struct file_operations ima_measurements_ops = { | ||
6579 | .release = seq_release, | ||
6580 | }; | ||
6581 | |||
6582 | -void ima_print_digest(struct seq_file *m, u8 *digest, int size) | ||
6583 | +void ima_print_digest(struct seq_file *m, u8 *digest, u32 size) | ||
6584 | { | ||
6585 | - int i; | ||
6586 | + u32 i; | ||
6587 | |||
6588 | for (i = 0; i < size; i++) | ||
6589 | seq_printf(m, "%02x", *(digest + i)); | ||
6590 | diff --git a/security/integrity/ima/ima_template_lib.c b/security/integrity/ima/ima_template_lib.c | ||
6591 | index 1506f0248572..1eb173ddefd6 100644 | ||
6592 | --- a/security/integrity/ima/ima_template_lib.c | ||
6593 | +++ b/security/integrity/ima/ima_template_lib.c | ||
6594 | @@ -70,7 +70,8 @@ static void ima_show_template_data_ascii(struct seq_file *m, | ||
6595 | enum data_formats datafmt, | ||
6596 | struct ima_field_data *field_data) | ||
6597 | { | ||
6598 | - u8 *buf_ptr = field_data->data, buflen = field_data->len; | ||
6599 | + u8 *buf_ptr = field_data->data; | ||
6600 | + u32 buflen = field_data->len; | ||
6601 | |||
6602 | switch (datafmt) { | ||
6603 | case DATA_FMT_DIGEST_WITH_ALGO: | ||
6604 | diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c | ||
6605 | index e708368d208f..6bd95f95e48f 100644 | ||
6606 | --- a/sound/pci/hda/hda_codec.c | ||
6607 | +++ b/sound/pci/hda/hda_codec.c | ||
6608 | @@ -2140,6 +2140,16 @@ static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps, | ||
6609 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm); | ||
6610 | } | ||
6611 | |||
6612 | +/* meta hook to call each driver's vmaster hook */ | ||
6613 | +static void vmaster_hook(void *private_data, int enabled) | ||
6614 | +{ | ||
6615 | + struct hda_vmaster_mute_hook *hook = private_data; | ||
6616 | + | ||
6617 | + if (hook->mute_mode != HDA_VMUTE_FOLLOW_MASTER) | ||
6618 | + enabled = hook->mute_mode; | ||
6619 | + hook->hook(hook->codec, enabled); | ||
6620 | +} | ||
6621 | + | ||
6622 | /** | ||
6623 | * snd_hda_codec_amp_read - Read AMP value | ||
6624 | * @codec: HD-audio codec | ||
6625 | @@ -2985,9 +2995,9 @@ int snd_hda_add_vmaster_hook(struct hda_codec *codec, | ||
6626 | |||
6627 | if (!hook->hook || !hook->sw_kctl) | ||
6628 | return 0; | ||
6629 | - snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec); | ||
6630 | hook->codec = codec; | ||
6631 | hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER; | ||
6632 | + snd_ctl_add_vmaster_hook(hook->sw_kctl, vmaster_hook, hook); | ||
6633 | if (!expose_enum_ctl) | ||
6634 | return 0; | ||
6635 | kctl = snd_ctl_new1(&vmaster_mute_mode, hook); | ||
6636 | @@ -3010,14 +3020,7 @@ void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook) | ||
6637 | */ | ||
6638 | if (hook->codec->bus->shutdown) | ||
6639 | return; | ||
6640 | - switch (hook->mute_mode) { | ||
6641 | - case HDA_VMUTE_FOLLOW_MASTER: | ||
6642 | - snd_ctl_sync_vmaster_hook(hook->sw_kctl); | ||
6643 | - break; | ||
6644 | - default: | ||
6645 | - hook->hook(hook->codec, hook->mute_mode); | ||
6646 | - break; | ||
6647 | - } | ||
6648 | + snd_ctl_sync_vmaster_hook(hook->sw_kctl); | ||
6649 | } | ||
6650 | EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook); | ||
6651 | |||
6652 | diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c | ||
6653 | index ddfc8a891db4..58f82733c893 100644 | ||
6654 | --- a/sound/pci/hda/hda_intel.c | ||
6655 | +++ b/sound/pci/hda/hda_intel.c | ||
6656 | @@ -2091,6 +2091,8 @@ static const struct pci_device_id azx_ids[] = { | ||
6657 | { PCI_DEVICE(0x1022, 0x780d), | ||
6658 | .driver_data = AZX_DRIVER_GENERIC | AZX_DCAPS_PRESET_ATI_SB }, | ||
6659 | /* ATI HDMI */ | ||
6660 | + { PCI_DEVICE(0x1002, 0x1308), | ||
6661 | + .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS }, | ||
6662 | { PCI_DEVICE(0x1002, 0x793b), | ||
6663 | .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI }, | ||
6664 | { PCI_DEVICE(0x1002, 0x7919), | ||
6665 | @@ -2099,6 +2101,8 @@ static const struct pci_device_id azx_ids[] = { | ||
6666 | .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI }, | ||
6667 | { PCI_DEVICE(0x1002, 0x970f), | ||
6668 | .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI }, | ||
6669 | + { PCI_DEVICE(0x1002, 0x9840), | ||
6670 | + .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS }, | ||
6671 | { PCI_DEVICE(0x1002, 0xaa00), | ||
6672 | .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI }, | ||
6673 | { PCI_DEVICE(0x1002, 0xaa08), | ||
6674 | diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c | ||
6675 | index 1b1e8c68edd6..69c9d377e517 100644 | ||
6676 | --- a/sound/pci/hda/patch_conexant.c | ||
6677 | +++ b/sound/pci/hda/patch_conexant.c | ||
6678 | @@ -973,6 +973,14 @@ static const struct hda_codec_preset snd_hda_preset_conexant[] = { | ||
6679 | .patch = patch_conexant_auto }, | ||
6680 | { .id = 0x14f150b9, .name = "CX20665", | ||
6681 | .patch = patch_conexant_auto }, | ||
6682 | + { .id = 0x14f150f1, .name = "CX20721", | ||
6683 | + .patch = patch_conexant_auto }, | ||
6684 | + { .id = 0x14f150f2, .name = "CX20722", | ||
6685 | + .patch = patch_conexant_auto }, | ||
6686 | + { .id = 0x14f150f3, .name = "CX20723", | ||
6687 | + .patch = patch_conexant_auto }, | ||
6688 | + { .id = 0x14f150f4, .name = "CX20724", | ||
6689 | + .patch = patch_conexant_auto }, | ||
6690 | { .id = 0x14f1510f, .name = "CX20751/2", | ||
6691 | .patch = patch_conexant_auto }, | ||
6692 | { .id = 0x14f15110, .name = "CX20751/2", | ||
6693 | @@ -1007,6 +1015,10 @@ MODULE_ALIAS("snd-hda-codec-id:14f150ab"); | ||
6694 | MODULE_ALIAS("snd-hda-codec-id:14f150ac"); | ||
6695 | MODULE_ALIAS("snd-hda-codec-id:14f150b8"); | ||
6696 | MODULE_ALIAS("snd-hda-codec-id:14f150b9"); | ||
6697 | +MODULE_ALIAS("snd-hda-codec-id:14f150f1"); | ||
6698 | +MODULE_ALIAS("snd-hda-codec-id:14f150f2"); | ||
6699 | +MODULE_ALIAS("snd-hda-codec-id:14f150f3"); | ||
6700 | +MODULE_ALIAS("snd-hda-codec-id:14f150f4"); | ||
6701 | MODULE_ALIAS("snd-hda-codec-id:14f1510f"); | ||
6702 | MODULE_ALIAS("snd-hda-codec-id:14f15110"); | ||
6703 | MODULE_ALIAS("snd-hda-codec-id:14f15111"); | ||
6704 | diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c | ||
6705 | index fca6d06f4bec..24cec17db1a4 100644 | ||
6706 | --- a/sound/pci/hda/patch_realtek.c | ||
6707 | +++ b/sound/pci/hda/patch_realtek.c | ||
6708 | @@ -2165,6 +2165,7 @@ static const struct hda_fixup alc882_fixups[] = { | ||
6709 | static const struct snd_pci_quirk alc882_fixup_tbl[] = { | ||
6710 | SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD), | ||
6711 | SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), | ||
6712 | + SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), | ||
6713 | SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD), | ||
6714 | SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), | ||
6715 | SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD), | ||
6716 | @@ -4375,6 +4376,7 @@ enum { | ||
6717 | ALC269_FIXUP_LIFEBOOK, | ||
6718 | ALC269_FIXUP_LIFEBOOK_EXTMIC, | ||
6719 | ALC269_FIXUP_LIFEBOOK_HP_PIN, | ||
6720 | + ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT, | ||
6721 | ALC269_FIXUP_AMIC, | ||
6722 | ALC269_FIXUP_DMIC, | ||
6723 | ALC269VB_FIXUP_AMIC, | ||
6724 | @@ -4395,6 +4397,7 @@ enum { | ||
6725 | ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, | ||
6726 | ALC269_FIXUP_HEADSET_MODE, | ||
6727 | ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, | ||
6728 | + ALC269_FIXUP_ASPIRE_HEADSET_MIC, | ||
6729 | ALC269_FIXUP_ASUS_X101_FUNC, | ||
6730 | ALC269_FIXUP_ASUS_X101_VERB, | ||
6731 | ALC269_FIXUP_ASUS_X101, | ||
6732 | @@ -4422,6 +4425,7 @@ enum { | ||
6733 | ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC, | ||
6734 | ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, | ||
6735 | ALC292_FIXUP_TPT440_DOCK, | ||
6736 | + ALC292_FIXUP_TPT440_DOCK2, | ||
6737 | ALC283_FIXUP_BXBT2807_MIC, | ||
6738 | ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED, | ||
6739 | ALC282_FIXUP_ASPIRE_V5_PINS, | ||
6740 | @@ -4532,6 +4536,10 @@ static const struct hda_fixup alc269_fixups[] = { | ||
6741 | { } | ||
6742 | }, | ||
6743 | }, | ||
6744 | + [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = { | ||
6745 | + .type = HDA_FIXUP_FUNC, | ||
6746 | + .v.func = alc269_fixup_pincfg_no_hp_to_lineout, | ||
6747 | + }, | ||
6748 | [ALC269_FIXUP_AMIC] = { | ||
6749 | .type = HDA_FIXUP_PINS, | ||
6750 | .v.pins = (const struct hda_pintbl[]) { | ||
6751 | @@ -4660,6 +4668,15 @@ static const struct hda_fixup alc269_fixups[] = { | ||
6752 | .type = HDA_FIXUP_FUNC, | ||
6753 | .v.func = alc_fixup_headset_mode_no_hp_mic, | ||
6754 | }, | ||
6755 | + [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = { | ||
6756 | + .type = HDA_FIXUP_PINS, | ||
6757 | + .v.pins = (const struct hda_pintbl[]) { | ||
6758 | + { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */ | ||
6759 | + { } | ||
6760 | + }, | ||
6761 | + .chained = true, | ||
6762 | + .chain_id = ALC269_FIXUP_HEADSET_MODE, | ||
6763 | + }, | ||
6764 | [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = { | ||
6765 | .type = HDA_FIXUP_PINS, | ||
6766 | .v.pins = (const struct hda_pintbl[]) { | ||
6767 | @@ -4862,6 +4879,12 @@ static const struct hda_fixup alc269_fixups[] = { | ||
6768 | .chain_id = ALC269_FIXUP_HEADSET_MODE | ||
6769 | }, | ||
6770 | [ALC292_FIXUP_TPT440_DOCK] = { | ||
6771 | + .type = HDA_FIXUP_FUNC, | ||
6772 | + .v.func = alc269_fixup_pincfg_no_hp_to_lineout, | ||
6773 | + .chained = true, | ||
6774 | + .chain_id = ALC292_FIXUP_TPT440_DOCK2 | ||
6775 | + }, | ||
6776 | + [ALC292_FIXUP_TPT440_DOCK2] = { | ||
6777 | .type = HDA_FIXUP_PINS, | ||
6778 | .v.pins = (const struct hda_pintbl[]) { | ||
6779 | { 0x16, 0x21211010 }, /* dock headphone */ | ||
6780 | @@ -4909,6 +4932,8 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { | ||
6781 | SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC), | ||
6782 | SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC), | ||
6783 | SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700), | ||
6784 | + SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC), | ||
6785 | + SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC), | ||
6786 | SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK), | ||
6787 | SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK), | ||
6788 | SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), | ||
6789 | @@ -5002,6 +5027,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { | ||
6790 | SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), | ||
6791 | SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX), | ||
6792 | SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK), | ||
6793 | + SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT), | ||
6794 | SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN), | ||
6795 | SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN), | ||
6796 | SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC), | ||
6797 | diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c | ||
6798 | index 87eff3173ce9..60b3100a2120 100644 | ||
6799 | --- a/sound/pci/hda/patch_sigmatel.c | ||
6800 | +++ b/sound/pci/hda/patch_sigmatel.c | ||
6801 | @@ -100,6 +100,7 @@ enum { | ||
6802 | STAC_HP_ENVY_BASS, | ||
6803 | STAC_HP_BNB13_EQ, | ||
6804 | STAC_HP_ENVY_TS_BASS, | ||
6805 | + STAC_HP_ENVY_TS_DAC_BIND, | ||
6806 | STAC_92HD83XXX_GPIO10_EAPD, | ||
6807 | STAC_92HD83XXX_MODELS | ||
6808 | }; | ||
6809 | @@ -2170,6 +2171,22 @@ static void stac92hd83xxx_fixup_gpio10_eapd(struct hda_codec *codec, | ||
6810 | spec->eapd_switch = 0; | ||
6811 | } | ||
6812 | |||
6813 | +static void hp_envy_ts_fixup_dac_bind(struct hda_codec *codec, | ||
6814 | + const struct hda_fixup *fix, | ||
6815 | + int action) | ||
6816 | +{ | ||
6817 | + struct sigmatel_spec *spec = codec->spec; | ||
6818 | + static hda_nid_t preferred_pairs[] = { | ||
6819 | + 0xd, 0x13, | ||
6820 | + 0 | ||
6821 | + }; | ||
6822 | + | ||
6823 | + if (action != HDA_FIXUP_ACT_PRE_PROBE) | ||
6824 | + return; | ||
6825 | + | ||
6826 | + spec->gen.preferred_dacs = preferred_pairs; | ||
6827 | +} | ||
6828 | + | ||
6829 | static const struct hda_verb hp_bnb13_eq_verbs[] = { | ||
6830 | /* 44.1KHz base */ | ||
6831 | { 0x22, 0x7A6, 0x3E }, | ||
6832 | @@ -2685,6 +2702,12 @@ static const struct hda_fixup stac92hd83xxx_fixups[] = { | ||
6833 | {} | ||
6834 | }, | ||
6835 | }, | ||
6836 | + [STAC_HP_ENVY_TS_DAC_BIND] = { | ||
6837 | + .type = HDA_FIXUP_FUNC, | ||
6838 | + .v.func = hp_envy_ts_fixup_dac_bind, | ||
6839 | + .chained = true, | ||
6840 | + .chain_id = STAC_HP_ENVY_TS_BASS, | ||
6841 | + }, | ||
6842 | [STAC_92HD83XXX_GPIO10_EAPD] = { | ||
6843 | .type = HDA_FIXUP_FUNC, | ||
6844 | .v.func = stac92hd83xxx_fixup_gpio10_eapd, | ||
6845 | @@ -2763,6 +2786,8 @@ static const struct snd_pci_quirk stac92hd83xxx_fixup_tbl[] = { | ||
6846 | "HP bNB13", STAC_HP_BNB13_EQ), | ||
6847 | SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x190e, | ||
6848 | "HP ENVY TS", STAC_HP_ENVY_TS_BASS), | ||
6849 | + SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1967, | ||
6850 | + "HP ENVY TS", STAC_HP_ENVY_TS_DAC_BIND), | ||
6851 | SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1940, | ||
6852 | "HP bNB13", STAC_HP_BNB13_EQ), | ||
6853 | SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1941, | ||
6854 | diff --git a/sound/soc/codecs/tas2552.c b/sound/soc/codecs/tas2552.c | ||
6855 | index f039dc825971..6dbfc4703a3a 100644 | ||
6856 | --- a/sound/soc/codecs/tas2552.c | ||
6857 | +++ b/sound/soc/codecs/tas2552.c | ||
6858 | @@ -120,6 +120,9 @@ static void tas2552_sw_shutdown(struct tas2552_data *tas_data, int sw_shutdown) | ||
6859 | { | ||
6860 | u8 cfg1_reg; | ||
6861 | |||
6862 | + if (!tas_data->codec) | ||
6863 | + return; | ||
6864 | + | ||
6865 | if (sw_shutdown) | ||
6866 | cfg1_reg = 0; | ||
6867 | else | ||
6868 | @@ -335,7 +338,6 @@ static DECLARE_TLV_DB_SCALE(dac_tlv, -7, 100, 24); | ||
6869 | static const struct snd_kcontrol_new tas2552_snd_controls[] = { | ||
6870 | SOC_SINGLE_TLV("Speaker Driver Playback Volume", | ||
6871 | TAS2552_PGA_GAIN, 0, 0x1f, 1, dac_tlv), | ||
6872 | - SOC_DAPM_SINGLE("Playback AMP", SND_SOC_NOPM, 0, 1, 0), | ||
6873 | }; | ||
6874 | |||
6875 | static const struct reg_default tas2552_init_regs[] = { | ||
6876 | diff --git a/sound/soc/codecs/wm5102.c b/sound/soc/codecs/wm5102.c | ||
6877 | index f60234962527..8fafff5fad4b 100644 | ||
6878 | --- a/sound/soc/codecs/wm5102.c | ||
6879 | +++ b/sound/soc/codecs/wm5102.c | ||
6880 | @@ -41,7 +41,7 @@ struct wm5102_priv { | ||
6881 | static DECLARE_TLV_DB_SCALE(ana_tlv, 0, 100, 0); | ||
6882 | static DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0); | ||
6883 | static DECLARE_TLV_DB_SCALE(digital_tlv, -6400, 50, 0); | ||
6884 | -static DECLARE_TLV_DB_SCALE(noise_tlv, 0, 600, 0); | ||
6885 | +static DECLARE_TLV_DB_SCALE(noise_tlv, -13200, 600, 0); | ||
6886 | static DECLARE_TLV_DB_SCALE(ng_tlv, -10200, 600, 0); | ||
6887 | |||
6888 | static const struct wm_adsp_region wm5102_dsp1_regions[] = { | ||
6889 | diff --git a/sound/soc/codecs/wm5110.c b/sound/soc/codecs/wm5110.c | ||
6890 | index 2f2ec26d831c..4cab08b43a53 100644 | ||
6891 | --- a/sound/soc/codecs/wm5110.c | ||
6892 | +++ b/sound/soc/codecs/wm5110.c | ||
6893 | @@ -167,7 +167,7 @@ static int wm5110_sysclk_ev(struct snd_soc_dapm_widget *w, | ||
6894 | static DECLARE_TLV_DB_SCALE(ana_tlv, 0, 100, 0); | ||
6895 | static DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0); | ||
6896 | static DECLARE_TLV_DB_SCALE(digital_tlv, -6400, 50, 0); | ||
6897 | -static DECLARE_TLV_DB_SCALE(noise_tlv, 0, 600, 0); | ||
6898 | +static DECLARE_TLV_DB_SCALE(noise_tlv, -13200, 600, 0); | ||
6899 | static DECLARE_TLV_DB_SCALE(ng_tlv, -10200, 600, 0); | ||
6900 | |||
6901 | #define WM5110_NG_SRC(name, base) \ | ||
6902 | diff --git a/sound/soc/codecs/wm8737.c b/sound/soc/codecs/wm8737.c | ||
6903 | index 744a422ecb05..4be874c9dc91 100644 | ||
6904 | --- a/sound/soc/codecs/wm8737.c | ||
6905 | +++ b/sound/soc/codecs/wm8737.c | ||
6906 | @@ -494,7 +494,8 @@ static int wm8737_set_bias_level(struct snd_soc_codec *codec, | ||
6907 | |||
6908 | /* Fast VMID ramp at 2*2.5k */ | ||
6909 | snd_soc_update_bits(codec, WM8737_MISC_BIAS_CONTROL, | ||
6910 | - WM8737_VMIDSEL_MASK, 0x4); | ||
6911 | + WM8737_VMIDSEL_MASK, | ||
6912 | + 2 << WM8737_VMIDSEL_SHIFT); | ||
6913 | |||
6914 | /* Bring VMID up */ | ||
6915 | snd_soc_update_bits(codec, WM8737_POWER_MANAGEMENT, | ||
6916 | @@ -508,7 +509,8 @@ static int wm8737_set_bias_level(struct snd_soc_codec *codec, | ||
6917 | |||
6918 | /* VMID at 2*300k */ | ||
6919 | snd_soc_update_bits(codec, WM8737_MISC_BIAS_CONTROL, | ||
6920 | - WM8737_VMIDSEL_MASK, 2); | ||
6921 | + WM8737_VMIDSEL_MASK, | ||
6922 | + 1 << WM8737_VMIDSEL_SHIFT); | ||
6923 | |||
6924 | break; | ||
6925 | |||
6926 | diff --git a/sound/soc/codecs/wm8903.h b/sound/soc/codecs/wm8903.h | ||
6927 | index db949311c0f2..0bb4a647755d 100644 | ||
6928 | --- a/sound/soc/codecs/wm8903.h | ||
6929 | +++ b/sound/soc/codecs/wm8903.h | ||
6930 | @@ -172,7 +172,7 @@ extern int wm8903_mic_detect(struct snd_soc_codec *codec, | ||
6931 | #define WM8903_VMID_BUF_ENA_WIDTH 1 /* VMID_BUF_ENA */ | ||
6932 | |||
6933 | #define WM8903_VMID_RES_50K 2 | ||
6934 | -#define WM8903_VMID_RES_250K 3 | ||
6935 | +#define WM8903_VMID_RES_250K 4 | ||
6936 | #define WM8903_VMID_RES_5K 6 | ||
6937 | |||
6938 | /* | ||
6939 | diff --git a/sound/soc/codecs/wm8955.c b/sound/soc/codecs/wm8955.c | ||
6940 | index 7d0b01bcab4b..d48ac712f624 100644 | ||
6941 | --- a/sound/soc/codecs/wm8955.c | ||
6942 | +++ b/sound/soc/codecs/wm8955.c | ||
6943 | @@ -298,7 +298,7 @@ static int wm8955_configure_clocking(struct snd_soc_codec *codec) | ||
6944 | snd_soc_update_bits(codec, WM8955_PLL_CONTROL_2, | ||
6945 | WM8955_K_17_9_MASK, | ||
6946 | (pll.k >> 9) & WM8955_K_17_9_MASK); | ||
6947 | - snd_soc_update_bits(codec, WM8955_PLL_CONTROL_2, | ||
6948 | + snd_soc_update_bits(codec, WM8955_PLL_CONTROL_3, | ||
6949 | WM8955_K_8_0_MASK, | ||
6950 | pll.k & WM8955_K_8_0_MASK); | ||
6951 | if (pll.k) | ||
6952 | diff --git a/sound/soc/codecs/wm8960.c b/sound/soc/codecs/wm8960.c | ||
6953 | index 34a18a910113..ab7fa7c9fa84 100644 | ||
6954 | --- a/sound/soc/codecs/wm8960.c | ||
6955 | +++ b/sound/soc/codecs/wm8960.c | ||
6956 | @@ -242,7 +242,7 @@ SOC_SINGLE("PCM Playback -6dB Switch", WM8960_DACCTL1, 7, 1, 0), | ||
6957 | SOC_ENUM("ADC Polarity", wm8960_enum[0]), | ||
6958 | SOC_SINGLE("ADC High Pass Filter Switch", WM8960_DACCTL1, 0, 1, 0), | ||
6959 | |||
6960 | -SOC_ENUM("DAC Polarity", wm8960_enum[2]), | ||
6961 | +SOC_ENUM("DAC Polarity", wm8960_enum[1]), | ||
6962 | SOC_SINGLE_BOOL_EXT("DAC Deemphasis Switch", 0, | ||
6963 | wm8960_get_deemph, wm8960_put_deemph), | ||
6964 | |||
6965 | diff --git a/sound/soc/codecs/wm8997.c b/sound/soc/codecs/wm8997.c | ||
6966 | index ab33fe596519..dd1842527b30 100644 | ||
6967 | --- a/sound/soc/codecs/wm8997.c | ||
6968 | +++ b/sound/soc/codecs/wm8997.c | ||
6969 | @@ -40,7 +40,7 @@ struct wm8997_priv { | ||
6970 | static DECLARE_TLV_DB_SCALE(ana_tlv, 0, 100, 0); | ||
6971 | static DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0); | ||
6972 | static DECLARE_TLV_DB_SCALE(digital_tlv, -6400, 50, 0); | ||
6973 | -static DECLARE_TLV_DB_SCALE(noise_tlv, 0, 600, 0); | ||
6974 | +static DECLARE_TLV_DB_SCALE(noise_tlv, -13200, 600, 0); | ||
6975 | static DECLARE_TLV_DB_SCALE(ng_tlv, -10200, 600, 0); | ||
6976 | |||
6977 | static const struct reg_default wm8997_sysclk_reva_patch[] = { | ||
6978 | diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c | ||
6979 | index a712d754431c..b4edae1d4f5d 100644 | ||
6980 | --- a/sound/usb/mixer.c | ||
6981 | +++ b/sound/usb/mixer.c | ||
6982 | @@ -914,6 +914,7 @@ static void volume_control_quirks(struct usb_mixer_elem_info *cval, | ||
6983 | case USB_ID(0x046d, 0x081d): /* HD Webcam c510 */ | ||
6984 | case USB_ID(0x046d, 0x0825): /* HD Webcam c270 */ | ||
6985 | case USB_ID(0x046d, 0x0826): /* HD Webcam c525 */ | ||
6986 | + case USB_ID(0x046d, 0x08ca): /* Logitech Quickcam Fusion */ | ||
6987 | case USB_ID(0x046d, 0x0991): | ||
6988 | /* Most audio usb devices lie about volume resolution. | ||
6989 | * Most Logitech webcams have res = 384. | ||
6990 | diff --git a/sound/usb/mixer_maps.c b/sound/usb/mixer_maps.c | ||
6991 | index 621bc9ebb55e..b16be3944213 100644 | ||
6992 | --- a/sound/usb/mixer_maps.c | ||
6993 | +++ b/sound/usb/mixer_maps.c | ||
6994 | @@ -428,6 +428,11 @@ static struct usbmix_ctl_map usbmix_ctl_maps[] = { | ||
6995 | .map = ebox44_map, | ||
6996 | }, | ||
6997 | { | ||
6998 | + /* MAYA44 USB+ */ | ||
6999 | + .id = USB_ID(0x2573, 0x0008), | ||
7000 | + .map = maya44_map, | ||
7001 | + }, | ||
7002 | + { | ||
7003 | /* KEF X300A */ | ||
7004 | .id = USB_ID(0x27ac, 0x1000), | ||
7005 | .map = scms_usb3318_map, | ||
7006 | diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c | ||
7007 | index 05ad944dc5c8..9ff5050d513a 100644 | ||
7008 | --- a/sound/usb/quirks.c | ||
7009 | +++ b/sound/usb/quirks.c | ||
7010 | @@ -1257,8 +1257,9 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, | ||
7011 | if (fp->altsetting == 2) | ||
7012 | return SNDRV_PCM_FMTBIT_DSD_U32_BE; | ||
7013 | break; | ||
7014 | - /* DIYINHK DSD DXD 384kHz USB to I2S/DSD */ | ||
7015 | - case USB_ID(0x20b1, 0x2009): | ||
7016 | + | ||
7017 | + case USB_ID(0x20b1, 0x2009): /* DIYINHK DSD DXD 384kHz USB to I2S/DSD */ | ||
7018 | + case USB_ID(0x20b1, 0x2023): /* JLsounds I2SoverUSB */ | ||
7019 | if (fp->altsetting == 3) | ||
7020 | return SNDRV_PCM_FMTBIT_DSD_U32_BE; | ||
7021 | break; | ||
7022 | diff --git a/virt/kvm/arm/vgic.c b/virt/kvm/arm/vgic.c | ||
7023 | index 5f67fadfca65..d7cf2ffc56e9 100644 | ||
7024 | --- a/virt/kvm/arm/vgic.c | ||
7025 | +++ b/virt/kvm/arm/vgic.c | ||
7026 | @@ -1721,7 +1721,7 @@ int kvm_vgic_inject_irq(struct kvm *kvm, int cpuid, unsigned int irq_num, | ||
7027 | goto out; | ||
7028 | } | ||
7029 | |||
7030 | - if (irq_num >= kvm->arch.vgic.nr_irqs) | ||
7031 | + if (irq_num >= min(kvm->arch.vgic.nr_irqs, 1020)) | ||
7032 | return -EINVAL; | ||
7033 | |||
7034 | vcpu_id = vgic_update_irq_pending(kvm, cpuid, irq_num, level); |