Contents of /trunk/kernel-magellan/patches-4.17/0101-4.17.2-all-fixes.patch
Parent Directory | Revision Log
Revision 3135 -
(show annotations)
(download)
Mon Jun 18 09:23:45 2018 UTC (6 years, 3 months ago) by niro
File size: 100377 byte(s)
Mon Jun 18 09:23:45 2018 UTC (6 years, 3 months ago) by niro
File size: 100377 byte(s)
-linux-4.17.2
1 | diff --git a/Documentation/ABI/stable/sysfs-bus-vmbus b/Documentation/ABI/stable/sysfs-bus-vmbus |
2 | index 0c9d9dcd2151..3eaffbb2d468 100644 |
3 | --- a/Documentation/ABI/stable/sysfs-bus-vmbus |
4 | +++ b/Documentation/ABI/stable/sysfs-bus-vmbus |
5 | @@ -1,25 +1,25 @@ |
6 | -What: /sys/bus/vmbus/devices/vmbus_*/id |
7 | +What: /sys/bus/vmbus/devices/<UUID>/id |
8 | Date: Jul 2009 |
9 | KernelVersion: 2.6.31 |
10 | Contact: K. Y. Srinivasan <kys@microsoft.com> |
11 | Description: The VMBus child_relid of the device's primary channel |
12 | Users: tools/hv/lsvmbus |
13 | |
14 | -What: /sys/bus/vmbus/devices/vmbus_*/class_id |
15 | +What: /sys/bus/vmbus/devices/<UUID>/class_id |
16 | Date: Jul 2009 |
17 | KernelVersion: 2.6.31 |
18 | Contact: K. Y. Srinivasan <kys@microsoft.com> |
19 | Description: The VMBus interface type GUID of the device |
20 | Users: tools/hv/lsvmbus |
21 | |
22 | -What: /sys/bus/vmbus/devices/vmbus_*/device_id |
23 | +What: /sys/bus/vmbus/devices/<UUID>/device_id |
24 | Date: Jul 2009 |
25 | KernelVersion: 2.6.31 |
26 | Contact: K. Y. Srinivasan <kys@microsoft.com> |
27 | Description: The VMBus interface instance GUID of the device |
28 | Users: tools/hv/lsvmbus |
29 | |
30 | -What: /sys/bus/vmbus/devices/vmbus_*/channel_vp_mapping |
31 | +What: /sys/bus/vmbus/devices/<UUID>/channel_vp_mapping |
32 | Date: Jul 2015 |
33 | KernelVersion: 4.2.0 |
34 | Contact: K. Y. Srinivasan <kys@microsoft.com> |
35 | @@ -28,112 +28,112 @@ Description: The mapping of which primary/sub channels are bound to which |
36 | Format: <channel's child_relid:the bound cpu's number> |
37 | Users: tools/hv/lsvmbus |
38 | |
39 | -What: /sys/bus/vmbus/devices/vmbus_*/device |
40 | +What: /sys/bus/vmbus/devices/<UUID>/device |
41 | Date: Dec. 2015 |
42 | KernelVersion: 4.5 |
43 | Contact: K. Y. Srinivasan <kys@microsoft.com> |
44 | Description: The 16 bit device ID of the device |
45 | Users: tools/hv/lsvmbus and user level RDMA libraries |
46 | |
47 | -What: /sys/bus/vmbus/devices/vmbus_*/vendor |
48 | +What: /sys/bus/vmbus/devices/<UUID>/vendor |
49 | Date: Dec. 2015 |
50 | KernelVersion: 4.5 |
51 | Contact: K. Y. Srinivasan <kys@microsoft.com> |
52 | Description: The 16 bit vendor ID of the device |
53 | Users: tools/hv/lsvmbus and user level RDMA libraries |
54 | |
55 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN |
56 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N> |
57 | Date: September. 2017 |
58 | KernelVersion: 4.14 |
59 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
60 | Description: Directory for per-channel information |
61 | NN is the VMBUS relid associtated with the channel. |
62 | |
63 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/cpu |
64 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/cpu |
65 | Date: September. 2017 |
66 | KernelVersion: 4.14 |
67 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
68 | Description: VCPU (sub)channel is affinitized to |
69 | Users: tools/hv/lsvmbus and other debugging tools |
70 | |
71 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/cpu |
72 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/cpu |
73 | Date: September. 2017 |
74 | KernelVersion: 4.14 |
75 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
76 | Description: VCPU (sub)channel is affinitized to |
77 | Users: tools/hv/lsvmbus and other debugging tools |
78 | |
79 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/in_mask |
80 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/in_mask |
81 | Date: September. 2017 |
82 | KernelVersion: 4.14 |
83 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
84 | Description: Host to guest channel interrupt mask |
85 | Users: Debugging tools |
86 | |
87 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/latency |
88 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/latency |
89 | Date: September. 2017 |
90 | KernelVersion: 4.14 |
91 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
92 | Description: Channel signaling latency |
93 | Users: Debugging tools |
94 | |
95 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/out_mask |
96 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/out_mask |
97 | Date: September. 2017 |
98 | KernelVersion: 4.14 |
99 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
100 | Description: Guest to host channel interrupt mask |
101 | Users: Debugging tools |
102 | |
103 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/pending |
104 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/pending |
105 | Date: September. 2017 |
106 | KernelVersion: 4.14 |
107 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
108 | Description: Channel interrupt pending state |
109 | Users: Debugging tools |
110 | |
111 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/read_avail |
112 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/read_avail |
113 | Date: September. 2017 |
114 | KernelVersion: 4.14 |
115 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
116 | Description: Bytes available to read |
117 | Users: Debugging tools |
118 | |
119 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/write_avail |
120 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/write_avail |
121 | Date: September. 2017 |
122 | KernelVersion: 4.14 |
123 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
124 | Description: Bytes available to write |
125 | Users: Debugging tools |
126 | |
127 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/events |
128 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/events |
129 | Date: September. 2017 |
130 | KernelVersion: 4.14 |
131 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
132 | Description: Number of times we have signaled the host |
133 | Users: Debugging tools |
134 | |
135 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/interrupts |
136 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/interrupts |
137 | Date: September. 2017 |
138 | KernelVersion: 4.14 |
139 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
140 | Description: Number of times we have taken an interrupt (incoming) |
141 | Users: Debugging tools |
142 | |
143 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/subchannel_id |
144 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/subchannel_id |
145 | Date: January. 2018 |
146 | KernelVersion: 4.16 |
147 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
148 | Description: Subchannel ID associated with VMBUS channel |
149 | Users: Debugging tools and userspace drivers |
150 | |
151 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/monitor_id |
152 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/monitor_id |
153 | Date: January. 2018 |
154 | KernelVersion: 4.16 |
155 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
156 | Description: Monitor bit associated with channel |
157 | Users: Debugging tools and userspace drivers |
158 | |
159 | -What: /sys/bus/vmbus/devices/vmbus_*/channels/NN/ring |
160 | +What: /sys/bus/vmbus/devices/<UUID>/channels/<N>/ring |
161 | Date: January. 2018 |
162 | KernelVersion: 4.16 |
163 | Contact: Stephen Hemminger <sthemmin@microsoft.com> |
164 | diff --git a/Makefile b/Makefile |
165 | index e551c9af6a06..f43cd522b175 100644 |
166 | --- a/Makefile |
167 | +++ b/Makefile |
168 | @@ -1,7 +1,7 @@ |
169 | # SPDX-License-Identifier: GPL-2.0 |
170 | VERSION = 4 |
171 | PATCHLEVEL = 17 |
172 | -SUBLEVEL = 1 |
173 | +SUBLEVEL = 2 |
174 | EXTRAVERSION = |
175 | NAME = Merciless Moray |
176 | |
177 | diff --git a/arch/arm64/configs/defconfig b/arch/arm64/configs/defconfig |
178 | index ecf613761e78..fe005df02ed3 100644 |
179 | --- a/arch/arm64/configs/defconfig |
180 | +++ b/arch/arm64/configs/defconfig |
181 | @@ -320,6 +320,7 @@ CONFIG_PINCTRL_MAX77620=y |
182 | CONFIG_PINCTRL_MSM8916=y |
183 | CONFIG_PINCTRL_MSM8994=y |
184 | CONFIG_PINCTRL_MSM8996=y |
185 | +CONFIG_PINCTRL_MT7622=y |
186 | CONFIG_PINCTRL_QDF2XXX=y |
187 | CONFIG_PINCTRL_QCOM_SPMI_PMIC=y |
188 | CONFIG_GPIO_DWAPB=y |
189 | diff --git a/arch/x86/include/asm/kvm_emulate.h b/arch/x86/include/asm/kvm_emulate.h |
190 | index b24b1c8b3979..0f82cd91cd3c 100644 |
191 | --- a/arch/x86/include/asm/kvm_emulate.h |
192 | +++ b/arch/x86/include/asm/kvm_emulate.h |
193 | @@ -107,11 +107,12 @@ struct x86_emulate_ops { |
194 | * @addr: [IN ] Linear address from which to read. |
195 | * @val: [OUT] Value read from memory, zero-extended to 'u_long'. |
196 | * @bytes: [IN ] Number of bytes to read from memory. |
197 | + * @system:[IN ] Whether the access is forced to be at CPL0. |
198 | */ |
199 | int (*read_std)(struct x86_emulate_ctxt *ctxt, |
200 | unsigned long addr, void *val, |
201 | unsigned int bytes, |
202 | - struct x86_exception *fault); |
203 | + struct x86_exception *fault, bool system); |
204 | |
205 | /* |
206 | * read_phys: Read bytes of standard (non-emulated/special) memory. |
207 | @@ -129,10 +130,11 @@ struct x86_emulate_ops { |
208 | * @addr: [IN ] Linear address to which to write. |
209 | * @val: [OUT] Value write to memory, zero-extended to 'u_long'. |
210 | * @bytes: [IN ] Number of bytes to write to memory. |
211 | + * @system:[IN ] Whether the access is forced to be at CPL0. |
212 | */ |
213 | int (*write_std)(struct x86_emulate_ctxt *ctxt, |
214 | unsigned long addr, void *val, unsigned int bytes, |
215 | - struct x86_exception *fault); |
216 | + struct x86_exception *fault, bool system); |
217 | /* |
218 | * fetch: Read bytes of standard (non-emulated/special) memory. |
219 | * Used for instruction fetch. |
220 | diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c |
221 | index b3705ae52824..4c4f4263420c 100644 |
222 | --- a/arch/x86/kvm/emulate.c |
223 | +++ b/arch/x86/kvm/emulate.c |
224 | @@ -812,6 +812,19 @@ static inline int jmp_rel(struct x86_emulate_ctxt *ctxt, int rel) |
225 | return assign_eip_near(ctxt, ctxt->_eip + rel); |
226 | } |
227 | |
228 | +static int linear_read_system(struct x86_emulate_ctxt *ctxt, ulong linear, |
229 | + void *data, unsigned size) |
230 | +{ |
231 | + return ctxt->ops->read_std(ctxt, linear, data, size, &ctxt->exception, true); |
232 | +} |
233 | + |
234 | +static int linear_write_system(struct x86_emulate_ctxt *ctxt, |
235 | + ulong linear, void *data, |
236 | + unsigned int size) |
237 | +{ |
238 | + return ctxt->ops->write_std(ctxt, linear, data, size, &ctxt->exception, true); |
239 | +} |
240 | + |
241 | static int segmented_read_std(struct x86_emulate_ctxt *ctxt, |
242 | struct segmented_address addr, |
243 | void *data, |
244 | @@ -823,7 +836,7 @@ static int segmented_read_std(struct x86_emulate_ctxt *ctxt, |
245 | rc = linearize(ctxt, addr, size, false, &linear); |
246 | if (rc != X86EMUL_CONTINUE) |
247 | return rc; |
248 | - return ctxt->ops->read_std(ctxt, linear, data, size, &ctxt->exception); |
249 | + return ctxt->ops->read_std(ctxt, linear, data, size, &ctxt->exception, false); |
250 | } |
251 | |
252 | static int segmented_write_std(struct x86_emulate_ctxt *ctxt, |
253 | @@ -837,7 +850,7 @@ static int segmented_write_std(struct x86_emulate_ctxt *ctxt, |
254 | rc = linearize(ctxt, addr, size, true, &linear); |
255 | if (rc != X86EMUL_CONTINUE) |
256 | return rc; |
257 | - return ctxt->ops->write_std(ctxt, linear, data, size, &ctxt->exception); |
258 | + return ctxt->ops->write_std(ctxt, linear, data, size, &ctxt->exception, false); |
259 | } |
260 | |
261 | /* |
262 | @@ -1496,8 +1509,7 @@ static int read_interrupt_descriptor(struct x86_emulate_ctxt *ctxt, |
263 | return emulate_gp(ctxt, index << 3 | 0x2); |
264 | |
265 | addr = dt.address + index * 8; |
266 | - return ctxt->ops->read_std(ctxt, addr, desc, sizeof *desc, |
267 | - &ctxt->exception); |
268 | + return linear_read_system(ctxt, addr, desc, sizeof *desc); |
269 | } |
270 | |
271 | static void get_descriptor_table_ptr(struct x86_emulate_ctxt *ctxt, |
272 | @@ -1560,8 +1572,7 @@ static int read_segment_descriptor(struct x86_emulate_ctxt *ctxt, |
273 | if (rc != X86EMUL_CONTINUE) |
274 | return rc; |
275 | |
276 | - return ctxt->ops->read_std(ctxt, *desc_addr_p, desc, sizeof(*desc), |
277 | - &ctxt->exception); |
278 | + return linear_read_system(ctxt, *desc_addr_p, desc, sizeof(*desc)); |
279 | } |
280 | |
281 | /* allowed just for 8 bytes segments */ |
282 | @@ -1575,8 +1586,7 @@ static int write_segment_descriptor(struct x86_emulate_ctxt *ctxt, |
283 | if (rc != X86EMUL_CONTINUE) |
284 | return rc; |
285 | |
286 | - return ctxt->ops->write_std(ctxt, addr, desc, sizeof *desc, |
287 | - &ctxt->exception); |
288 | + return linear_write_system(ctxt, addr, desc, sizeof *desc); |
289 | } |
290 | |
291 | static int __load_segment_descriptor(struct x86_emulate_ctxt *ctxt, |
292 | @@ -1737,8 +1747,7 @@ static int __load_segment_descriptor(struct x86_emulate_ctxt *ctxt, |
293 | return ret; |
294 | } |
295 | } else if (ctxt->mode == X86EMUL_MODE_PROT64) { |
296 | - ret = ctxt->ops->read_std(ctxt, desc_addr+8, &base3, |
297 | - sizeof(base3), &ctxt->exception); |
298 | + ret = linear_read_system(ctxt, desc_addr+8, &base3, sizeof(base3)); |
299 | if (ret != X86EMUL_CONTINUE) |
300 | return ret; |
301 | if (emul_is_noncanonical_address(get_desc_base(&seg_desc) | |
302 | @@ -2051,11 +2060,11 @@ static int __emulate_int_real(struct x86_emulate_ctxt *ctxt, int irq) |
303 | eip_addr = dt.address + (irq << 2); |
304 | cs_addr = dt.address + (irq << 2) + 2; |
305 | |
306 | - rc = ops->read_std(ctxt, cs_addr, &cs, 2, &ctxt->exception); |
307 | + rc = linear_read_system(ctxt, cs_addr, &cs, 2); |
308 | if (rc != X86EMUL_CONTINUE) |
309 | return rc; |
310 | |
311 | - rc = ops->read_std(ctxt, eip_addr, &eip, 2, &ctxt->exception); |
312 | + rc = linear_read_system(ctxt, eip_addr, &eip, 2); |
313 | if (rc != X86EMUL_CONTINUE) |
314 | return rc; |
315 | |
316 | @@ -2919,12 +2928,12 @@ static bool emulator_io_port_access_allowed(struct x86_emulate_ctxt *ctxt, |
317 | #ifdef CONFIG_X86_64 |
318 | base |= ((u64)base3) << 32; |
319 | #endif |
320 | - r = ops->read_std(ctxt, base + 102, &io_bitmap_ptr, 2, NULL); |
321 | + r = ops->read_std(ctxt, base + 102, &io_bitmap_ptr, 2, NULL, true); |
322 | if (r != X86EMUL_CONTINUE) |
323 | return false; |
324 | if (io_bitmap_ptr + port/8 > desc_limit_scaled(&tr_seg)) |
325 | return false; |
326 | - r = ops->read_std(ctxt, base + io_bitmap_ptr + port/8, &perm, 2, NULL); |
327 | + r = ops->read_std(ctxt, base + io_bitmap_ptr + port/8, &perm, 2, NULL, true); |
328 | if (r != X86EMUL_CONTINUE) |
329 | return false; |
330 | if ((perm >> bit_idx) & mask) |
331 | @@ -3053,35 +3062,30 @@ static int task_switch_16(struct x86_emulate_ctxt *ctxt, |
332 | u16 tss_selector, u16 old_tss_sel, |
333 | ulong old_tss_base, struct desc_struct *new_desc) |
334 | { |
335 | - const struct x86_emulate_ops *ops = ctxt->ops; |
336 | struct tss_segment_16 tss_seg; |
337 | int ret; |
338 | u32 new_tss_base = get_desc_base(new_desc); |
339 | |
340 | - ret = ops->read_std(ctxt, old_tss_base, &tss_seg, sizeof tss_seg, |
341 | - &ctxt->exception); |
342 | + ret = linear_read_system(ctxt, old_tss_base, &tss_seg, sizeof tss_seg); |
343 | if (ret != X86EMUL_CONTINUE) |
344 | return ret; |
345 | |
346 | save_state_to_tss16(ctxt, &tss_seg); |
347 | |
348 | - ret = ops->write_std(ctxt, old_tss_base, &tss_seg, sizeof tss_seg, |
349 | - &ctxt->exception); |
350 | + ret = linear_write_system(ctxt, old_tss_base, &tss_seg, sizeof tss_seg); |
351 | if (ret != X86EMUL_CONTINUE) |
352 | return ret; |
353 | |
354 | - ret = ops->read_std(ctxt, new_tss_base, &tss_seg, sizeof tss_seg, |
355 | - &ctxt->exception); |
356 | + ret = linear_read_system(ctxt, new_tss_base, &tss_seg, sizeof tss_seg); |
357 | if (ret != X86EMUL_CONTINUE) |
358 | return ret; |
359 | |
360 | if (old_tss_sel != 0xffff) { |
361 | tss_seg.prev_task_link = old_tss_sel; |
362 | |
363 | - ret = ops->write_std(ctxt, new_tss_base, |
364 | - &tss_seg.prev_task_link, |
365 | - sizeof tss_seg.prev_task_link, |
366 | - &ctxt->exception); |
367 | + ret = linear_write_system(ctxt, new_tss_base, |
368 | + &tss_seg.prev_task_link, |
369 | + sizeof tss_seg.prev_task_link); |
370 | if (ret != X86EMUL_CONTINUE) |
371 | return ret; |
372 | } |
373 | @@ -3197,38 +3201,34 @@ static int task_switch_32(struct x86_emulate_ctxt *ctxt, |
374 | u16 tss_selector, u16 old_tss_sel, |
375 | ulong old_tss_base, struct desc_struct *new_desc) |
376 | { |
377 | - const struct x86_emulate_ops *ops = ctxt->ops; |
378 | struct tss_segment_32 tss_seg; |
379 | int ret; |
380 | u32 new_tss_base = get_desc_base(new_desc); |
381 | u32 eip_offset = offsetof(struct tss_segment_32, eip); |
382 | u32 ldt_sel_offset = offsetof(struct tss_segment_32, ldt_selector); |
383 | |
384 | - ret = ops->read_std(ctxt, old_tss_base, &tss_seg, sizeof tss_seg, |
385 | - &ctxt->exception); |
386 | + ret = linear_read_system(ctxt, old_tss_base, &tss_seg, sizeof tss_seg); |
387 | if (ret != X86EMUL_CONTINUE) |
388 | return ret; |
389 | |
390 | save_state_to_tss32(ctxt, &tss_seg); |
391 | |
392 | /* Only GP registers and segment selectors are saved */ |
393 | - ret = ops->write_std(ctxt, old_tss_base + eip_offset, &tss_seg.eip, |
394 | - ldt_sel_offset - eip_offset, &ctxt->exception); |
395 | + ret = linear_write_system(ctxt, old_tss_base + eip_offset, &tss_seg.eip, |
396 | + ldt_sel_offset - eip_offset); |
397 | if (ret != X86EMUL_CONTINUE) |
398 | return ret; |
399 | |
400 | - ret = ops->read_std(ctxt, new_tss_base, &tss_seg, sizeof tss_seg, |
401 | - &ctxt->exception); |
402 | + ret = linear_read_system(ctxt, new_tss_base, &tss_seg, sizeof tss_seg); |
403 | if (ret != X86EMUL_CONTINUE) |
404 | return ret; |
405 | |
406 | if (old_tss_sel != 0xffff) { |
407 | tss_seg.prev_task_link = old_tss_sel; |
408 | |
409 | - ret = ops->write_std(ctxt, new_tss_base, |
410 | - &tss_seg.prev_task_link, |
411 | - sizeof tss_seg.prev_task_link, |
412 | - &ctxt->exception); |
413 | + ret = linear_write_system(ctxt, new_tss_base, |
414 | + &tss_seg.prev_task_link, |
415 | + sizeof tss_seg.prev_task_link); |
416 | if (ret != X86EMUL_CONTINUE) |
417 | return ret; |
418 | } |
419 | @@ -4189,7 +4189,9 @@ static int check_cr_write(struct x86_emulate_ctxt *ctxt) |
420 | maxphyaddr = eax & 0xff; |
421 | else |
422 | maxphyaddr = 36; |
423 | - rsvd = rsvd_bits(maxphyaddr, 62); |
424 | + rsvd = rsvd_bits(maxphyaddr, 63); |
425 | + if (ctxt->ops->get_cr(ctxt, 4) & X86_CR4_PCIDE) |
426 | + rsvd &= ~CR3_PCID_INVD; |
427 | } |
428 | |
429 | if (new_val & rsvd) |
430 | diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c |
431 | index 40aa29204baf..82f5e915e568 100644 |
432 | --- a/arch/x86/kvm/vmx.c |
433 | +++ b/arch/x86/kvm/vmx.c |
434 | @@ -7588,8 +7588,7 @@ static int nested_vmx_get_vmptr(struct kvm_vcpu *vcpu, gpa_t *vmpointer) |
435 | vmcs_read32(VMX_INSTRUCTION_INFO), false, &gva)) |
436 | return 1; |
437 | |
438 | - if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, vmpointer, |
439 | - sizeof(*vmpointer), &e)) { |
440 | + if (kvm_read_guest_virt(vcpu, gva, vmpointer, sizeof(*vmpointer), &e)) { |
441 | kvm_inject_page_fault(vcpu, &e); |
442 | return 1; |
443 | } |
444 | @@ -7670,6 +7669,12 @@ static int handle_vmon(struct kvm_vcpu *vcpu) |
445 | return 1; |
446 | } |
447 | |
448 | + /* CPL=0 must be checked manually. */ |
449 | + if (vmx_get_cpl(vcpu)) { |
450 | + kvm_queue_exception(vcpu, UD_VECTOR); |
451 | + return 1; |
452 | + } |
453 | + |
454 | if (vmx->nested.vmxon) { |
455 | nested_vmx_failValid(vcpu, VMXERR_VMXON_IN_VMX_ROOT_OPERATION); |
456 | return kvm_skip_emulated_instruction(vcpu); |
457 | @@ -7729,6 +7734,11 @@ static int handle_vmon(struct kvm_vcpu *vcpu) |
458 | */ |
459 | static int nested_vmx_check_permission(struct kvm_vcpu *vcpu) |
460 | { |
461 | + if (vmx_get_cpl(vcpu)) { |
462 | + kvm_queue_exception(vcpu, UD_VECTOR); |
463 | + return 0; |
464 | + } |
465 | + |
466 | if (!to_vmx(vcpu)->nested.vmxon) { |
467 | kvm_queue_exception(vcpu, UD_VECTOR); |
468 | return 0; |
469 | @@ -8029,9 +8039,9 @@ static int handle_vmread(struct kvm_vcpu *vcpu) |
470 | if (get_vmx_mem_address(vcpu, exit_qualification, |
471 | vmx_instruction_info, true, &gva)) |
472 | return 1; |
473 | - /* _system ok, as hardware has verified cpl=0 */ |
474 | - kvm_write_guest_virt_system(&vcpu->arch.emulate_ctxt, gva, |
475 | - &field_value, (is_long_mode(vcpu) ? 8 : 4), NULL); |
476 | + /* _system ok, nested_vmx_check_permission has verified cpl=0 */ |
477 | + kvm_write_guest_virt_system(vcpu, gva, &field_value, |
478 | + (is_long_mode(vcpu) ? 8 : 4), NULL); |
479 | } |
480 | |
481 | nested_vmx_succeed(vcpu); |
482 | @@ -8069,8 +8079,8 @@ static int handle_vmwrite(struct kvm_vcpu *vcpu) |
483 | if (get_vmx_mem_address(vcpu, exit_qualification, |
484 | vmx_instruction_info, false, &gva)) |
485 | return 1; |
486 | - if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, |
487 | - &field_value, (is_64_bit_mode(vcpu) ? 8 : 4), &e)) { |
488 | + if (kvm_read_guest_virt(vcpu, gva, &field_value, |
489 | + (is_64_bit_mode(vcpu) ? 8 : 4), &e)) { |
490 | kvm_inject_page_fault(vcpu, &e); |
491 | return 1; |
492 | } |
493 | @@ -8189,10 +8199,10 @@ static int handle_vmptrst(struct kvm_vcpu *vcpu) |
494 | if (get_vmx_mem_address(vcpu, exit_qualification, |
495 | vmx_instruction_info, true, &vmcs_gva)) |
496 | return 1; |
497 | - /* ok to use *_system, as hardware has verified cpl=0 */ |
498 | - if (kvm_write_guest_virt_system(&vcpu->arch.emulate_ctxt, vmcs_gva, |
499 | - (void *)&to_vmx(vcpu)->nested.current_vmptr, |
500 | - sizeof(u64), &e)) { |
501 | + /* *_system ok, nested_vmx_check_permission has verified cpl=0 */ |
502 | + if (kvm_write_guest_virt_system(vcpu, vmcs_gva, |
503 | + (void *)&to_vmx(vcpu)->nested.current_vmptr, |
504 | + sizeof(u64), &e)) { |
505 | kvm_inject_page_fault(vcpu, &e); |
506 | return 1; |
507 | } |
508 | @@ -8239,8 +8249,7 @@ static int handle_invept(struct kvm_vcpu *vcpu) |
509 | if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), |
510 | vmx_instruction_info, false, &gva)) |
511 | return 1; |
512 | - if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &operand, |
513 | - sizeof(operand), &e)) { |
514 | + if (kvm_read_guest_virt(vcpu, gva, &operand, sizeof(operand), &e)) { |
515 | kvm_inject_page_fault(vcpu, &e); |
516 | return 1; |
517 | } |
518 | @@ -8304,8 +8313,7 @@ static int handle_invvpid(struct kvm_vcpu *vcpu) |
519 | if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), |
520 | vmx_instruction_info, false, &gva)) |
521 | return 1; |
522 | - if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &operand, |
523 | - sizeof(operand), &e)) { |
524 | + if (kvm_read_guest_virt(vcpu, gva, &operand, sizeof(operand), &e)) { |
525 | kvm_inject_page_fault(vcpu, &e); |
526 | return 1; |
527 | } |
528 | diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c |
529 | index 71e7cda6d014..fbc4d17e3ecc 100644 |
530 | --- a/arch/x86/kvm/x86.c |
531 | +++ b/arch/x86/kvm/x86.c |
532 | @@ -856,7 +856,7 @@ int kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3) |
533 | } |
534 | |
535 | if (is_long_mode(vcpu) && |
536 | - (cr3 & rsvd_bits(cpuid_maxphyaddr(vcpu), 62))) |
537 | + (cr3 & rsvd_bits(cpuid_maxphyaddr(vcpu), 63))) |
538 | return 1; |
539 | else if (is_pae(vcpu) && is_paging(vcpu) && |
540 | !load_pdptrs(vcpu, vcpu->arch.walk_mmu, cr3)) |
541 | @@ -2894,7 +2894,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) |
542 | r = KVM_CLOCK_TSC_STABLE; |
543 | break; |
544 | case KVM_CAP_X86_DISABLE_EXITS: |
545 | - r |= KVM_X86_DISABLE_EXITS_HTL | KVM_X86_DISABLE_EXITS_PAUSE; |
546 | + r |= KVM_X86_DISABLE_EXITS_HLT | KVM_X86_DISABLE_EXITS_PAUSE; |
547 | if(kvm_can_mwait_in_guest()) |
548 | r |= KVM_X86_DISABLE_EXITS_MWAIT; |
549 | break; |
550 | @@ -4248,7 +4248,7 @@ static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, |
551 | if ((cap->args[0] & KVM_X86_DISABLE_EXITS_MWAIT) && |
552 | kvm_can_mwait_in_guest()) |
553 | kvm->arch.mwait_in_guest = true; |
554 | - if (cap->args[0] & KVM_X86_DISABLE_EXITS_HTL) |
555 | + if (cap->args[0] & KVM_X86_DISABLE_EXITS_HLT) |
556 | kvm->arch.hlt_in_guest = true; |
557 | if (cap->args[0] & KVM_X86_DISABLE_EXITS_PAUSE) |
558 | kvm->arch.pause_in_guest = true; |
559 | @@ -4787,11 +4787,10 @@ static int kvm_fetch_guest_virt(struct x86_emulate_ctxt *ctxt, |
560 | return X86EMUL_CONTINUE; |
561 | } |
562 | |
563 | -int kvm_read_guest_virt(struct x86_emulate_ctxt *ctxt, |
564 | +int kvm_read_guest_virt(struct kvm_vcpu *vcpu, |
565 | gva_t addr, void *val, unsigned int bytes, |
566 | struct x86_exception *exception) |
567 | { |
568 | - struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt); |
569 | u32 access = (kvm_x86_ops->get_cpl(vcpu) == 3) ? PFERR_USER_MASK : 0; |
570 | |
571 | return kvm_read_guest_virt_helper(addr, val, bytes, vcpu, access, |
572 | @@ -4799,12 +4798,17 @@ int kvm_read_guest_virt(struct x86_emulate_ctxt *ctxt, |
573 | } |
574 | EXPORT_SYMBOL_GPL(kvm_read_guest_virt); |
575 | |
576 | -static int kvm_read_guest_virt_system(struct x86_emulate_ctxt *ctxt, |
577 | - gva_t addr, void *val, unsigned int bytes, |
578 | - struct x86_exception *exception) |
579 | +static int emulator_read_std(struct x86_emulate_ctxt *ctxt, |
580 | + gva_t addr, void *val, unsigned int bytes, |
581 | + struct x86_exception *exception, bool system) |
582 | { |
583 | struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt); |
584 | - return kvm_read_guest_virt_helper(addr, val, bytes, vcpu, 0, exception); |
585 | + u32 access = 0; |
586 | + |
587 | + if (!system && kvm_x86_ops->get_cpl(vcpu) == 3) |
588 | + access |= PFERR_USER_MASK; |
589 | + |
590 | + return kvm_read_guest_virt_helper(addr, val, bytes, vcpu, access, exception); |
591 | } |
592 | |
593 | static int kvm_read_guest_phys_system(struct x86_emulate_ctxt *ctxt, |
594 | @@ -4816,18 +4820,16 @@ static int kvm_read_guest_phys_system(struct x86_emulate_ctxt *ctxt, |
595 | return r < 0 ? X86EMUL_IO_NEEDED : X86EMUL_CONTINUE; |
596 | } |
597 | |
598 | -int kvm_write_guest_virt_system(struct x86_emulate_ctxt *ctxt, |
599 | - gva_t addr, void *val, |
600 | - unsigned int bytes, |
601 | - struct x86_exception *exception) |
602 | +static int kvm_write_guest_virt_helper(gva_t addr, void *val, unsigned int bytes, |
603 | + struct kvm_vcpu *vcpu, u32 access, |
604 | + struct x86_exception *exception) |
605 | { |
606 | - struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt); |
607 | void *data = val; |
608 | int r = X86EMUL_CONTINUE; |
609 | |
610 | while (bytes) { |
611 | gpa_t gpa = vcpu->arch.walk_mmu->gva_to_gpa(vcpu, addr, |
612 | - PFERR_WRITE_MASK, |
613 | + access, |
614 | exception); |
615 | unsigned offset = addr & (PAGE_SIZE-1); |
616 | unsigned towrite = min(bytes, (unsigned)PAGE_SIZE - offset); |
617 | @@ -4848,6 +4850,27 @@ int kvm_write_guest_virt_system(struct x86_emulate_ctxt *ctxt, |
618 | out: |
619 | return r; |
620 | } |
621 | + |
622 | +static int emulator_write_std(struct x86_emulate_ctxt *ctxt, gva_t addr, void *val, |
623 | + unsigned int bytes, struct x86_exception *exception, |
624 | + bool system) |
625 | +{ |
626 | + struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt); |
627 | + u32 access = PFERR_WRITE_MASK; |
628 | + |
629 | + if (!system && kvm_x86_ops->get_cpl(vcpu) == 3) |
630 | + access |= PFERR_USER_MASK; |
631 | + |
632 | + return kvm_write_guest_virt_helper(addr, val, bytes, vcpu, |
633 | + access, exception); |
634 | +} |
635 | + |
636 | +int kvm_write_guest_virt_system(struct kvm_vcpu *vcpu, gva_t addr, void *val, |
637 | + unsigned int bytes, struct x86_exception *exception) |
638 | +{ |
639 | + return kvm_write_guest_virt_helper(addr, val, bytes, vcpu, |
640 | + PFERR_WRITE_MASK, exception); |
641 | +} |
642 | EXPORT_SYMBOL_GPL(kvm_write_guest_virt_system); |
643 | |
644 | int handle_ud(struct kvm_vcpu *vcpu) |
645 | @@ -4858,8 +4881,8 @@ int handle_ud(struct kvm_vcpu *vcpu) |
646 | struct x86_exception e; |
647 | |
648 | if (force_emulation_prefix && |
649 | - kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, |
650 | - kvm_get_linear_rip(vcpu), sig, sizeof(sig), &e) == 0 && |
651 | + kvm_read_guest_virt(vcpu, kvm_get_linear_rip(vcpu), |
652 | + sig, sizeof(sig), &e) == 0 && |
653 | memcmp(sig, "\xf\xbkvm", sizeof(sig)) == 0) { |
654 | kvm_rip_write(vcpu, kvm_rip_read(vcpu) + sizeof(sig)); |
655 | emul_type = 0; |
656 | @@ -5600,8 +5623,8 @@ static int emulator_pre_leave_smm(struct x86_emulate_ctxt *ctxt, u64 smbase) |
657 | static const struct x86_emulate_ops emulate_ops = { |
658 | .read_gpr = emulator_read_gpr, |
659 | .write_gpr = emulator_write_gpr, |
660 | - .read_std = kvm_read_guest_virt_system, |
661 | - .write_std = kvm_write_guest_virt_system, |
662 | + .read_std = emulator_read_std, |
663 | + .write_std = emulator_write_std, |
664 | .read_phys = kvm_read_guest_phys_system, |
665 | .fetch = kvm_fetch_guest_virt, |
666 | .read_emulated = emulator_read_emulated, |
667 | diff --git a/arch/x86/kvm/x86.h b/arch/x86/kvm/x86.h |
668 | index c9492f764902..331993c49dae 100644 |
669 | --- a/arch/x86/kvm/x86.h |
670 | +++ b/arch/x86/kvm/x86.h |
671 | @@ -247,11 +247,11 @@ int kvm_inject_realmode_interrupt(struct kvm_vcpu *vcpu, int irq, int inc_eip); |
672 | void kvm_write_tsc(struct kvm_vcpu *vcpu, struct msr_data *msr); |
673 | u64 get_kvmclock_ns(struct kvm *kvm); |
674 | |
675 | -int kvm_read_guest_virt(struct x86_emulate_ctxt *ctxt, |
676 | +int kvm_read_guest_virt(struct kvm_vcpu *vcpu, |
677 | gva_t addr, void *val, unsigned int bytes, |
678 | struct x86_exception *exception); |
679 | |
680 | -int kvm_write_guest_virt_system(struct x86_emulate_ctxt *ctxt, |
681 | +int kvm_write_guest_virt_system(struct kvm_vcpu *vcpu, |
682 | gva_t addr, void *val, unsigned int bytes, |
683 | struct x86_exception *exception); |
684 | |
685 | diff --git a/block/blk-zoned.c b/block/blk-zoned.c |
686 | index 08e84ef2bc05..3d08dc84db16 100644 |
687 | --- a/block/blk-zoned.c |
688 | +++ b/block/blk-zoned.c |
689 | @@ -328,7 +328,11 @@ int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode, |
690 | if (!rep.nr_zones) |
691 | return -EINVAL; |
692 | |
693 | - zones = kcalloc(rep.nr_zones, sizeof(struct blk_zone), GFP_KERNEL); |
694 | + if (rep.nr_zones > INT_MAX / sizeof(struct blk_zone)) |
695 | + return -ERANGE; |
696 | + |
697 | + zones = kvmalloc(rep.nr_zones * sizeof(struct blk_zone), |
698 | + GFP_KERNEL | __GFP_ZERO); |
699 | if (!zones) |
700 | return -ENOMEM; |
701 | |
702 | @@ -350,7 +354,7 @@ int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode, |
703 | } |
704 | |
705 | out: |
706 | - kfree(zones); |
707 | + kvfree(zones); |
708 | |
709 | return ret; |
710 | } |
711 | diff --git a/drivers/crypto/caam/caamalg.c b/drivers/crypto/caam/caamalg.c |
712 | index 7207a535942d..d67667970f7e 100644 |
713 | --- a/drivers/crypto/caam/caamalg.c |
714 | +++ b/drivers/crypto/caam/caamalg.c |
715 | @@ -769,15 +769,18 @@ struct aead_edesc { |
716 | * @src_nents: number of segments in input s/w scatterlist |
717 | * @dst_nents: number of segments in output s/w scatterlist |
718 | * @iv_dma: dma address of iv for checking continuity and link table |
719 | + * @iv_dir: DMA mapping direction for IV |
720 | * @sec4_sg_bytes: length of dma mapped sec4_sg space |
721 | * @sec4_sg_dma: bus physical mapped address of h/w link table |
722 | * @sec4_sg: pointer to h/w link table |
723 | * @hw_desc: the h/w job descriptor followed by any referenced link tables |
724 | + * and IV |
725 | */ |
726 | struct ablkcipher_edesc { |
727 | int src_nents; |
728 | int dst_nents; |
729 | dma_addr_t iv_dma; |
730 | + enum dma_data_direction iv_dir; |
731 | int sec4_sg_bytes; |
732 | dma_addr_t sec4_sg_dma; |
733 | struct sec4_sg_entry *sec4_sg; |
734 | @@ -787,7 +790,8 @@ struct ablkcipher_edesc { |
735 | static void caam_unmap(struct device *dev, struct scatterlist *src, |
736 | struct scatterlist *dst, int src_nents, |
737 | int dst_nents, |
738 | - dma_addr_t iv_dma, int ivsize, dma_addr_t sec4_sg_dma, |
739 | + dma_addr_t iv_dma, int ivsize, |
740 | + enum dma_data_direction iv_dir, dma_addr_t sec4_sg_dma, |
741 | int sec4_sg_bytes) |
742 | { |
743 | if (dst != src) { |
744 | @@ -799,7 +803,7 @@ static void caam_unmap(struct device *dev, struct scatterlist *src, |
745 | } |
746 | |
747 | if (iv_dma) |
748 | - dma_unmap_single(dev, iv_dma, ivsize, DMA_TO_DEVICE); |
749 | + dma_unmap_single(dev, iv_dma, ivsize, iv_dir); |
750 | if (sec4_sg_bytes) |
751 | dma_unmap_single(dev, sec4_sg_dma, sec4_sg_bytes, |
752 | DMA_TO_DEVICE); |
753 | @@ -810,7 +814,7 @@ static void aead_unmap(struct device *dev, |
754 | struct aead_request *req) |
755 | { |
756 | caam_unmap(dev, req->src, req->dst, |
757 | - edesc->src_nents, edesc->dst_nents, 0, 0, |
758 | + edesc->src_nents, edesc->dst_nents, 0, 0, DMA_NONE, |
759 | edesc->sec4_sg_dma, edesc->sec4_sg_bytes); |
760 | } |
761 | |
762 | @@ -823,7 +827,7 @@ static void ablkcipher_unmap(struct device *dev, |
763 | |
764 | caam_unmap(dev, req->src, req->dst, |
765 | edesc->src_nents, edesc->dst_nents, |
766 | - edesc->iv_dma, ivsize, |
767 | + edesc->iv_dma, ivsize, edesc->iv_dir, |
768 | edesc->sec4_sg_dma, edesc->sec4_sg_bytes); |
769 | } |
770 | |
771 | @@ -912,6 +916,18 @@ static void ablkcipher_encrypt_done(struct device *jrdev, u32 *desc, u32 err, |
772 | scatterwalk_map_and_copy(req->info, req->dst, req->nbytes - ivsize, |
773 | ivsize, 0); |
774 | |
775 | + /* In case initial IV was generated, copy it in GIVCIPHER request */ |
776 | + if (edesc->iv_dir == DMA_FROM_DEVICE) { |
777 | + u8 *iv; |
778 | + struct skcipher_givcrypt_request *greq; |
779 | + |
780 | + greq = container_of(req, struct skcipher_givcrypt_request, |
781 | + creq); |
782 | + iv = (u8 *)edesc->hw_desc + desc_bytes(edesc->hw_desc) + |
783 | + edesc->sec4_sg_bytes; |
784 | + memcpy(greq->giv, iv, ivsize); |
785 | + } |
786 | + |
787 | kfree(edesc); |
788 | |
789 | ablkcipher_request_complete(req, err); |
790 | @@ -922,10 +938,10 @@ static void ablkcipher_decrypt_done(struct device *jrdev, u32 *desc, u32 err, |
791 | { |
792 | struct ablkcipher_request *req = context; |
793 | struct ablkcipher_edesc *edesc; |
794 | +#ifdef DEBUG |
795 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); |
796 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); |
797 | |
798 | -#ifdef DEBUG |
799 | dev_err(jrdev, "%s %d: err 0x%x\n", __func__, __LINE__, err); |
800 | #endif |
801 | |
802 | @@ -943,14 +959,6 @@ static void ablkcipher_decrypt_done(struct device *jrdev, u32 *desc, u32 err, |
803 | edesc->dst_nents > 1 ? 100 : req->nbytes, 1); |
804 | |
805 | ablkcipher_unmap(jrdev, edesc, req); |
806 | - |
807 | - /* |
808 | - * The crypto API expects us to set the IV (req->info) to the last |
809 | - * ciphertext block. |
810 | - */ |
811 | - scatterwalk_map_and_copy(req->info, req->src, req->nbytes - ivsize, |
812 | - ivsize, 0); |
813 | - |
814 | kfree(edesc); |
815 | |
816 | ablkcipher_request_complete(req, err); |
817 | @@ -1099,15 +1107,14 @@ static void init_authenc_job(struct aead_request *req, |
818 | */ |
819 | static void init_ablkcipher_job(u32 *sh_desc, dma_addr_t ptr, |
820 | struct ablkcipher_edesc *edesc, |
821 | - struct ablkcipher_request *req, |
822 | - bool iv_contig) |
823 | + struct ablkcipher_request *req) |
824 | { |
825 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); |
826 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); |
827 | u32 *desc = edesc->hw_desc; |
828 | - u32 out_options = 0, in_options; |
829 | - dma_addr_t dst_dma, src_dma; |
830 | - int len, sec4_sg_index = 0; |
831 | + u32 out_options = 0; |
832 | + dma_addr_t dst_dma; |
833 | + int len; |
834 | |
835 | #ifdef DEBUG |
836 | print_hex_dump(KERN_ERR, "presciv@"__stringify(__LINE__)": ", |
837 | @@ -1123,30 +1130,18 @@ static void init_ablkcipher_job(u32 *sh_desc, dma_addr_t ptr, |
838 | len = desc_len(sh_desc); |
839 | init_job_desc_shared(desc, ptr, len, HDR_SHARE_DEFER | HDR_REVERSE); |
840 | |
841 | - if (iv_contig) { |
842 | - src_dma = edesc->iv_dma; |
843 | - in_options = 0; |
844 | - } else { |
845 | - src_dma = edesc->sec4_sg_dma; |
846 | - sec4_sg_index += edesc->src_nents + 1; |
847 | - in_options = LDST_SGF; |
848 | - } |
849 | - append_seq_in_ptr(desc, src_dma, req->nbytes + ivsize, in_options); |
850 | + append_seq_in_ptr(desc, edesc->sec4_sg_dma, req->nbytes + ivsize, |
851 | + LDST_SGF); |
852 | |
853 | if (likely(req->src == req->dst)) { |
854 | - if (edesc->src_nents == 1 && iv_contig) { |
855 | - dst_dma = sg_dma_address(req->src); |
856 | - } else { |
857 | - dst_dma = edesc->sec4_sg_dma + |
858 | - sizeof(struct sec4_sg_entry); |
859 | - out_options = LDST_SGF; |
860 | - } |
861 | + dst_dma = edesc->sec4_sg_dma + sizeof(struct sec4_sg_entry); |
862 | + out_options = LDST_SGF; |
863 | } else { |
864 | if (edesc->dst_nents == 1) { |
865 | dst_dma = sg_dma_address(req->dst); |
866 | } else { |
867 | - dst_dma = edesc->sec4_sg_dma + |
868 | - sec4_sg_index * sizeof(struct sec4_sg_entry); |
869 | + dst_dma = edesc->sec4_sg_dma + (edesc->src_nents + 1) * |
870 | + sizeof(struct sec4_sg_entry); |
871 | out_options = LDST_SGF; |
872 | } |
873 | } |
874 | @@ -1158,13 +1153,12 @@ static void init_ablkcipher_job(u32 *sh_desc, dma_addr_t ptr, |
875 | */ |
876 | static void init_ablkcipher_giv_job(u32 *sh_desc, dma_addr_t ptr, |
877 | struct ablkcipher_edesc *edesc, |
878 | - struct ablkcipher_request *req, |
879 | - bool iv_contig) |
880 | + struct ablkcipher_request *req) |
881 | { |
882 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); |
883 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); |
884 | u32 *desc = edesc->hw_desc; |
885 | - u32 out_options, in_options; |
886 | + u32 in_options; |
887 | dma_addr_t dst_dma, src_dma; |
888 | int len, sec4_sg_index = 0; |
889 | |
890 | @@ -1190,15 +1184,9 @@ static void init_ablkcipher_giv_job(u32 *sh_desc, dma_addr_t ptr, |
891 | } |
892 | append_seq_in_ptr(desc, src_dma, req->nbytes, in_options); |
893 | |
894 | - if (iv_contig) { |
895 | - dst_dma = edesc->iv_dma; |
896 | - out_options = 0; |
897 | - } else { |
898 | - dst_dma = edesc->sec4_sg_dma + |
899 | - sec4_sg_index * sizeof(struct sec4_sg_entry); |
900 | - out_options = LDST_SGF; |
901 | - } |
902 | - append_seq_out_ptr(desc, dst_dma, req->nbytes + ivsize, out_options); |
903 | + dst_dma = edesc->sec4_sg_dma + sec4_sg_index * |
904 | + sizeof(struct sec4_sg_entry); |
905 | + append_seq_out_ptr(desc, dst_dma, req->nbytes + ivsize, LDST_SGF); |
906 | } |
907 | |
908 | /* |
909 | @@ -1287,7 +1275,7 @@ static struct aead_edesc *aead_edesc_alloc(struct aead_request *req, |
910 | GFP_DMA | flags); |
911 | if (!edesc) { |
912 | caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, |
913 | - 0, 0, 0); |
914 | + 0, DMA_NONE, 0, 0); |
915 | return ERR_PTR(-ENOMEM); |
916 | } |
917 | |
918 | @@ -1491,8 +1479,7 @@ static int aead_decrypt(struct aead_request *req) |
919 | * allocate and map the ablkcipher extended descriptor for ablkcipher |
920 | */ |
921 | static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request |
922 | - *req, int desc_bytes, |
923 | - bool *iv_contig_out) |
924 | + *req, int desc_bytes) |
925 | { |
926 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); |
927 | struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher); |
928 | @@ -1501,8 +1488,8 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request |
929 | GFP_KERNEL : GFP_ATOMIC; |
930 | int src_nents, mapped_src_nents, dst_nents = 0, mapped_dst_nents = 0; |
931 | struct ablkcipher_edesc *edesc; |
932 | - dma_addr_t iv_dma = 0; |
933 | - bool in_contig; |
934 | + dma_addr_t iv_dma; |
935 | + u8 *iv; |
936 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); |
937 | int dst_sg_idx, sec4_sg_ents, sec4_sg_bytes; |
938 | |
939 | @@ -1546,33 +1533,20 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request |
940 | } |
941 | } |
942 | |
943 | - iv_dma = dma_map_single(jrdev, req->info, ivsize, DMA_TO_DEVICE); |
944 | - if (dma_mapping_error(jrdev, iv_dma)) { |
945 | - dev_err(jrdev, "unable to map IV\n"); |
946 | - caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, |
947 | - 0, 0, 0); |
948 | - return ERR_PTR(-ENOMEM); |
949 | - } |
950 | - |
951 | - if (mapped_src_nents == 1 && |
952 | - iv_dma + ivsize == sg_dma_address(req->src)) { |
953 | - in_contig = true; |
954 | - sec4_sg_ents = 0; |
955 | - } else { |
956 | - in_contig = false; |
957 | - sec4_sg_ents = 1 + mapped_src_nents; |
958 | - } |
959 | + sec4_sg_ents = 1 + mapped_src_nents; |
960 | dst_sg_idx = sec4_sg_ents; |
961 | sec4_sg_ents += mapped_dst_nents > 1 ? mapped_dst_nents : 0; |
962 | sec4_sg_bytes = sec4_sg_ents * sizeof(struct sec4_sg_entry); |
963 | |
964 | - /* allocate space for base edesc and hw desc commands, link tables */ |
965 | - edesc = kzalloc(sizeof(*edesc) + desc_bytes + sec4_sg_bytes, |
966 | + /* |
967 | + * allocate space for base edesc and hw desc commands, link tables, IV |
968 | + */ |
969 | + edesc = kzalloc(sizeof(*edesc) + desc_bytes + sec4_sg_bytes + ivsize, |
970 | GFP_DMA | flags); |
971 | if (!edesc) { |
972 | dev_err(jrdev, "could not allocate extended descriptor\n"); |
973 | - caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, |
974 | - iv_dma, ivsize, 0, 0); |
975 | + caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, |
976 | + 0, DMA_NONE, 0, 0); |
977 | return ERR_PTR(-ENOMEM); |
978 | } |
979 | |
980 | @@ -1581,13 +1555,24 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request |
981 | edesc->sec4_sg_bytes = sec4_sg_bytes; |
982 | edesc->sec4_sg = (void *)edesc + sizeof(struct ablkcipher_edesc) + |
983 | desc_bytes; |
984 | + edesc->iv_dir = DMA_TO_DEVICE; |
985 | |
986 | - if (!in_contig) { |
987 | - dma_to_sec4_sg_one(edesc->sec4_sg, iv_dma, ivsize, 0); |
988 | - sg_to_sec4_sg_last(req->src, mapped_src_nents, |
989 | - edesc->sec4_sg + 1, 0); |
990 | + /* Make sure IV is located in a DMAable area */ |
991 | + iv = (u8 *)edesc->hw_desc + desc_bytes + sec4_sg_bytes; |
992 | + memcpy(iv, req->info, ivsize); |
993 | + |
994 | + iv_dma = dma_map_single(jrdev, iv, ivsize, DMA_TO_DEVICE); |
995 | + if (dma_mapping_error(jrdev, iv_dma)) { |
996 | + dev_err(jrdev, "unable to map IV\n"); |
997 | + caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, |
998 | + 0, DMA_NONE, 0, 0); |
999 | + kfree(edesc); |
1000 | + return ERR_PTR(-ENOMEM); |
1001 | } |
1002 | |
1003 | + dma_to_sec4_sg_one(edesc->sec4_sg, iv_dma, ivsize, 0); |
1004 | + sg_to_sec4_sg_last(req->src, mapped_src_nents, edesc->sec4_sg + 1, 0); |
1005 | + |
1006 | if (mapped_dst_nents > 1) { |
1007 | sg_to_sec4_sg_last(req->dst, mapped_dst_nents, |
1008 | edesc->sec4_sg + dst_sg_idx, 0); |
1009 | @@ -1598,7 +1583,7 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request |
1010 | if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) { |
1011 | dev_err(jrdev, "unable to map S/G table\n"); |
1012 | caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, |
1013 | - iv_dma, ivsize, 0, 0); |
1014 | + iv_dma, ivsize, DMA_TO_DEVICE, 0, 0); |
1015 | kfree(edesc); |
1016 | return ERR_PTR(-ENOMEM); |
1017 | } |
1018 | @@ -1611,7 +1596,6 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request |
1019 | sec4_sg_bytes, 1); |
1020 | #endif |
1021 | |
1022 | - *iv_contig_out = in_contig; |
1023 | return edesc; |
1024 | } |
1025 | |
1026 | @@ -1621,19 +1605,16 @@ static int ablkcipher_encrypt(struct ablkcipher_request *req) |
1027 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); |
1028 | struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher); |
1029 | struct device *jrdev = ctx->jrdev; |
1030 | - bool iv_contig; |
1031 | u32 *desc; |
1032 | int ret = 0; |
1033 | |
1034 | /* allocate extended descriptor */ |
1035 | - edesc = ablkcipher_edesc_alloc(req, DESC_JOB_IO_LEN * |
1036 | - CAAM_CMD_SZ, &iv_contig); |
1037 | + edesc = ablkcipher_edesc_alloc(req, DESC_JOB_IO_LEN * CAAM_CMD_SZ); |
1038 | if (IS_ERR(edesc)) |
1039 | return PTR_ERR(edesc); |
1040 | |
1041 | /* Create and submit job descriptor*/ |
1042 | - init_ablkcipher_job(ctx->sh_desc_enc, |
1043 | - ctx->sh_desc_enc_dma, edesc, req, iv_contig); |
1044 | + init_ablkcipher_job(ctx->sh_desc_enc, ctx->sh_desc_enc_dma, edesc, req); |
1045 | #ifdef DEBUG |
1046 | print_hex_dump(KERN_ERR, "ablkcipher jobdesc@"__stringify(__LINE__)": ", |
1047 | DUMP_PREFIX_ADDRESS, 16, 4, edesc->hw_desc, |
1048 | @@ -1657,20 +1638,25 @@ static int ablkcipher_decrypt(struct ablkcipher_request *req) |
1049 | struct ablkcipher_edesc *edesc; |
1050 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); |
1051 | struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher); |
1052 | + int ivsize = crypto_ablkcipher_ivsize(ablkcipher); |
1053 | struct device *jrdev = ctx->jrdev; |
1054 | - bool iv_contig; |
1055 | u32 *desc; |
1056 | int ret = 0; |
1057 | |
1058 | /* allocate extended descriptor */ |
1059 | - edesc = ablkcipher_edesc_alloc(req, DESC_JOB_IO_LEN * |
1060 | - CAAM_CMD_SZ, &iv_contig); |
1061 | + edesc = ablkcipher_edesc_alloc(req, DESC_JOB_IO_LEN * CAAM_CMD_SZ); |
1062 | if (IS_ERR(edesc)) |
1063 | return PTR_ERR(edesc); |
1064 | |
1065 | + /* |
1066 | + * The crypto API expects us to set the IV (req->info) to the last |
1067 | + * ciphertext block. |
1068 | + */ |
1069 | + scatterwalk_map_and_copy(req->info, req->src, req->nbytes - ivsize, |
1070 | + ivsize, 0); |
1071 | + |
1072 | /* Create and submit job descriptor*/ |
1073 | - init_ablkcipher_job(ctx->sh_desc_dec, |
1074 | - ctx->sh_desc_dec_dma, edesc, req, iv_contig); |
1075 | + init_ablkcipher_job(ctx->sh_desc_dec, ctx->sh_desc_dec_dma, edesc, req); |
1076 | desc = edesc->hw_desc; |
1077 | #ifdef DEBUG |
1078 | print_hex_dump(KERN_ERR, "ablkcipher jobdesc@"__stringify(__LINE__)": ", |
1079 | @@ -1695,8 +1681,7 @@ static int ablkcipher_decrypt(struct ablkcipher_request *req) |
1080 | */ |
1081 | static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( |
1082 | struct skcipher_givcrypt_request *greq, |
1083 | - int desc_bytes, |
1084 | - bool *iv_contig_out) |
1085 | + int desc_bytes) |
1086 | { |
1087 | struct ablkcipher_request *req = &greq->creq; |
1088 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); |
1089 | @@ -1706,8 +1691,8 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( |
1090 | GFP_KERNEL : GFP_ATOMIC; |
1091 | int src_nents, mapped_src_nents, dst_nents, mapped_dst_nents; |
1092 | struct ablkcipher_edesc *edesc; |
1093 | - dma_addr_t iv_dma = 0; |
1094 | - bool out_contig; |
1095 | + dma_addr_t iv_dma; |
1096 | + u8 *iv; |
1097 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); |
1098 | int dst_sg_idx, sec4_sg_ents, sec4_sg_bytes; |
1099 | |
1100 | @@ -1752,36 +1737,20 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( |
1101 | } |
1102 | } |
1103 | |
1104 | - /* |
1105 | - * Check if iv can be contiguous with source and destination. |
1106 | - * If so, include it. If not, create scatterlist. |
1107 | - */ |
1108 | - iv_dma = dma_map_single(jrdev, greq->giv, ivsize, DMA_TO_DEVICE); |
1109 | - if (dma_mapping_error(jrdev, iv_dma)) { |
1110 | - dev_err(jrdev, "unable to map IV\n"); |
1111 | - caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, |
1112 | - 0, 0, 0); |
1113 | - return ERR_PTR(-ENOMEM); |
1114 | - } |
1115 | - |
1116 | sec4_sg_ents = mapped_src_nents > 1 ? mapped_src_nents : 0; |
1117 | dst_sg_idx = sec4_sg_ents; |
1118 | - if (mapped_dst_nents == 1 && |
1119 | - iv_dma + ivsize == sg_dma_address(req->dst)) { |
1120 | - out_contig = true; |
1121 | - } else { |
1122 | - out_contig = false; |
1123 | - sec4_sg_ents += 1 + mapped_dst_nents; |
1124 | - } |
1125 | + sec4_sg_ents += 1 + mapped_dst_nents; |
1126 | |
1127 | - /* allocate space for base edesc and hw desc commands, link tables */ |
1128 | + /* |
1129 | + * allocate space for base edesc and hw desc commands, link tables, IV |
1130 | + */ |
1131 | sec4_sg_bytes = sec4_sg_ents * sizeof(struct sec4_sg_entry); |
1132 | - edesc = kzalloc(sizeof(*edesc) + desc_bytes + sec4_sg_bytes, |
1133 | + edesc = kzalloc(sizeof(*edesc) + desc_bytes + sec4_sg_bytes + ivsize, |
1134 | GFP_DMA | flags); |
1135 | if (!edesc) { |
1136 | dev_err(jrdev, "could not allocate extended descriptor\n"); |
1137 | - caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, |
1138 | - iv_dma, ivsize, 0, 0); |
1139 | + caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, |
1140 | + 0, DMA_NONE, 0, 0); |
1141 | return ERR_PTR(-ENOMEM); |
1142 | } |
1143 | |
1144 | @@ -1790,24 +1759,33 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( |
1145 | edesc->sec4_sg_bytes = sec4_sg_bytes; |
1146 | edesc->sec4_sg = (void *)edesc + sizeof(struct ablkcipher_edesc) + |
1147 | desc_bytes; |
1148 | + edesc->iv_dir = DMA_FROM_DEVICE; |
1149 | + |
1150 | + /* Make sure IV is located in a DMAable area */ |
1151 | + iv = (u8 *)edesc->hw_desc + desc_bytes + sec4_sg_bytes; |
1152 | + iv_dma = dma_map_single(jrdev, iv, ivsize, DMA_FROM_DEVICE); |
1153 | + if (dma_mapping_error(jrdev, iv_dma)) { |
1154 | + dev_err(jrdev, "unable to map IV\n"); |
1155 | + caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, |
1156 | + 0, DMA_NONE, 0, 0); |
1157 | + kfree(edesc); |
1158 | + return ERR_PTR(-ENOMEM); |
1159 | + } |
1160 | |
1161 | if (mapped_src_nents > 1) |
1162 | sg_to_sec4_sg_last(req->src, mapped_src_nents, edesc->sec4_sg, |
1163 | 0); |
1164 | |
1165 | - if (!out_contig) { |
1166 | - dma_to_sec4_sg_one(edesc->sec4_sg + dst_sg_idx, |
1167 | - iv_dma, ivsize, 0); |
1168 | - sg_to_sec4_sg_last(req->dst, mapped_dst_nents, |
1169 | - edesc->sec4_sg + dst_sg_idx + 1, 0); |
1170 | - } |
1171 | + dma_to_sec4_sg_one(edesc->sec4_sg + dst_sg_idx, iv_dma, ivsize, 0); |
1172 | + sg_to_sec4_sg_last(req->dst, mapped_dst_nents, edesc->sec4_sg + |
1173 | + dst_sg_idx + 1, 0); |
1174 | |
1175 | edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg, |
1176 | sec4_sg_bytes, DMA_TO_DEVICE); |
1177 | if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) { |
1178 | dev_err(jrdev, "unable to map S/G table\n"); |
1179 | caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, |
1180 | - iv_dma, ivsize, 0, 0); |
1181 | + iv_dma, ivsize, DMA_FROM_DEVICE, 0, 0); |
1182 | kfree(edesc); |
1183 | return ERR_PTR(-ENOMEM); |
1184 | } |
1185 | @@ -1820,7 +1798,6 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( |
1186 | sec4_sg_bytes, 1); |
1187 | #endif |
1188 | |
1189 | - *iv_contig_out = out_contig; |
1190 | return edesc; |
1191 | } |
1192 | |
1193 | @@ -1831,19 +1808,17 @@ static int ablkcipher_givencrypt(struct skcipher_givcrypt_request *creq) |
1194 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); |
1195 | struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher); |
1196 | struct device *jrdev = ctx->jrdev; |
1197 | - bool iv_contig = false; |
1198 | u32 *desc; |
1199 | int ret = 0; |
1200 | |
1201 | /* allocate extended descriptor */ |
1202 | - edesc = ablkcipher_giv_edesc_alloc(creq, DESC_JOB_IO_LEN * |
1203 | - CAAM_CMD_SZ, &iv_contig); |
1204 | + edesc = ablkcipher_giv_edesc_alloc(creq, DESC_JOB_IO_LEN * CAAM_CMD_SZ); |
1205 | if (IS_ERR(edesc)) |
1206 | return PTR_ERR(edesc); |
1207 | |
1208 | /* Create and submit job descriptor*/ |
1209 | init_ablkcipher_giv_job(ctx->sh_desc_givenc, ctx->sh_desc_givenc_dma, |
1210 | - edesc, req, iv_contig); |
1211 | + edesc, req); |
1212 | #ifdef DEBUG |
1213 | print_hex_dump(KERN_ERR, |
1214 | "ablkcipher jobdesc@" __stringify(__LINE__) ": ", |
1215 | diff --git a/drivers/crypto/caam/caamalg_qi.c b/drivers/crypto/caam/caamalg_qi.c |
1216 | index cacda0831390..6e61cc93c2b0 100644 |
1217 | --- a/drivers/crypto/caam/caamalg_qi.c |
1218 | +++ b/drivers/crypto/caam/caamalg_qi.c |
1219 | @@ -728,7 +728,7 @@ static int xts_ablkcipher_setkey(struct crypto_ablkcipher *ablkcipher, |
1220 | * @assoclen: associated data length, in CAAM endianness |
1221 | * @assoclen_dma: bus physical mapped address of req->assoclen |
1222 | * @drv_req: driver-specific request structure |
1223 | - * @sgt: the h/w link table |
1224 | + * @sgt: the h/w link table, followed by IV |
1225 | */ |
1226 | struct aead_edesc { |
1227 | int src_nents; |
1228 | @@ -739,9 +739,6 @@ struct aead_edesc { |
1229 | unsigned int assoclen; |
1230 | dma_addr_t assoclen_dma; |
1231 | struct caam_drv_req drv_req; |
1232 | -#define CAAM_QI_MAX_AEAD_SG \ |
1233 | - ((CAAM_QI_MEMCACHE_SIZE - offsetof(struct aead_edesc, sgt)) / \ |
1234 | - sizeof(struct qm_sg_entry)) |
1235 | struct qm_sg_entry sgt[0]; |
1236 | }; |
1237 | |
1238 | @@ -753,7 +750,7 @@ struct aead_edesc { |
1239 | * @qm_sg_bytes: length of dma mapped h/w link table |
1240 | * @qm_sg_dma: bus physical mapped address of h/w link table |
1241 | * @drv_req: driver-specific request structure |
1242 | - * @sgt: the h/w link table |
1243 | + * @sgt: the h/w link table, followed by IV |
1244 | */ |
1245 | struct ablkcipher_edesc { |
1246 | int src_nents; |
1247 | @@ -762,9 +759,6 @@ struct ablkcipher_edesc { |
1248 | int qm_sg_bytes; |
1249 | dma_addr_t qm_sg_dma; |
1250 | struct caam_drv_req drv_req; |
1251 | -#define CAAM_QI_MAX_ABLKCIPHER_SG \ |
1252 | - ((CAAM_QI_MEMCACHE_SIZE - offsetof(struct ablkcipher_edesc, sgt)) / \ |
1253 | - sizeof(struct qm_sg_entry)) |
1254 | struct qm_sg_entry sgt[0]; |
1255 | }; |
1256 | |
1257 | @@ -986,17 +980,8 @@ static struct aead_edesc *aead_edesc_alloc(struct aead_request *req, |
1258 | } |
1259 | } |
1260 | |
1261 | - if ((alg->caam.rfc3686 && encrypt) || !alg->caam.geniv) { |
1262 | + if ((alg->caam.rfc3686 && encrypt) || !alg->caam.geniv) |
1263 | ivsize = crypto_aead_ivsize(aead); |
1264 | - iv_dma = dma_map_single(qidev, req->iv, ivsize, DMA_TO_DEVICE); |
1265 | - if (dma_mapping_error(qidev, iv_dma)) { |
1266 | - dev_err(qidev, "unable to map IV\n"); |
1267 | - caam_unmap(qidev, req->src, req->dst, src_nents, |
1268 | - dst_nents, 0, 0, op_type, 0, 0); |
1269 | - qi_cache_free(edesc); |
1270 | - return ERR_PTR(-ENOMEM); |
1271 | - } |
1272 | - } |
1273 | |
1274 | /* |
1275 | * Create S/G table: req->assoclen, [IV,] req->src [, req->dst]. |
1276 | @@ -1004,16 +989,33 @@ static struct aead_edesc *aead_edesc_alloc(struct aead_request *req, |
1277 | */ |
1278 | qm_sg_ents = 1 + !!ivsize + mapped_src_nents + |
1279 | (mapped_dst_nents > 1 ? mapped_dst_nents : 0); |
1280 | - if (unlikely(qm_sg_ents > CAAM_QI_MAX_AEAD_SG)) { |
1281 | - dev_err(qidev, "Insufficient S/G entries: %d > %zu\n", |
1282 | - qm_sg_ents, CAAM_QI_MAX_AEAD_SG); |
1283 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, |
1284 | - iv_dma, ivsize, op_type, 0, 0); |
1285 | + sg_table = &edesc->sgt[0]; |
1286 | + qm_sg_bytes = qm_sg_ents * sizeof(*sg_table); |
1287 | + if (unlikely(offsetof(struct aead_edesc, sgt) + qm_sg_bytes + ivsize > |
1288 | + CAAM_QI_MEMCACHE_SIZE)) { |
1289 | + dev_err(qidev, "No space for %d S/G entries and/or %dB IV\n", |
1290 | + qm_sg_ents, ivsize); |
1291 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, |
1292 | + 0, 0, 0, 0); |
1293 | qi_cache_free(edesc); |
1294 | return ERR_PTR(-ENOMEM); |
1295 | } |
1296 | - sg_table = &edesc->sgt[0]; |
1297 | - qm_sg_bytes = qm_sg_ents * sizeof(*sg_table); |
1298 | + |
1299 | + if (ivsize) { |
1300 | + u8 *iv = (u8 *)(sg_table + qm_sg_ents); |
1301 | + |
1302 | + /* Make sure IV is located in a DMAable area */ |
1303 | + memcpy(iv, req->iv, ivsize); |
1304 | + |
1305 | + iv_dma = dma_map_single(qidev, iv, ivsize, DMA_TO_DEVICE); |
1306 | + if (dma_mapping_error(qidev, iv_dma)) { |
1307 | + dev_err(qidev, "unable to map IV\n"); |
1308 | + caam_unmap(qidev, req->src, req->dst, src_nents, |
1309 | + dst_nents, 0, 0, 0, 0, 0); |
1310 | + qi_cache_free(edesc); |
1311 | + return ERR_PTR(-ENOMEM); |
1312 | + } |
1313 | + } |
1314 | |
1315 | edesc->src_nents = src_nents; |
1316 | edesc->dst_nents = dst_nents; |
1317 | @@ -1166,15 +1168,27 @@ static void ablkcipher_done(struct caam_drv_req *drv_req, u32 status) |
1318 | #endif |
1319 | |
1320 | ablkcipher_unmap(qidev, edesc, req); |
1321 | - qi_cache_free(edesc); |
1322 | + |
1323 | + /* In case initial IV was generated, copy it in GIVCIPHER request */ |
1324 | + if (edesc->drv_req.drv_ctx->op_type == GIVENCRYPT) { |
1325 | + u8 *iv; |
1326 | + struct skcipher_givcrypt_request *greq; |
1327 | + |
1328 | + greq = container_of(req, struct skcipher_givcrypt_request, |
1329 | + creq); |
1330 | + iv = (u8 *)edesc->sgt + edesc->qm_sg_bytes; |
1331 | + memcpy(greq->giv, iv, ivsize); |
1332 | + } |
1333 | |
1334 | /* |
1335 | * The crypto API expects us to set the IV (req->info) to the last |
1336 | * ciphertext block. This is used e.g. by the CTS mode. |
1337 | */ |
1338 | - scatterwalk_map_and_copy(req->info, req->dst, req->nbytes - ivsize, |
1339 | - ivsize, 0); |
1340 | + if (edesc->drv_req.drv_ctx->op_type != DECRYPT) |
1341 | + scatterwalk_map_and_copy(req->info, req->dst, req->nbytes - |
1342 | + ivsize, ivsize, 0); |
1343 | |
1344 | + qi_cache_free(edesc); |
1345 | ablkcipher_request_complete(req, status); |
1346 | } |
1347 | |
1348 | @@ -1189,9 +1203,9 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request |
1349 | int src_nents, mapped_src_nents, dst_nents = 0, mapped_dst_nents = 0; |
1350 | struct ablkcipher_edesc *edesc; |
1351 | dma_addr_t iv_dma; |
1352 | - bool in_contig; |
1353 | + u8 *iv; |
1354 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); |
1355 | - int dst_sg_idx, qm_sg_ents; |
1356 | + int dst_sg_idx, qm_sg_ents, qm_sg_bytes; |
1357 | struct qm_sg_entry *sg_table, *fd_sgt; |
1358 | struct caam_drv_ctx *drv_ctx; |
1359 | enum optype op_type = encrypt ? ENCRYPT : DECRYPT; |
1360 | @@ -1238,55 +1252,53 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request |
1361 | } |
1362 | } |
1363 | |
1364 | - iv_dma = dma_map_single(qidev, req->info, ivsize, DMA_TO_DEVICE); |
1365 | - if (dma_mapping_error(qidev, iv_dma)) { |
1366 | - dev_err(qidev, "unable to map IV\n"); |
1367 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, |
1368 | - 0, 0, 0, 0); |
1369 | - return ERR_PTR(-ENOMEM); |
1370 | - } |
1371 | - |
1372 | - if (mapped_src_nents == 1 && |
1373 | - iv_dma + ivsize == sg_dma_address(req->src)) { |
1374 | - in_contig = true; |
1375 | - qm_sg_ents = 0; |
1376 | - } else { |
1377 | - in_contig = false; |
1378 | - qm_sg_ents = 1 + mapped_src_nents; |
1379 | - } |
1380 | + qm_sg_ents = 1 + mapped_src_nents; |
1381 | dst_sg_idx = qm_sg_ents; |
1382 | |
1383 | qm_sg_ents += mapped_dst_nents > 1 ? mapped_dst_nents : 0; |
1384 | - if (unlikely(qm_sg_ents > CAAM_QI_MAX_ABLKCIPHER_SG)) { |
1385 | - dev_err(qidev, "Insufficient S/G entries: %d > %zu\n", |
1386 | - qm_sg_ents, CAAM_QI_MAX_ABLKCIPHER_SG); |
1387 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, |
1388 | - iv_dma, ivsize, op_type, 0, 0); |
1389 | + qm_sg_bytes = qm_sg_ents * sizeof(struct qm_sg_entry); |
1390 | + if (unlikely(offsetof(struct ablkcipher_edesc, sgt) + qm_sg_bytes + |
1391 | + ivsize > CAAM_QI_MEMCACHE_SIZE)) { |
1392 | + dev_err(qidev, "No space for %d S/G entries and/or %dB IV\n", |
1393 | + qm_sg_ents, ivsize); |
1394 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, |
1395 | + 0, 0, 0, 0); |
1396 | return ERR_PTR(-ENOMEM); |
1397 | } |
1398 | |
1399 | - /* allocate space for base edesc and link tables */ |
1400 | + /* allocate space for base edesc, link tables and IV */ |
1401 | edesc = qi_cache_alloc(GFP_DMA | flags); |
1402 | if (unlikely(!edesc)) { |
1403 | dev_err(qidev, "could not allocate extended descriptor\n"); |
1404 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, |
1405 | - iv_dma, ivsize, op_type, 0, 0); |
1406 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, |
1407 | + 0, 0, 0, 0); |
1408 | + return ERR_PTR(-ENOMEM); |
1409 | + } |
1410 | + |
1411 | + /* Make sure IV is located in a DMAable area */ |
1412 | + sg_table = &edesc->sgt[0]; |
1413 | + iv = (u8 *)(sg_table + qm_sg_ents); |
1414 | + memcpy(iv, req->info, ivsize); |
1415 | + |
1416 | + iv_dma = dma_map_single(qidev, iv, ivsize, DMA_TO_DEVICE); |
1417 | + if (dma_mapping_error(qidev, iv_dma)) { |
1418 | + dev_err(qidev, "unable to map IV\n"); |
1419 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, |
1420 | + 0, 0, 0, 0); |
1421 | + qi_cache_free(edesc); |
1422 | return ERR_PTR(-ENOMEM); |
1423 | } |
1424 | |
1425 | edesc->src_nents = src_nents; |
1426 | edesc->dst_nents = dst_nents; |
1427 | edesc->iv_dma = iv_dma; |
1428 | - sg_table = &edesc->sgt[0]; |
1429 | - edesc->qm_sg_bytes = qm_sg_ents * sizeof(*sg_table); |
1430 | + edesc->qm_sg_bytes = qm_sg_bytes; |
1431 | edesc->drv_req.app_ctx = req; |
1432 | edesc->drv_req.cbk = ablkcipher_done; |
1433 | edesc->drv_req.drv_ctx = drv_ctx; |
1434 | |
1435 | - if (!in_contig) { |
1436 | - dma_to_qm_sg_one(sg_table, iv_dma, ivsize, 0); |
1437 | - sg_to_qm_sg_last(req->src, mapped_src_nents, sg_table + 1, 0); |
1438 | - } |
1439 | + dma_to_qm_sg_one(sg_table, iv_dma, ivsize, 0); |
1440 | + sg_to_qm_sg_last(req->src, mapped_src_nents, sg_table + 1, 0); |
1441 | |
1442 | if (mapped_dst_nents > 1) |
1443 | sg_to_qm_sg_last(req->dst, mapped_dst_nents, sg_table + |
1444 | @@ -1304,20 +1316,12 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request |
1445 | |
1446 | fd_sgt = &edesc->drv_req.fd_sgt[0]; |
1447 | |
1448 | - if (!in_contig) |
1449 | - dma_to_qm_sg_one_last_ext(&fd_sgt[1], edesc->qm_sg_dma, |
1450 | - ivsize + req->nbytes, 0); |
1451 | - else |
1452 | - dma_to_qm_sg_one_last(&fd_sgt[1], iv_dma, ivsize + req->nbytes, |
1453 | - 0); |
1454 | + dma_to_qm_sg_one_last_ext(&fd_sgt[1], edesc->qm_sg_dma, |
1455 | + ivsize + req->nbytes, 0); |
1456 | |
1457 | if (req->src == req->dst) { |
1458 | - if (!in_contig) |
1459 | - dma_to_qm_sg_one_ext(&fd_sgt[0], edesc->qm_sg_dma + |
1460 | - sizeof(*sg_table), req->nbytes, 0); |
1461 | - else |
1462 | - dma_to_qm_sg_one(&fd_sgt[0], sg_dma_address(req->src), |
1463 | - req->nbytes, 0); |
1464 | + dma_to_qm_sg_one_ext(&fd_sgt[0], edesc->qm_sg_dma + |
1465 | + sizeof(*sg_table), req->nbytes, 0); |
1466 | } else if (mapped_dst_nents > 1) { |
1467 | dma_to_qm_sg_one_ext(&fd_sgt[0], edesc->qm_sg_dma + dst_sg_idx * |
1468 | sizeof(*sg_table), req->nbytes, 0); |
1469 | @@ -1341,10 +1345,10 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( |
1470 | int src_nents, mapped_src_nents, dst_nents, mapped_dst_nents; |
1471 | struct ablkcipher_edesc *edesc; |
1472 | dma_addr_t iv_dma; |
1473 | - bool out_contig; |
1474 | + u8 *iv; |
1475 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); |
1476 | struct qm_sg_entry *sg_table, *fd_sgt; |
1477 | - int dst_sg_idx, qm_sg_ents; |
1478 | + int dst_sg_idx, qm_sg_ents, qm_sg_bytes; |
1479 | struct caam_drv_ctx *drv_ctx; |
1480 | |
1481 | drv_ctx = get_drv_ctx(ctx, GIVENCRYPT); |
1482 | @@ -1392,46 +1396,45 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( |
1483 | mapped_dst_nents = src_nents; |
1484 | } |
1485 | |
1486 | - iv_dma = dma_map_single(qidev, creq->giv, ivsize, DMA_FROM_DEVICE); |
1487 | - if (dma_mapping_error(qidev, iv_dma)) { |
1488 | - dev_err(qidev, "unable to map IV\n"); |
1489 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, |
1490 | - 0, 0, 0, 0); |
1491 | - return ERR_PTR(-ENOMEM); |
1492 | - } |
1493 | - |
1494 | qm_sg_ents = mapped_src_nents > 1 ? mapped_src_nents : 0; |
1495 | dst_sg_idx = qm_sg_ents; |
1496 | - if (mapped_dst_nents == 1 && |
1497 | - iv_dma + ivsize == sg_dma_address(req->dst)) { |
1498 | - out_contig = true; |
1499 | - } else { |
1500 | - out_contig = false; |
1501 | - qm_sg_ents += 1 + mapped_dst_nents; |
1502 | - } |
1503 | |
1504 | - if (unlikely(qm_sg_ents > CAAM_QI_MAX_ABLKCIPHER_SG)) { |
1505 | - dev_err(qidev, "Insufficient S/G entries: %d > %zu\n", |
1506 | - qm_sg_ents, CAAM_QI_MAX_ABLKCIPHER_SG); |
1507 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, |
1508 | - iv_dma, ivsize, GIVENCRYPT, 0, 0); |
1509 | + qm_sg_ents += 1 + mapped_dst_nents; |
1510 | + qm_sg_bytes = qm_sg_ents * sizeof(struct qm_sg_entry); |
1511 | + if (unlikely(offsetof(struct ablkcipher_edesc, sgt) + qm_sg_bytes + |
1512 | + ivsize > CAAM_QI_MEMCACHE_SIZE)) { |
1513 | + dev_err(qidev, "No space for %d S/G entries and/or %dB IV\n", |
1514 | + qm_sg_ents, ivsize); |
1515 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, |
1516 | + 0, 0, 0, 0); |
1517 | return ERR_PTR(-ENOMEM); |
1518 | } |
1519 | |
1520 | - /* allocate space for base edesc and link tables */ |
1521 | + /* allocate space for base edesc, link tables and IV */ |
1522 | edesc = qi_cache_alloc(GFP_DMA | flags); |
1523 | if (!edesc) { |
1524 | dev_err(qidev, "could not allocate extended descriptor\n"); |
1525 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, |
1526 | - iv_dma, ivsize, GIVENCRYPT, 0, 0); |
1527 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, |
1528 | + 0, 0, 0, 0); |
1529 | + return ERR_PTR(-ENOMEM); |
1530 | + } |
1531 | + |
1532 | + /* Make sure IV is located in a DMAable area */ |
1533 | + sg_table = &edesc->sgt[0]; |
1534 | + iv = (u8 *)(sg_table + qm_sg_ents); |
1535 | + iv_dma = dma_map_single(qidev, iv, ivsize, DMA_FROM_DEVICE); |
1536 | + if (dma_mapping_error(qidev, iv_dma)) { |
1537 | + dev_err(qidev, "unable to map IV\n"); |
1538 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, |
1539 | + 0, 0, 0, 0); |
1540 | + qi_cache_free(edesc); |
1541 | return ERR_PTR(-ENOMEM); |
1542 | } |
1543 | |
1544 | edesc->src_nents = src_nents; |
1545 | edesc->dst_nents = dst_nents; |
1546 | edesc->iv_dma = iv_dma; |
1547 | - sg_table = &edesc->sgt[0]; |
1548 | - edesc->qm_sg_bytes = qm_sg_ents * sizeof(*sg_table); |
1549 | + edesc->qm_sg_bytes = qm_sg_bytes; |
1550 | edesc->drv_req.app_ctx = req; |
1551 | edesc->drv_req.cbk = ablkcipher_done; |
1552 | edesc->drv_req.drv_ctx = drv_ctx; |
1553 | @@ -1439,11 +1442,9 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( |
1554 | if (mapped_src_nents > 1) |
1555 | sg_to_qm_sg_last(req->src, mapped_src_nents, sg_table, 0); |
1556 | |
1557 | - if (!out_contig) { |
1558 | - dma_to_qm_sg_one(sg_table + dst_sg_idx, iv_dma, ivsize, 0); |
1559 | - sg_to_qm_sg_last(req->dst, mapped_dst_nents, sg_table + |
1560 | - dst_sg_idx + 1, 0); |
1561 | - } |
1562 | + dma_to_qm_sg_one(sg_table + dst_sg_idx, iv_dma, ivsize, 0); |
1563 | + sg_to_qm_sg_last(req->dst, mapped_dst_nents, sg_table + dst_sg_idx + 1, |
1564 | + 0); |
1565 | |
1566 | edesc->qm_sg_dma = dma_map_single(qidev, sg_table, edesc->qm_sg_bytes, |
1567 | DMA_TO_DEVICE); |
1568 | @@ -1464,13 +1465,8 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( |
1569 | dma_to_qm_sg_one(&fd_sgt[1], sg_dma_address(req->src), |
1570 | req->nbytes, 0); |
1571 | |
1572 | - if (!out_contig) |
1573 | - dma_to_qm_sg_one_ext(&fd_sgt[0], edesc->qm_sg_dma + dst_sg_idx * |
1574 | - sizeof(*sg_table), ivsize + req->nbytes, |
1575 | - 0); |
1576 | - else |
1577 | - dma_to_qm_sg_one(&fd_sgt[0], sg_dma_address(req->dst), |
1578 | - ivsize + req->nbytes, 0); |
1579 | + dma_to_qm_sg_one_ext(&fd_sgt[0], edesc->qm_sg_dma + dst_sg_idx * |
1580 | + sizeof(*sg_table), ivsize + req->nbytes, 0); |
1581 | |
1582 | return edesc; |
1583 | } |
1584 | @@ -1480,6 +1476,7 @@ static inline int ablkcipher_crypt(struct ablkcipher_request *req, bool encrypt) |
1585 | struct ablkcipher_edesc *edesc; |
1586 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); |
1587 | struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher); |
1588 | + int ivsize = crypto_ablkcipher_ivsize(ablkcipher); |
1589 | int ret; |
1590 | |
1591 | if (unlikely(caam_congested)) |
1592 | @@ -1490,6 +1487,14 @@ static inline int ablkcipher_crypt(struct ablkcipher_request *req, bool encrypt) |
1593 | if (IS_ERR(edesc)) |
1594 | return PTR_ERR(edesc); |
1595 | |
1596 | + /* |
1597 | + * The crypto API expects us to set the IV (req->info) to the last |
1598 | + * ciphertext block. |
1599 | + */ |
1600 | + if (!encrypt) |
1601 | + scatterwalk_map_and_copy(req->info, req->src, req->nbytes - |
1602 | + ivsize, ivsize, 0); |
1603 | + |
1604 | ret = caam_qi_enqueue(ctx->qidev, &edesc->drv_req); |
1605 | if (!ret) { |
1606 | ret = -EINPROGRESS; |
1607 | diff --git a/drivers/crypto/caam/caampkc.c b/drivers/crypto/caam/caampkc.c |
1608 | index 7a897209f181..7ff4a25440ac 100644 |
1609 | --- a/drivers/crypto/caam/caampkc.c |
1610 | +++ b/drivers/crypto/caam/caampkc.c |
1611 | @@ -66,7 +66,7 @@ static void rsa_priv_f2_unmap(struct device *dev, struct rsa_edesc *edesc, |
1612 | struct caam_rsa_key *key = &ctx->key; |
1613 | struct rsa_priv_f2_pdb *pdb = &edesc->pdb.priv_f2; |
1614 | size_t p_sz = key->p_sz; |
1615 | - size_t q_sz = key->p_sz; |
1616 | + size_t q_sz = key->q_sz; |
1617 | |
1618 | dma_unmap_single(dev, pdb->d_dma, key->d_sz, DMA_TO_DEVICE); |
1619 | dma_unmap_single(dev, pdb->p_dma, p_sz, DMA_TO_DEVICE); |
1620 | @@ -83,7 +83,7 @@ static void rsa_priv_f3_unmap(struct device *dev, struct rsa_edesc *edesc, |
1621 | struct caam_rsa_key *key = &ctx->key; |
1622 | struct rsa_priv_f3_pdb *pdb = &edesc->pdb.priv_f3; |
1623 | size_t p_sz = key->p_sz; |
1624 | - size_t q_sz = key->p_sz; |
1625 | + size_t q_sz = key->q_sz; |
1626 | |
1627 | dma_unmap_single(dev, pdb->p_dma, p_sz, DMA_TO_DEVICE); |
1628 | dma_unmap_single(dev, pdb->q_dma, q_sz, DMA_TO_DEVICE); |
1629 | @@ -166,18 +166,71 @@ static void rsa_priv_f3_done(struct device *dev, u32 *desc, u32 err, |
1630 | akcipher_request_complete(req, err); |
1631 | } |
1632 | |
1633 | +static int caam_rsa_count_leading_zeros(struct scatterlist *sgl, |
1634 | + unsigned int nbytes, |
1635 | + unsigned int flags) |
1636 | +{ |
1637 | + struct sg_mapping_iter miter; |
1638 | + int lzeros, ents; |
1639 | + unsigned int len; |
1640 | + unsigned int tbytes = nbytes; |
1641 | + const u8 *buff; |
1642 | + |
1643 | + ents = sg_nents_for_len(sgl, nbytes); |
1644 | + if (ents < 0) |
1645 | + return ents; |
1646 | + |
1647 | + sg_miter_start(&miter, sgl, ents, SG_MITER_FROM_SG | flags); |
1648 | + |
1649 | + lzeros = 0; |
1650 | + len = 0; |
1651 | + while (nbytes > 0) { |
1652 | + while (len && !*buff) { |
1653 | + lzeros++; |
1654 | + len--; |
1655 | + buff++; |
1656 | + } |
1657 | + |
1658 | + if (len && *buff) |
1659 | + break; |
1660 | + |
1661 | + sg_miter_next(&miter); |
1662 | + buff = miter.addr; |
1663 | + len = miter.length; |
1664 | + |
1665 | + nbytes -= lzeros; |
1666 | + lzeros = 0; |
1667 | + } |
1668 | + |
1669 | + miter.consumed = lzeros; |
1670 | + sg_miter_stop(&miter); |
1671 | + nbytes -= lzeros; |
1672 | + |
1673 | + return tbytes - nbytes; |
1674 | +} |
1675 | + |
1676 | static struct rsa_edesc *rsa_edesc_alloc(struct akcipher_request *req, |
1677 | size_t desclen) |
1678 | { |
1679 | struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req); |
1680 | struct caam_rsa_ctx *ctx = akcipher_tfm_ctx(tfm); |
1681 | struct device *dev = ctx->dev; |
1682 | + struct caam_rsa_req_ctx *req_ctx = akcipher_request_ctx(req); |
1683 | struct rsa_edesc *edesc; |
1684 | gfp_t flags = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? |
1685 | GFP_KERNEL : GFP_ATOMIC; |
1686 | + int sg_flags = (flags == GFP_ATOMIC) ? SG_MITER_ATOMIC : 0; |
1687 | int sgc; |
1688 | int sec4_sg_index, sec4_sg_len = 0, sec4_sg_bytes; |
1689 | int src_nents, dst_nents; |
1690 | + int lzeros; |
1691 | + |
1692 | + lzeros = caam_rsa_count_leading_zeros(req->src, req->src_len, sg_flags); |
1693 | + if (lzeros < 0) |
1694 | + return ERR_PTR(lzeros); |
1695 | + |
1696 | + req->src_len -= lzeros; |
1697 | + req->src = scatterwalk_ffwd(req_ctx->src, req->src, lzeros); |
1698 | |
1699 | src_nents = sg_nents_for_len(req->src, req->src_len); |
1700 | dst_nents = sg_nents_for_len(req->dst, req->dst_len); |
1701 | @@ -344,7 +397,7 @@ static int set_rsa_priv_f2_pdb(struct akcipher_request *req, |
1702 | struct rsa_priv_f2_pdb *pdb = &edesc->pdb.priv_f2; |
1703 | int sec4_sg_index = 0; |
1704 | size_t p_sz = key->p_sz; |
1705 | - size_t q_sz = key->p_sz; |
1706 | + size_t q_sz = key->q_sz; |
1707 | |
1708 | pdb->d_dma = dma_map_single(dev, key->d, key->d_sz, DMA_TO_DEVICE); |
1709 | if (dma_mapping_error(dev, pdb->d_dma)) { |
1710 | @@ -419,7 +472,7 @@ static int set_rsa_priv_f3_pdb(struct akcipher_request *req, |
1711 | struct rsa_priv_f3_pdb *pdb = &edesc->pdb.priv_f3; |
1712 | int sec4_sg_index = 0; |
1713 | size_t p_sz = key->p_sz; |
1714 | - size_t q_sz = key->p_sz; |
1715 | + size_t q_sz = key->q_sz; |
1716 | |
1717 | pdb->p_dma = dma_map_single(dev, key->p, p_sz, DMA_TO_DEVICE); |
1718 | if (dma_mapping_error(dev, pdb->p_dma)) { |
1719 | @@ -953,6 +1006,7 @@ static struct akcipher_alg caam_rsa = { |
1720 | .max_size = caam_rsa_max_size, |
1721 | .init = caam_rsa_init_tfm, |
1722 | .exit = caam_rsa_exit_tfm, |
1723 | + .reqsize = sizeof(struct caam_rsa_req_ctx), |
1724 | .base = { |
1725 | .cra_name = "rsa", |
1726 | .cra_driver_name = "rsa-caam", |
1727 | diff --git a/drivers/crypto/caam/caampkc.h b/drivers/crypto/caam/caampkc.h |
1728 | index fd145c46eae1..82645bcf8b27 100644 |
1729 | --- a/drivers/crypto/caam/caampkc.h |
1730 | +++ b/drivers/crypto/caam/caampkc.h |
1731 | @@ -95,6 +95,14 @@ struct caam_rsa_ctx { |
1732 | struct device *dev; |
1733 | }; |
1734 | |
1735 | +/** |
1736 | + * caam_rsa_req_ctx - per request context. |
1737 | + * @src: input scatterlist (stripped of leading zeros) |
1738 | + */ |
1739 | +struct caam_rsa_req_ctx { |
1740 | + struct scatterlist src[2]; |
1741 | +}; |
1742 | + |
1743 | /** |
1744 | * rsa_edesc - s/w-extended rsa descriptor |
1745 | * @src_nents : number of segments in input scatterlist |
1746 | diff --git a/drivers/crypto/cavium/zip/common.h b/drivers/crypto/cavium/zip/common.h |
1747 | index dc451e0a43c5..58fb3ed6e644 100644 |
1748 | --- a/drivers/crypto/cavium/zip/common.h |
1749 | +++ b/drivers/crypto/cavium/zip/common.h |
1750 | @@ -46,8 +46,10 @@ |
1751 | #ifndef __COMMON_H__ |
1752 | #define __COMMON_H__ |
1753 | |
1754 | +#include <linux/delay.h> |
1755 | #include <linux/init.h> |
1756 | #include <linux/interrupt.h> |
1757 | +#include <linux/io.h> |
1758 | #include <linux/kernel.h> |
1759 | #include <linux/module.h> |
1760 | #include <linux/pci.h> |
1761 | @@ -149,6 +151,25 @@ struct zip_operation { |
1762 | u32 sizeofzops; |
1763 | }; |
1764 | |
1765 | +static inline int zip_poll_result(union zip_zres_s *result) |
1766 | +{ |
1767 | + int retries = 1000; |
1768 | + |
1769 | + while (!result->s.compcode) { |
1770 | + if (!--retries) { |
1771 | + pr_err("ZIP ERR: request timed out"); |
1772 | + return -ETIMEDOUT; |
1773 | + } |
1774 | + udelay(10); |
1775 | + /* |
1776 | + * Force re-reading of compcode which is updated |
1777 | + * by the ZIP coprocessor. |
1778 | + */ |
1779 | + rmb(); |
1780 | + } |
1781 | + return 0; |
1782 | +} |
1783 | + |
1784 | /* error messages */ |
1785 | #define zip_err(fmt, args...) pr_err("ZIP ERR:%s():%d: " \ |
1786 | fmt "\n", __func__, __LINE__, ## args) |
1787 | diff --git a/drivers/crypto/cavium/zip/zip_crypto.c b/drivers/crypto/cavium/zip/zip_crypto.c |
1788 | index 8df4d26cf9d4..b92b6e7e100f 100644 |
1789 | --- a/drivers/crypto/cavium/zip/zip_crypto.c |
1790 | +++ b/drivers/crypto/cavium/zip/zip_crypto.c |
1791 | @@ -124,7 +124,7 @@ int zip_compress(const u8 *src, unsigned int slen, |
1792 | struct zip_kernel_ctx *zip_ctx) |
1793 | { |
1794 | struct zip_operation *zip_ops = NULL; |
1795 | - struct zip_state zip_state; |
1796 | + struct zip_state *zip_state; |
1797 | struct zip_device *zip = NULL; |
1798 | int ret; |
1799 | |
1800 | @@ -135,20 +135,23 @@ int zip_compress(const u8 *src, unsigned int slen, |
1801 | if (!zip) |
1802 | return -ENODEV; |
1803 | |
1804 | - memset(&zip_state, 0, sizeof(struct zip_state)); |
1805 | + zip_state = kzalloc(sizeof(*zip_state), GFP_ATOMIC); |
1806 | + if (!zip_state) |
1807 | + return -ENOMEM; |
1808 | + |
1809 | zip_ops = &zip_ctx->zip_comp; |
1810 | |
1811 | zip_ops->input_len = slen; |
1812 | zip_ops->output_len = *dlen; |
1813 | memcpy(zip_ops->input, src, slen); |
1814 | |
1815 | - ret = zip_deflate(zip_ops, &zip_state, zip); |
1816 | + ret = zip_deflate(zip_ops, zip_state, zip); |
1817 | |
1818 | if (!ret) { |
1819 | *dlen = zip_ops->output_len; |
1820 | memcpy(dst, zip_ops->output, *dlen); |
1821 | } |
1822 | - |
1823 | + kfree(zip_state); |
1824 | return ret; |
1825 | } |
1826 | |
1827 | @@ -157,7 +160,7 @@ int zip_decompress(const u8 *src, unsigned int slen, |
1828 | struct zip_kernel_ctx *zip_ctx) |
1829 | { |
1830 | struct zip_operation *zip_ops = NULL; |
1831 | - struct zip_state zip_state; |
1832 | + struct zip_state *zip_state; |
1833 | struct zip_device *zip = NULL; |
1834 | int ret; |
1835 | |
1836 | @@ -168,7 +171,10 @@ int zip_decompress(const u8 *src, unsigned int slen, |
1837 | if (!zip) |
1838 | return -ENODEV; |
1839 | |
1840 | - memset(&zip_state, 0, sizeof(struct zip_state)); |
1841 | + zip_state = kzalloc(sizeof(*zip_state), GFP_ATOMIC); |
1842 | + if (!zip_state) |
1843 | + return -ENOMEM; |
1844 | + |
1845 | zip_ops = &zip_ctx->zip_decomp; |
1846 | memcpy(zip_ops->input, src, slen); |
1847 | |
1848 | @@ -179,13 +185,13 @@ int zip_decompress(const u8 *src, unsigned int slen, |
1849 | zip_ops->input_len = slen; |
1850 | zip_ops->output_len = *dlen; |
1851 | |
1852 | - ret = zip_inflate(zip_ops, &zip_state, zip); |
1853 | + ret = zip_inflate(zip_ops, zip_state, zip); |
1854 | |
1855 | if (!ret) { |
1856 | *dlen = zip_ops->output_len; |
1857 | memcpy(dst, zip_ops->output, *dlen); |
1858 | } |
1859 | - |
1860 | + kfree(zip_state); |
1861 | return ret; |
1862 | } |
1863 | |
1864 | diff --git a/drivers/crypto/cavium/zip/zip_deflate.c b/drivers/crypto/cavium/zip/zip_deflate.c |
1865 | index 9a944b8c1e29..d7133f857d67 100644 |
1866 | --- a/drivers/crypto/cavium/zip/zip_deflate.c |
1867 | +++ b/drivers/crypto/cavium/zip/zip_deflate.c |
1868 | @@ -129,8 +129,8 @@ int zip_deflate(struct zip_operation *zip_ops, struct zip_state *s, |
1869 | /* Stats update for compression requests submitted */ |
1870 | atomic64_inc(&zip_dev->stats.comp_req_submit); |
1871 | |
1872 | - while (!result_ptr->s.compcode) |
1873 | - continue; |
1874 | + /* Wait for completion or error */ |
1875 | + zip_poll_result(result_ptr); |
1876 | |
1877 | /* Stats update for compression requests completed */ |
1878 | atomic64_inc(&zip_dev->stats.comp_req_complete); |
1879 | diff --git a/drivers/crypto/cavium/zip/zip_inflate.c b/drivers/crypto/cavium/zip/zip_inflate.c |
1880 | index 50cbdd83dbf2..7e0d73e2f89e 100644 |
1881 | --- a/drivers/crypto/cavium/zip/zip_inflate.c |
1882 | +++ b/drivers/crypto/cavium/zip/zip_inflate.c |
1883 | @@ -143,8 +143,8 @@ int zip_inflate(struct zip_operation *zip_ops, struct zip_state *s, |
1884 | /* Decompression requests submitted stats update */ |
1885 | atomic64_inc(&zip_dev->stats.decomp_req_submit); |
1886 | |
1887 | - while (!result_ptr->s.compcode) |
1888 | - continue; |
1889 | + /* Wait for completion or error */ |
1890 | + zip_poll_result(result_ptr); |
1891 | |
1892 | /* Decompression requests completed stats update */ |
1893 | atomic64_inc(&zip_dev->stats.decomp_req_complete); |
1894 | diff --git a/drivers/crypto/ccree/cc_debugfs.c b/drivers/crypto/ccree/cc_debugfs.c |
1895 | index 08f8db489cf0..5ca184e42483 100644 |
1896 | --- a/drivers/crypto/ccree/cc_debugfs.c |
1897 | +++ b/drivers/crypto/ccree/cc_debugfs.c |
1898 | @@ -26,7 +26,8 @@ struct cc_debugfs_ctx { |
1899 | static struct dentry *cc_debugfs_dir; |
1900 | |
1901 | static struct debugfs_reg32 debug_regs[] = { |
1902 | - CC_DEBUG_REG(HOST_SIGNATURE), |
1903 | + { .name = "SIGNATURE" }, /* Must be 0th */ |
1904 | + { .name = "VERSION" }, /* Must be 1st */ |
1905 | CC_DEBUG_REG(HOST_IRR), |
1906 | CC_DEBUG_REG(HOST_POWER_DOWN_EN), |
1907 | CC_DEBUG_REG(AXIM_MON_ERR), |
1908 | @@ -34,7 +35,6 @@ static struct debugfs_reg32 debug_regs[] = { |
1909 | CC_DEBUG_REG(HOST_IMR), |
1910 | CC_DEBUG_REG(AXIM_CFG), |
1911 | CC_DEBUG_REG(AXIM_CACHE_PARAMS), |
1912 | - CC_DEBUG_REG(HOST_VERSION), |
1913 | CC_DEBUG_REG(GPR_HOST), |
1914 | CC_DEBUG_REG(AXIM_MON_COMP), |
1915 | }; |
1916 | @@ -58,6 +58,9 @@ int cc_debugfs_init(struct cc_drvdata *drvdata) |
1917 | struct debugfs_regset32 *regset; |
1918 | struct dentry *file; |
1919 | |
1920 | + debug_regs[0].offset = drvdata->sig_offset; |
1921 | + debug_regs[1].offset = drvdata->ver_offset; |
1922 | + |
1923 | ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); |
1924 | if (!ctx) |
1925 | return -ENOMEM; |
1926 | diff --git a/drivers/crypto/ccree/cc_driver.c b/drivers/crypto/ccree/cc_driver.c |
1927 | index 89ce013ae093..6f93ce7701ec 100644 |
1928 | --- a/drivers/crypto/ccree/cc_driver.c |
1929 | +++ b/drivers/crypto/ccree/cc_driver.c |
1930 | @@ -207,9 +207,13 @@ static int init_cc_resources(struct platform_device *plat_dev) |
1931 | if (hw_rev->rev >= CC_HW_REV_712) { |
1932 | new_drvdata->hash_len_sz = HASH_LEN_SIZE_712; |
1933 | new_drvdata->axim_mon_offset = CC_REG(AXIM_MON_COMP); |
1934 | + new_drvdata->sig_offset = CC_REG(HOST_SIGNATURE_712); |
1935 | + new_drvdata->ver_offset = CC_REG(HOST_VERSION_712); |
1936 | } else { |
1937 | new_drvdata->hash_len_sz = HASH_LEN_SIZE_630; |
1938 | new_drvdata->axim_mon_offset = CC_REG(AXIM_MON_COMP8); |
1939 | + new_drvdata->sig_offset = CC_REG(HOST_SIGNATURE_630); |
1940 | + new_drvdata->ver_offset = CC_REG(HOST_VERSION_630); |
1941 | } |
1942 | |
1943 | platform_set_drvdata(plat_dev, new_drvdata); |
1944 | @@ -276,7 +280,7 @@ static int init_cc_resources(struct platform_device *plat_dev) |
1945 | } |
1946 | |
1947 | /* Verify correct mapping */ |
1948 | - signature_val = cc_ioread(new_drvdata, CC_REG(HOST_SIGNATURE)); |
1949 | + signature_val = cc_ioread(new_drvdata, new_drvdata->sig_offset); |
1950 | if (signature_val != hw_rev->sig) { |
1951 | dev_err(dev, "Invalid CC signature: SIGNATURE=0x%08X != expected=0x%08X\n", |
1952 | signature_val, hw_rev->sig); |
1953 | @@ -287,7 +291,7 @@ static int init_cc_resources(struct platform_device *plat_dev) |
1954 | |
1955 | /* Display HW versions */ |
1956 | dev_info(dev, "ARM CryptoCell %s Driver: HW version 0x%08X, Driver version %s\n", |
1957 | - hw_rev->name, cc_ioread(new_drvdata, CC_REG(HOST_VERSION)), |
1958 | + hw_rev->name, cc_ioread(new_drvdata, new_drvdata->ver_offset), |
1959 | DRV_MODULE_VERSION); |
1960 | |
1961 | rc = init_cc_regs(new_drvdata, true); |
1962 | diff --git a/drivers/crypto/ccree/cc_driver.h b/drivers/crypto/ccree/cc_driver.h |
1963 | index 2048fdeb9579..95f82b2d1e70 100644 |
1964 | --- a/drivers/crypto/ccree/cc_driver.h |
1965 | +++ b/drivers/crypto/ccree/cc_driver.h |
1966 | @@ -129,6 +129,8 @@ struct cc_drvdata { |
1967 | enum cc_hw_rev hw_rev; |
1968 | u32 hash_len_sz; |
1969 | u32 axim_mon_offset; |
1970 | + u32 sig_offset; |
1971 | + u32 ver_offset; |
1972 | }; |
1973 | |
1974 | struct cc_crypto_alg { |
1975 | diff --git a/drivers/crypto/ccree/cc_host_regs.h b/drivers/crypto/ccree/cc_host_regs.h |
1976 | index f51001898ca1..616b2e1c41ba 100644 |
1977 | --- a/drivers/crypto/ccree/cc_host_regs.h |
1978 | +++ b/drivers/crypto/ccree/cc_host_regs.h |
1979 | @@ -45,7 +45,8 @@ |
1980 | #define CC_HOST_ICR_DSCRPTR_WATERMARK_QUEUE0_CLEAR_BIT_SIZE 0x1UL |
1981 | #define CC_HOST_ICR_AXIM_COMP_INT_CLEAR_BIT_SHIFT 0x17UL |
1982 | #define CC_HOST_ICR_AXIM_COMP_INT_CLEAR_BIT_SIZE 0x1UL |
1983 | -#define CC_HOST_SIGNATURE_REG_OFFSET 0xA24UL |
1984 | +#define CC_HOST_SIGNATURE_712_REG_OFFSET 0xA24UL |
1985 | +#define CC_HOST_SIGNATURE_630_REG_OFFSET 0xAC8UL |
1986 | #define CC_HOST_SIGNATURE_VALUE_BIT_SHIFT 0x0UL |
1987 | #define CC_HOST_SIGNATURE_VALUE_BIT_SIZE 0x20UL |
1988 | #define CC_HOST_BOOT_REG_OFFSET 0xA28UL |
1989 | @@ -105,7 +106,8 @@ |
1990 | #define CC_HOST_BOOT_ONLY_ENCRYPT_LOCAL_BIT_SIZE 0x1UL |
1991 | #define CC_HOST_BOOT_AES_EXISTS_LOCAL_BIT_SHIFT 0x1EUL |
1992 | #define CC_HOST_BOOT_AES_EXISTS_LOCAL_BIT_SIZE 0x1UL |
1993 | -#define CC_HOST_VERSION_REG_OFFSET 0xA40UL |
1994 | +#define CC_HOST_VERSION_712_REG_OFFSET 0xA40UL |
1995 | +#define CC_HOST_VERSION_630_REG_OFFSET 0xAD8UL |
1996 | #define CC_HOST_VERSION_VALUE_BIT_SHIFT 0x0UL |
1997 | #define CC_HOST_VERSION_VALUE_BIT_SIZE 0x20UL |
1998 | #define CC_HOST_KFDE0_VALID_REG_OFFSET 0xA60UL |
1999 | diff --git a/drivers/crypto/chelsio/chcr_ipsec.c b/drivers/crypto/chelsio/chcr_ipsec.c |
2000 | index 8e0aa3f175c9..461b97e2f1fd 100644 |
2001 | --- a/drivers/crypto/chelsio/chcr_ipsec.c |
2002 | +++ b/drivers/crypto/chelsio/chcr_ipsec.c |
2003 | @@ -346,18 +346,23 @@ inline void *copy_cpltx_pktxt(struct sk_buff *skb, |
2004 | struct net_device *dev, |
2005 | void *pos) |
2006 | { |
2007 | + struct cpl_tx_pkt_core *cpl; |
2008 | + struct sge_eth_txq *q; |
2009 | struct adapter *adap; |
2010 | struct port_info *pi; |
2011 | - struct sge_eth_txq *q; |
2012 | - struct cpl_tx_pkt_core *cpl; |
2013 | - u64 cntrl = 0; |
2014 | u32 ctrl0, qidx; |
2015 | + u64 cntrl = 0; |
2016 | + int left; |
2017 | |
2018 | pi = netdev_priv(dev); |
2019 | adap = pi->adapter; |
2020 | qidx = skb->queue_mapping; |
2021 | q = &adap->sge.ethtxq[qidx + pi->first_qset]; |
2022 | |
2023 | + left = (void *)q->q.stat - pos; |
2024 | + if (!left) |
2025 | + pos = q->q.desc; |
2026 | + |
2027 | cpl = (struct cpl_tx_pkt_core *)pos; |
2028 | |
2029 | cntrl = TXPKT_L4CSUM_DIS_F | TXPKT_IPCSUM_DIS_F; |
2030 | @@ -382,18 +387,17 @@ inline void *copy_key_cpltx_pktxt(struct sk_buff *skb, |
2031 | void *pos, |
2032 | struct ipsec_sa_entry *sa_entry) |
2033 | { |
2034 | - struct adapter *adap; |
2035 | - struct port_info *pi; |
2036 | - struct sge_eth_txq *q; |
2037 | - unsigned int len, qidx; |
2038 | struct _key_ctx *key_ctx; |
2039 | int left, eoq, key_len; |
2040 | + struct sge_eth_txq *q; |
2041 | + struct adapter *adap; |
2042 | + struct port_info *pi; |
2043 | + unsigned int qidx; |
2044 | |
2045 | pi = netdev_priv(dev); |
2046 | adap = pi->adapter; |
2047 | qidx = skb->queue_mapping; |
2048 | q = &adap->sge.ethtxq[qidx + pi->first_qset]; |
2049 | - len = sa_entry->enckey_len + sizeof(struct cpl_tx_pkt_core); |
2050 | key_len = sa_entry->kctx_len; |
2051 | |
2052 | /* end of queue, reset pos to start of queue */ |
2053 | @@ -411,19 +415,14 @@ inline void *copy_key_cpltx_pktxt(struct sk_buff *skb, |
2054 | pos += sizeof(struct _key_ctx); |
2055 | left -= sizeof(struct _key_ctx); |
2056 | |
2057 | - if (likely(len <= left)) { |
2058 | + if (likely(key_len <= left)) { |
2059 | memcpy(key_ctx->key, sa_entry->key, key_len); |
2060 | pos += key_len; |
2061 | } else { |
2062 | - if (key_len <= left) { |
2063 | - memcpy(pos, sa_entry->key, key_len); |
2064 | - pos += key_len; |
2065 | - } else { |
2066 | - memcpy(pos, sa_entry->key, left); |
2067 | - memcpy(q->q.desc, sa_entry->key + left, |
2068 | - key_len - left); |
2069 | - pos = (u8 *)q->q.desc + (key_len - left); |
2070 | - } |
2071 | + memcpy(pos, sa_entry->key, left); |
2072 | + memcpy(q->q.desc, sa_entry->key + left, |
2073 | + key_len - left); |
2074 | + pos = (u8 *)q->q.desc + (key_len - left); |
2075 | } |
2076 | /* Copy CPL TX PKT XT */ |
2077 | pos = copy_cpltx_pktxt(skb, dev, pos); |
2078 | diff --git a/drivers/crypto/omap-sham.c b/drivers/crypto/omap-sham.c |
2079 | index ad02aa63b519..d1a1c74fb56a 100644 |
2080 | --- a/drivers/crypto/omap-sham.c |
2081 | +++ b/drivers/crypto/omap-sham.c |
2082 | @@ -1087,7 +1087,7 @@ static void omap_sham_finish_req(struct ahash_request *req, int err) |
2083 | |
2084 | if (test_bit(FLAGS_SGS_COPIED, &dd->flags)) |
2085 | free_pages((unsigned long)sg_virt(ctx->sg), |
2086 | - get_order(ctx->sg->length)); |
2087 | + get_order(ctx->sg->length + ctx->bufcnt)); |
2088 | |
2089 | if (test_bit(FLAGS_SGS_ALLOCED, &dd->flags)) |
2090 | kfree(ctx->sg); |
2091 | diff --git a/drivers/crypto/vmx/aes.c b/drivers/crypto/vmx/aes.c |
2092 | index 96072b9b55c4..d7316f7a3a69 100644 |
2093 | --- a/drivers/crypto/vmx/aes.c |
2094 | +++ b/drivers/crypto/vmx/aes.c |
2095 | @@ -48,8 +48,6 @@ static int p8_aes_init(struct crypto_tfm *tfm) |
2096 | alg, PTR_ERR(fallback)); |
2097 | return PTR_ERR(fallback); |
2098 | } |
2099 | - printk(KERN_INFO "Using '%s' as fallback implementation.\n", |
2100 | - crypto_tfm_alg_driver_name((struct crypto_tfm *) fallback)); |
2101 | |
2102 | crypto_cipher_set_flags(fallback, |
2103 | crypto_cipher_get_flags((struct |
2104 | diff --git a/drivers/crypto/vmx/aes_cbc.c b/drivers/crypto/vmx/aes_cbc.c |
2105 | index 7394d35d5936..5285ece4f33a 100644 |
2106 | --- a/drivers/crypto/vmx/aes_cbc.c |
2107 | +++ b/drivers/crypto/vmx/aes_cbc.c |
2108 | @@ -52,9 +52,6 @@ static int p8_aes_cbc_init(struct crypto_tfm *tfm) |
2109 | alg, PTR_ERR(fallback)); |
2110 | return PTR_ERR(fallback); |
2111 | } |
2112 | - printk(KERN_INFO "Using '%s' as fallback implementation.\n", |
2113 | - crypto_skcipher_driver_name(fallback)); |
2114 | - |
2115 | |
2116 | crypto_skcipher_set_flags( |
2117 | fallback, |
2118 | diff --git a/drivers/crypto/vmx/aes_ctr.c b/drivers/crypto/vmx/aes_ctr.c |
2119 | index fc60d00a2e84..cd777c75291d 100644 |
2120 | --- a/drivers/crypto/vmx/aes_ctr.c |
2121 | +++ b/drivers/crypto/vmx/aes_ctr.c |
2122 | @@ -50,8 +50,6 @@ static int p8_aes_ctr_init(struct crypto_tfm *tfm) |
2123 | alg, PTR_ERR(fallback)); |
2124 | return PTR_ERR(fallback); |
2125 | } |
2126 | - printk(KERN_INFO "Using '%s' as fallback implementation.\n", |
2127 | - crypto_skcipher_driver_name(fallback)); |
2128 | |
2129 | crypto_skcipher_set_flags( |
2130 | fallback, |
2131 | diff --git a/drivers/crypto/vmx/aes_xts.c b/drivers/crypto/vmx/aes_xts.c |
2132 | index 8cd6e62e4c90..8bd9aff0f55f 100644 |
2133 | --- a/drivers/crypto/vmx/aes_xts.c |
2134 | +++ b/drivers/crypto/vmx/aes_xts.c |
2135 | @@ -53,8 +53,6 @@ static int p8_aes_xts_init(struct crypto_tfm *tfm) |
2136 | alg, PTR_ERR(fallback)); |
2137 | return PTR_ERR(fallback); |
2138 | } |
2139 | - printk(KERN_INFO "Using '%s' as fallback implementation.\n", |
2140 | - crypto_skcipher_driver_name(fallback)); |
2141 | |
2142 | crypto_skcipher_set_flags( |
2143 | fallback, |
2144 | diff --git a/drivers/crypto/vmx/ghash.c b/drivers/crypto/vmx/ghash.c |
2145 | index 27a94a119009..1c4b5b889fba 100644 |
2146 | --- a/drivers/crypto/vmx/ghash.c |
2147 | +++ b/drivers/crypto/vmx/ghash.c |
2148 | @@ -64,8 +64,6 @@ static int p8_ghash_init_tfm(struct crypto_tfm *tfm) |
2149 | alg, PTR_ERR(fallback)); |
2150 | return PTR_ERR(fallback); |
2151 | } |
2152 | - printk(KERN_INFO "Using '%s' as fallback implementation.\n", |
2153 | - crypto_tfm_alg_driver_name(crypto_shash_tfm(fallback))); |
2154 | |
2155 | crypto_shash_set_flags(fallback, |
2156 | crypto_shash_get_flags((struct crypto_shash |
2157 | diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c |
2158 | index 06e9650b3b30..a89b81b35932 100644 |
2159 | --- a/drivers/input/joystick/xpad.c |
2160 | +++ b/drivers/input/joystick/xpad.c |
2161 | @@ -123,6 +123,7 @@ static const struct xpad_device { |
2162 | u8 mapping; |
2163 | u8 xtype; |
2164 | } xpad_device[] = { |
2165 | + { 0x0079, 0x18d4, "GPD Win 2 Controller", 0, XTYPE_XBOX360 }, |
2166 | { 0x044f, 0x0f00, "Thrustmaster Wheel", 0, XTYPE_XBOX }, |
2167 | { 0x044f, 0x0f03, "Thrustmaster Wheel", 0, XTYPE_XBOX }, |
2168 | { 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX }, |
2169 | @@ -409,6 +410,7 @@ static const signed short xpad_abs_triggers[] = { |
2170 | |
2171 | static const struct usb_device_id xpad_table[] = { |
2172 | { USB_INTERFACE_INFO('X', 'B', 0) }, /* X-Box USB-IF not approved class */ |
2173 | + XPAD_XBOX360_VENDOR(0x0079), /* GPD Win 2 Controller */ |
2174 | XPAD_XBOX360_VENDOR(0x044f), /* Thrustmaster X-Box 360 controllers */ |
2175 | XPAD_XBOX360_VENDOR(0x045e), /* Microsoft X-Box 360 controllers */ |
2176 | XPAD_XBOXONE_VENDOR(0x045e), /* Microsoft X-Box One controllers */ |
2177 | diff --git a/drivers/input/mouse/elan_i2c_core.c b/drivers/input/mouse/elan_i2c_core.c |
2178 | index 75e757520ef0..93967c8139e7 100644 |
2179 | --- a/drivers/input/mouse/elan_i2c_core.c |
2180 | +++ b/drivers/input/mouse/elan_i2c_core.c |
2181 | @@ -1262,6 +1262,7 @@ static const struct acpi_device_id elan_acpi_id[] = { |
2182 | { "ELAN060B", 0 }, |
2183 | { "ELAN060C", 0 }, |
2184 | { "ELAN0611", 0 }, |
2185 | + { "ELAN0612", 0 }, |
2186 | { "ELAN1000", 0 }, |
2187 | { } |
2188 | }; |
2189 | diff --git a/drivers/input/touchscreen/goodix.c b/drivers/input/touchscreen/goodix.c |
2190 | index 9736c83dd418..f2d9c2c41885 100644 |
2191 | --- a/drivers/input/touchscreen/goodix.c |
2192 | +++ b/drivers/input/touchscreen/goodix.c |
2193 | @@ -933,6 +933,7 @@ MODULE_DEVICE_TABLE(i2c, goodix_ts_id); |
2194 | #ifdef CONFIG_ACPI |
2195 | static const struct acpi_device_id goodix_acpi_match[] = { |
2196 | { "GDIX1001", 0 }, |
2197 | + { "GDIX1002", 0 }, |
2198 | { } |
2199 | }; |
2200 | MODULE_DEVICE_TABLE(acpi, goodix_acpi_match); |
2201 | diff --git a/drivers/misc/vmw_balloon.c b/drivers/misc/vmw_balloon.c |
2202 | index 9047c0a529b2..efd733472a35 100644 |
2203 | --- a/drivers/misc/vmw_balloon.c |
2204 | +++ b/drivers/misc/vmw_balloon.c |
2205 | @@ -576,15 +576,9 @@ static void vmballoon_pop(struct vmballoon *b) |
2206 | } |
2207 | } |
2208 | |
2209 | - if (b->batch_page) { |
2210 | - vunmap(b->batch_page); |
2211 | - b->batch_page = NULL; |
2212 | - } |
2213 | - |
2214 | - if (b->page) { |
2215 | - __free_page(b->page); |
2216 | - b->page = NULL; |
2217 | - } |
2218 | + /* Clearing the batch_page unconditionally has no adverse effect */ |
2219 | + free_page((unsigned long)b->batch_page); |
2220 | + b->batch_page = NULL; |
2221 | } |
2222 | |
2223 | /* |
2224 | @@ -991,16 +985,13 @@ static const struct vmballoon_ops vmballoon_batched_ops = { |
2225 | |
2226 | static bool vmballoon_init_batching(struct vmballoon *b) |
2227 | { |
2228 | - b->page = alloc_page(VMW_PAGE_ALLOC_NOSLEEP); |
2229 | - if (!b->page) |
2230 | - return false; |
2231 | + struct page *page; |
2232 | |
2233 | - b->batch_page = vmap(&b->page, 1, VM_MAP, PAGE_KERNEL); |
2234 | - if (!b->batch_page) { |
2235 | - __free_page(b->page); |
2236 | + page = alloc_page(GFP_KERNEL | __GFP_ZERO); |
2237 | + if (!page) |
2238 | return false; |
2239 | - } |
2240 | |
2241 | + b->batch_page = page_address(page); |
2242 | return true; |
2243 | } |
2244 | |
2245 | diff --git a/drivers/nfc/pn533/usb.c b/drivers/nfc/pn533/usb.c |
2246 | index e153e8b64bb8..d5553c47014f 100644 |
2247 | --- a/drivers/nfc/pn533/usb.c |
2248 | +++ b/drivers/nfc/pn533/usb.c |
2249 | @@ -62,6 +62,9 @@ struct pn533_usb_phy { |
2250 | struct urb *out_urb; |
2251 | struct urb *in_urb; |
2252 | |
2253 | + struct urb *ack_urb; |
2254 | + u8 *ack_buffer; |
2255 | + |
2256 | struct pn533 *priv; |
2257 | }; |
2258 | |
2259 | @@ -150,13 +153,16 @@ static int pn533_usb_send_ack(struct pn533 *dev, gfp_t flags) |
2260 | struct pn533_usb_phy *phy = dev->phy; |
2261 | static const u8 ack[6] = {0x00, 0x00, 0xff, 0x00, 0xff, 0x00}; |
2262 | /* spec 7.1.1.3: Preamble, SoPC (2), ACK Code (2), Postamble */ |
2263 | - int rc; |
2264 | |
2265 | - phy->out_urb->transfer_buffer = (u8 *)ack; |
2266 | - phy->out_urb->transfer_buffer_length = sizeof(ack); |
2267 | - rc = usb_submit_urb(phy->out_urb, flags); |
2268 | + if (!phy->ack_buffer) { |
2269 | + phy->ack_buffer = kmemdup(ack, sizeof(ack), flags); |
2270 | + if (!phy->ack_buffer) |
2271 | + return -ENOMEM; |
2272 | + } |
2273 | |
2274 | - return rc; |
2275 | + phy->ack_urb->transfer_buffer = phy->ack_buffer; |
2276 | + phy->ack_urb->transfer_buffer_length = sizeof(ack); |
2277 | + return usb_submit_urb(phy->ack_urb, flags); |
2278 | } |
2279 | |
2280 | static int pn533_usb_send_frame(struct pn533 *dev, |
2281 | @@ -375,26 +381,31 @@ static int pn533_acr122_poweron_rdr(struct pn533_usb_phy *phy) |
2282 | /* Power on th reader (CCID cmd) */ |
2283 | u8 cmd[10] = {PN533_ACR122_PC_TO_RDR_ICCPOWERON, |
2284 | 0, 0, 0, 0, 0, 0, 3, 0, 0}; |
2285 | + char *buffer; |
2286 | + int transferred; |
2287 | int rc; |
2288 | void *cntx; |
2289 | struct pn533_acr122_poweron_rdr_arg arg; |
2290 | |
2291 | dev_dbg(&phy->udev->dev, "%s\n", __func__); |
2292 | |
2293 | + buffer = kmemdup(cmd, sizeof(cmd), GFP_KERNEL); |
2294 | + if (!buffer) |
2295 | + return -ENOMEM; |
2296 | + |
2297 | init_completion(&arg.done); |
2298 | cntx = phy->in_urb->context; /* backup context */ |
2299 | |
2300 | phy->in_urb->complete = pn533_acr122_poweron_rdr_resp; |
2301 | phy->in_urb->context = &arg; |
2302 | |
2303 | - phy->out_urb->transfer_buffer = cmd; |
2304 | - phy->out_urb->transfer_buffer_length = sizeof(cmd); |
2305 | - |
2306 | print_hex_dump_debug("ACR122 TX: ", DUMP_PREFIX_NONE, 16, 1, |
2307 | cmd, sizeof(cmd), false); |
2308 | |
2309 | - rc = usb_submit_urb(phy->out_urb, GFP_KERNEL); |
2310 | - if (rc) { |
2311 | + rc = usb_bulk_msg(phy->udev, phy->out_urb->pipe, buffer, sizeof(cmd), |
2312 | + &transferred, 0); |
2313 | + kfree(buffer); |
2314 | + if (rc || (transferred != sizeof(cmd))) { |
2315 | nfc_err(&phy->udev->dev, |
2316 | "Reader power on cmd error %d\n", rc); |
2317 | return rc; |
2318 | @@ -490,8 +501,9 @@ static int pn533_usb_probe(struct usb_interface *interface, |
2319 | |
2320 | phy->in_urb = usb_alloc_urb(0, GFP_KERNEL); |
2321 | phy->out_urb = usb_alloc_urb(0, GFP_KERNEL); |
2322 | + phy->ack_urb = usb_alloc_urb(0, GFP_KERNEL); |
2323 | |
2324 | - if (!phy->in_urb || !phy->out_urb) |
2325 | + if (!phy->in_urb || !phy->out_urb || !phy->ack_urb) |
2326 | goto error; |
2327 | |
2328 | usb_fill_bulk_urb(phy->in_urb, phy->udev, |
2329 | @@ -501,7 +513,9 @@ static int pn533_usb_probe(struct usb_interface *interface, |
2330 | usb_fill_bulk_urb(phy->out_urb, phy->udev, |
2331 | usb_sndbulkpipe(phy->udev, out_endpoint), |
2332 | NULL, 0, pn533_send_complete, phy); |
2333 | - |
2334 | + usb_fill_bulk_urb(phy->ack_urb, phy->udev, |
2335 | + usb_sndbulkpipe(phy->udev, out_endpoint), |
2336 | + NULL, 0, pn533_send_complete, phy); |
2337 | |
2338 | switch (id->driver_info) { |
2339 | case PN533_DEVICE_STD: |
2340 | @@ -554,6 +568,7 @@ static int pn533_usb_probe(struct usb_interface *interface, |
2341 | error: |
2342 | usb_free_urb(phy->in_urb); |
2343 | usb_free_urb(phy->out_urb); |
2344 | + usb_free_urb(phy->ack_urb); |
2345 | usb_put_dev(phy->udev); |
2346 | kfree(in_buf); |
2347 | |
2348 | @@ -573,10 +588,13 @@ static void pn533_usb_disconnect(struct usb_interface *interface) |
2349 | |
2350 | usb_kill_urb(phy->in_urb); |
2351 | usb_kill_urb(phy->out_urb); |
2352 | + usb_kill_urb(phy->ack_urb); |
2353 | |
2354 | kfree(phy->in_urb->transfer_buffer); |
2355 | usb_free_urb(phy->in_urb); |
2356 | usb_free_urb(phy->out_urb); |
2357 | + usb_free_urb(phy->ack_urb); |
2358 | + kfree(phy->ack_buffer); |
2359 | |
2360 | nfc_info(&interface->dev, "NXP PN533 NFC device disconnected\n"); |
2361 | } |
2362 | diff --git a/drivers/phy/qualcomm/phy-qcom-qusb2.c b/drivers/phy/qualcomm/phy-qcom-qusb2.c |
2363 | index 94afeac1a19e..40fdef8b5b75 100644 |
2364 | --- a/drivers/phy/qualcomm/phy-qcom-qusb2.c |
2365 | +++ b/drivers/phy/qualcomm/phy-qcom-qusb2.c |
2366 | @@ -315,6 +315,10 @@ static void qusb2_phy_set_tune2_param(struct qusb2_phy *qphy) |
2367 | const struct qusb2_phy_cfg *cfg = qphy->cfg; |
2368 | u8 *val; |
2369 | |
2370 | + /* efuse register is optional */ |
2371 | + if (!qphy->cell) |
2372 | + return; |
2373 | + |
2374 | /* |
2375 | * Read efuse register having TUNE2/1 parameter's high nibble. |
2376 | * If efuse register shows value as 0x0, or if we fail to find |
2377 | diff --git a/drivers/staging/android/ion/ion.c b/drivers/staging/android/ion/ion.c |
2378 | index e74db7902549..a68329411b29 100644 |
2379 | --- a/drivers/staging/android/ion/ion.c |
2380 | +++ b/drivers/staging/android/ion/ion.c |
2381 | @@ -114,8 +114,11 @@ static struct ion_buffer *ion_buffer_create(struct ion_heap *heap, |
2382 | |
2383 | void ion_buffer_destroy(struct ion_buffer *buffer) |
2384 | { |
2385 | - if (WARN_ON(buffer->kmap_cnt > 0)) |
2386 | + if (buffer->kmap_cnt > 0) { |
2387 | + pr_warn_once("%s: buffer still mapped in the kernel\n", |
2388 | + __func__); |
2389 | buffer->heap->ops->unmap_kernel(buffer->heap, buffer); |
2390 | + } |
2391 | buffer->heap->ops->free(buffer); |
2392 | kfree(buffer); |
2393 | } |
2394 | diff --git a/drivers/tty/serial/8250/8250_omap.c b/drivers/tty/serial/8250/8250_omap.c |
2395 | index 624b501fd253..93de20e87abe 100644 |
2396 | --- a/drivers/tty/serial/8250/8250_omap.c |
2397 | +++ b/drivers/tty/serial/8250/8250_omap.c |
2398 | @@ -1110,13 +1110,14 @@ static int omap8250_no_handle_irq(struct uart_port *port) |
2399 | return 0; |
2400 | } |
2401 | |
2402 | +static const u8 omap4_habit = UART_ERRATA_CLOCK_DISABLE; |
2403 | static const u8 am3352_habit = OMAP_DMA_TX_KICK | UART_ERRATA_CLOCK_DISABLE; |
2404 | static const u8 dra742_habit = UART_ERRATA_CLOCK_DISABLE; |
2405 | |
2406 | static const struct of_device_id omap8250_dt_ids[] = { |
2407 | { .compatible = "ti,omap2-uart" }, |
2408 | { .compatible = "ti,omap3-uart" }, |
2409 | - { .compatible = "ti,omap4-uart" }, |
2410 | + { .compatible = "ti,omap4-uart", .data = &omap4_habit, }, |
2411 | { .compatible = "ti,am3352-uart", .data = &am3352_habit, }, |
2412 | { .compatible = "ti,am4372-uart", .data = &am3352_habit, }, |
2413 | { .compatible = "ti,dra742-uart", .data = &dra742_habit, }, |
2414 | @@ -1353,6 +1354,19 @@ static int omap8250_soft_reset(struct device *dev) |
2415 | int sysc; |
2416 | int syss; |
2417 | |
2418 | + /* |
2419 | + * At least on omap4, unused uarts may not idle after reset without |
2420 | + * a basic scr dma configuration even with no dma in use. The |
2421 | + * module clkctrl status bits will be 1 instead of 3 blocking idle |
2422 | + * for the whole clockdomain. The softreset below will clear scr, |
2423 | + * and we restore it on resume so this is safe to do on all SoCs |
2424 | + * needing omap8250_soft_reset() quirk. Do it in two writes as |
2425 | + * recommended in the comment for omap8250_update_scr(). |
2426 | + */ |
2427 | + serial_out(up, UART_OMAP_SCR, OMAP_UART_SCR_DMAMODE_1); |
2428 | + serial_out(up, UART_OMAP_SCR, |
2429 | + OMAP_UART_SCR_DMAMODE_1 | OMAP_UART_SCR_DMAMODE_CTL); |
2430 | + |
2431 | sysc = serial_in(up, UART_OMAP_SYSC); |
2432 | |
2433 | /* softreset the UART */ |
2434 | diff --git a/drivers/tty/serial/amba-pl011.c b/drivers/tty/serial/amba-pl011.c |
2435 | index 4b40a5b449ee..ebd33c0232e6 100644 |
2436 | --- a/drivers/tty/serial/amba-pl011.c |
2437 | +++ b/drivers/tty/serial/amba-pl011.c |
2438 | @@ -1727,10 +1727,26 @@ static int pl011_allocate_irq(struct uart_amba_port *uap) |
2439 | */ |
2440 | static void pl011_enable_interrupts(struct uart_amba_port *uap) |
2441 | { |
2442 | + unsigned int i; |
2443 | + |
2444 | spin_lock_irq(&uap->port.lock); |
2445 | |
2446 | /* Clear out any spuriously appearing RX interrupts */ |
2447 | pl011_write(UART011_RTIS | UART011_RXIS, uap, REG_ICR); |
2448 | + |
2449 | + /* |
2450 | + * RXIS is asserted only when the RX FIFO transitions from below |
2451 | + * to above the trigger threshold. If the RX FIFO is already |
2452 | + * full to the threshold this can't happen and RXIS will now be |
2453 | + * stuck off. Drain the RX FIFO explicitly to fix this: |
2454 | + */ |
2455 | + for (i = 0; i < uap->fifosize * 2; ++i) { |
2456 | + if (pl011_read(uap, REG_FR) & UART01x_FR_RXFE) |
2457 | + break; |
2458 | + |
2459 | + pl011_read(uap, REG_DR); |
2460 | + } |
2461 | + |
2462 | uap->im = UART011_RTIM; |
2463 | if (!pl011_dma_rx_running(uap)) |
2464 | uap->im |= UART011_RXIM; |
2465 | diff --git a/drivers/tty/serial/atmel_serial.c b/drivers/tty/serial/atmel_serial.c |
2466 | index e287fe8f10fc..55b3eff148b1 100644 |
2467 | --- a/drivers/tty/serial/atmel_serial.c |
2468 | +++ b/drivers/tty/serial/atmel_serial.c |
2469 | @@ -1757,7 +1757,6 @@ static int atmel_startup(struct uart_port *port) |
2470 | { |
2471 | struct platform_device *pdev = to_platform_device(port->dev); |
2472 | struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); |
2473 | - struct tty_struct *tty = port->state->port.tty; |
2474 | int retval; |
2475 | |
2476 | /* |
2477 | @@ -1772,8 +1771,8 @@ static int atmel_startup(struct uart_port *port) |
2478 | * Allocate the IRQ |
2479 | */ |
2480 | retval = request_irq(port->irq, atmel_interrupt, |
2481 | - IRQF_SHARED | IRQF_COND_SUSPEND, |
2482 | - tty ? tty->name : "atmel_serial", port); |
2483 | + IRQF_SHARED | IRQF_COND_SUSPEND, |
2484 | + dev_name(&pdev->dev), port); |
2485 | if (retval) { |
2486 | dev_err(port->dev, "atmel_startup - Can't get irq\n"); |
2487 | return retval; |
2488 | diff --git a/drivers/tty/serial/samsung.c b/drivers/tty/serial/samsung.c |
2489 | index 3f2f8c118ce0..64e96926f1ad 100644 |
2490 | --- a/drivers/tty/serial/samsung.c |
2491 | +++ b/drivers/tty/serial/samsung.c |
2492 | @@ -862,15 +862,12 @@ static int s3c24xx_serial_request_dma(struct s3c24xx_uart_port *p) |
2493 | dma->rx_conf.direction = DMA_DEV_TO_MEM; |
2494 | dma->rx_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE; |
2495 | dma->rx_conf.src_addr = p->port.mapbase + S3C2410_URXH; |
2496 | - dma->rx_conf.src_maxburst = 16; |
2497 | + dma->rx_conf.src_maxburst = 1; |
2498 | |
2499 | dma->tx_conf.direction = DMA_MEM_TO_DEV; |
2500 | dma->tx_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE; |
2501 | dma->tx_conf.dst_addr = p->port.mapbase + S3C2410_UTXH; |
2502 | - if (dma_get_cache_alignment() >= 16) |
2503 | - dma->tx_conf.dst_maxburst = 16; |
2504 | - else |
2505 | - dma->tx_conf.dst_maxburst = 1; |
2506 | + dma->tx_conf.dst_maxburst = 1; |
2507 | |
2508 | dma->rx_chan = dma_request_chan(p->port.dev, "rx"); |
2509 | |
2510 | diff --git a/drivers/tty/serial/sh-sci.c b/drivers/tty/serial/sh-sci.c |
2511 | index fdbbff547106..a4f82ec665fe 100644 |
2512 | --- a/drivers/tty/serial/sh-sci.c |
2513 | +++ b/drivers/tty/serial/sh-sci.c |
2514 | @@ -2704,8 +2704,8 @@ static int sci_init_clocks(struct sci_port *sci_port, struct device *dev) |
2515 | dev_dbg(dev, "failed to get %s (%ld)\n", clk_names[i], |
2516 | PTR_ERR(clk)); |
2517 | else |
2518 | - dev_dbg(dev, "clk %s is %pC rate %pCr\n", clk_names[i], |
2519 | - clk, clk); |
2520 | + dev_dbg(dev, "clk %s is %pC rate %lu\n", clk_names[i], |
2521 | + clk, clk_get_rate(clk)); |
2522 | sci_port->clks[i] = IS_ERR(clk) ? NULL : clk; |
2523 | } |
2524 | return 0; |
2525 | diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c |
2526 | index 0c11d40a12bc..7b137003c2be 100644 |
2527 | --- a/drivers/usb/core/message.c |
2528 | +++ b/drivers/usb/core/message.c |
2529 | @@ -940,7 +940,7 @@ int usb_set_isoch_delay(struct usb_device *dev) |
2530 | return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), |
2531 | USB_REQ_SET_ISOCH_DELAY, |
2532 | USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE, |
2533 | - cpu_to_le16(dev->hub_delay), 0, NULL, 0, |
2534 | + dev->hub_delay, 0, NULL, 0, |
2535 | USB_CTRL_SET_TIMEOUT); |
2536 | } |
2537 | |
2538 | diff --git a/drivers/usb/gadget/function/f_printer.c b/drivers/usb/gadget/function/f_printer.c |
2539 | index d359efe06c76..9c7ed2539ff7 100644 |
2540 | --- a/drivers/usb/gadget/function/f_printer.c |
2541 | +++ b/drivers/usb/gadget/function/f_printer.c |
2542 | @@ -631,19 +631,19 @@ printer_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr) |
2543 | return -EAGAIN; |
2544 | } |
2545 | |
2546 | + list_add(&req->list, &dev->tx_reqs_active); |
2547 | + |
2548 | /* here, we unlock, and only unlock, to avoid deadlock. */ |
2549 | spin_unlock(&dev->lock); |
2550 | value = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC); |
2551 | spin_lock(&dev->lock); |
2552 | if (value) { |
2553 | + list_del(&req->list); |
2554 | list_add(&req->list, &dev->tx_reqs); |
2555 | spin_unlock_irqrestore(&dev->lock, flags); |
2556 | mutex_unlock(&dev->lock_printer_io); |
2557 | return -EAGAIN; |
2558 | } |
2559 | - |
2560 | - list_add(&req->list, &dev->tx_reqs_active); |
2561 | - |
2562 | } |
2563 | |
2564 | spin_unlock_irqrestore(&dev->lock, flags); |
2565 | diff --git a/drivers/usb/gadget/udc/renesas_usb3.c b/drivers/usb/gadget/udc/renesas_usb3.c |
2566 | index 409cde4e6a51..5caf78bbbf7c 100644 |
2567 | --- a/drivers/usb/gadget/udc/renesas_usb3.c |
2568 | +++ b/drivers/usb/gadget/udc/renesas_usb3.c |
2569 | @@ -333,6 +333,7 @@ struct renesas_usb3 { |
2570 | struct extcon_dev *extcon; |
2571 | struct work_struct extcon_work; |
2572 | struct phy *phy; |
2573 | + struct dentry *dentry; |
2574 | |
2575 | struct renesas_usb3_ep *usb3_ep; |
2576 | int num_usb3_eps; |
2577 | @@ -622,6 +623,13 @@ static void usb3_disconnect(struct renesas_usb3 *usb3) |
2578 | usb3_usb2_pullup(usb3, 0); |
2579 | usb3_clear_bit(usb3, USB30_CON_B3_CONNECT, USB3_USB30_CON); |
2580 | usb3_reset_epc(usb3); |
2581 | + usb3_disable_irq_1(usb3, USB_INT_1_B2_RSUM | USB_INT_1_B3_PLLWKUP | |
2582 | + USB_INT_1_B3_LUPSUCS | USB_INT_1_B3_DISABLE | |
2583 | + USB_INT_1_SPEED | USB_INT_1_B3_WRMRST | |
2584 | + USB_INT_1_B3_HOTRST | USB_INT_1_B2_SPND | |
2585 | + USB_INT_1_B2_L1SPND | USB_INT_1_B2_USBRST); |
2586 | + usb3_clear_bit(usb3, USB_COM_CON_SPD_MODE, USB3_USB_COM_CON); |
2587 | + usb3_init_epc_registers(usb3); |
2588 | |
2589 | if (usb3->driver) |
2590 | usb3->driver->disconnect(&usb3->gadget); |
2591 | @@ -2393,8 +2401,12 @@ static void renesas_usb3_debugfs_init(struct renesas_usb3 *usb3, |
2592 | |
2593 | file = debugfs_create_file("b_device", 0644, root, usb3, |
2594 | &renesas_usb3_b_device_fops); |
2595 | - if (!file) |
2596 | + if (!file) { |
2597 | dev_info(dev, "%s: Can't create debugfs mode\n", __func__); |
2598 | + debugfs_remove_recursive(root); |
2599 | + } else { |
2600 | + usb3->dentry = root; |
2601 | + } |
2602 | } |
2603 | |
2604 | /*------- platform_driver ------------------------------------------------*/ |
2605 | @@ -2402,14 +2414,13 @@ static int renesas_usb3_remove(struct platform_device *pdev) |
2606 | { |
2607 | struct renesas_usb3 *usb3 = platform_get_drvdata(pdev); |
2608 | |
2609 | + debugfs_remove_recursive(usb3->dentry); |
2610 | device_remove_file(&pdev->dev, &dev_attr_role); |
2611 | |
2612 | usb_del_gadget_udc(&usb3->gadget); |
2613 | renesas_usb3_dma_free_prd(usb3, &pdev->dev); |
2614 | |
2615 | __renesas_usb3_ep_free_request(usb3->ep0_req); |
2616 | - if (usb3->phy) |
2617 | - phy_put(usb3->phy); |
2618 | pm_runtime_disable(&pdev->dev); |
2619 | |
2620 | return 0; |
2621 | @@ -2628,6 +2639,17 @@ static int renesas_usb3_probe(struct platform_device *pdev) |
2622 | if (ret < 0) |
2623 | goto err_alloc_prd; |
2624 | |
2625 | + /* |
2626 | + * This is optional. So, if this driver cannot get a phy, |
2627 | + * this driver will not handle a phy anymore. |
2628 | + */ |
2629 | + usb3->phy = devm_phy_optional_get(&pdev->dev, "usb"); |
2630 | + if (IS_ERR(usb3->phy)) { |
2631 | + ret = PTR_ERR(usb3->phy); |
2632 | + goto err_add_udc; |
2633 | + } |
2634 | + |
2635 | + pm_runtime_enable(&pdev->dev); |
2636 | ret = usb_add_gadget_udc(&pdev->dev, &usb3->gadget); |
2637 | if (ret < 0) |
2638 | goto err_add_udc; |
2639 | @@ -2636,20 +2658,11 @@ static int renesas_usb3_probe(struct platform_device *pdev) |
2640 | if (ret < 0) |
2641 | goto err_dev_create; |
2642 | |
2643 | - /* |
2644 | - * This is an optional. So, if this driver cannot get a phy, |
2645 | - * this driver will not handle a phy anymore. |
2646 | - */ |
2647 | - usb3->phy = devm_phy_get(&pdev->dev, "usb"); |
2648 | - if (IS_ERR(usb3->phy)) |
2649 | - usb3->phy = NULL; |
2650 | - |
2651 | usb3->workaround_for_vbus = priv->workaround_for_vbus; |
2652 | |
2653 | renesas_usb3_debugfs_init(usb3, &pdev->dev); |
2654 | |
2655 | dev_info(&pdev->dev, "probed%s\n", usb3->phy ? " with phy" : ""); |
2656 | - pm_runtime_enable(usb3_to_dev(usb3)); |
2657 | |
2658 | return 0; |
2659 | |
2660 | diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c |
2661 | index 6034c39b67d1..9e9de5452860 100644 |
2662 | --- a/drivers/usb/storage/uas.c |
2663 | +++ b/drivers/usb/storage/uas.c |
2664 | @@ -836,6 +836,12 @@ static int uas_slave_configure(struct scsi_device *sdev) |
2665 | if (devinfo->flags & US_FL_BROKEN_FUA) |
2666 | sdev->broken_fua = 1; |
2667 | |
2668 | + /* UAS also needs to support FL_ALWAYS_SYNC */ |
2669 | + if (devinfo->flags & US_FL_ALWAYS_SYNC) { |
2670 | + sdev->skip_ms_page_3f = 1; |
2671 | + sdev->skip_ms_page_8 = 1; |
2672 | + sdev->wce_default_on = 1; |
2673 | + } |
2674 | scsi_change_queue_depth(sdev, devinfo->qdepth - 2); |
2675 | return 0; |
2676 | } |
2677 | diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h |
2678 | index 747d3a9596d9..22fcfccf453a 100644 |
2679 | --- a/drivers/usb/storage/unusual_devs.h |
2680 | +++ b/drivers/usb/storage/unusual_devs.h |
2681 | @@ -2321,6 +2321,15 @@ UNUSUAL_DEV( 0x4146, 0xba01, 0x0100, 0x0100, |
2682 | "Micro Mini 1GB", |
2683 | USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ), |
2684 | |
2685 | +/* "G-DRIVE" external HDD hangs on write without these. |
2686 | + * Patch submitted by Alexander Kappner <agk@godking.net> |
2687 | + */ |
2688 | +UNUSUAL_DEV(0x4971, 0x8024, 0x0000, 0x9999, |
2689 | + "SimpleTech", |
2690 | + "External HDD", |
2691 | + USB_SC_DEVICE, USB_PR_DEVICE, NULL, |
2692 | + US_FL_ALWAYS_SYNC), |
2693 | + |
2694 | /* |
2695 | * Nick Bowler <nbowler@elliptictech.com> |
2696 | * SCSI stack spams (otherwise harmless) error messages. |
2697 | diff --git a/drivers/usb/storage/unusual_uas.h b/drivers/usb/storage/unusual_uas.h |
2698 | index 38434d88954a..d0bdebd87ce3 100644 |
2699 | --- a/drivers/usb/storage/unusual_uas.h |
2700 | +++ b/drivers/usb/storage/unusual_uas.h |
2701 | @@ -107,3 +107,12 @@ UNUSUAL_DEV(0x4971, 0x8017, 0x0000, 0x9999, |
2702 | "External HDD", |
2703 | USB_SC_DEVICE, USB_PR_DEVICE, NULL, |
2704 | US_FL_NO_REPORT_OPCODES), |
2705 | + |
2706 | +/* "G-DRIVE" external HDD hangs on write without these. |
2707 | + * Patch submitted by Alexander Kappner <agk@godking.net> |
2708 | + */ |
2709 | +UNUSUAL_DEV(0x4971, 0x8024, 0x0000, 0x9999, |
2710 | + "SimpleTech", |
2711 | + "External HDD", |
2712 | + USB_SC_DEVICE, USB_PR_DEVICE, NULL, |
2713 | + US_FL_ALWAYS_SYNC), |
2714 | diff --git a/drivers/usb/typec/typec_wcove.c b/drivers/usb/typec/typec_wcove.c |
2715 | index 19cca7f1b2c5..58dc7ea7cf0d 100644 |
2716 | --- a/drivers/usb/typec/typec_wcove.c |
2717 | +++ b/drivers/usb/typec/typec_wcove.c |
2718 | @@ -202,6 +202,10 @@ static int wcove_init(struct tcpc_dev *tcpc) |
2719 | struct wcove_typec *wcove = tcpc_to_wcove(tcpc); |
2720 | int ret; |
2721 | |
2722 | + ret = regmap_write(wcove->regmap, USBC_CONTROL1, 0); |
2723 | + if (ret) |
2724 | + return ret; |
2725 | + |
2726 | /* Unmask everything */ |
2727 | ret = regmap_write(wcove->regmap, USBC_IRQMASK1, 0); |
2728 | if (ret) |
2729 | @@ -285,8 +289,30 @@ static int wcove_get_cc(struct tcpc_dev *tcpc, enum typec_cc_status *cc1, |
2730 | |
2731 | static int wcove_set_cc(struct tcpc_dev *tcpc, enum typec_cc_status cc) |
2732 | { |
2733 | - /* XXX: Relying on the HW FSM to configure things correctly for now */ |
2734 | - return 0; |
2735 | + struct wcove_typec *wcove = tcpc_to_wcove(tcpc); |
2736 | + unsigned int ctrl; |
2737 | + |
2738 | + switch (cc) { |
2739 | + case TYPEC_CC_RD: |
2740 | + ctrl = USBC_CONTROL1_MODE_SNK; |
2741 | + break; |
2742 | + case TYPEC_CC_RP_DEF: |
2743 | + ctrl = USBC_CONTROL1_CURSRC_UA_80 | USBC_CONTROL1_MODE_SRC; |
2744 | + break; |
2745 | + case TYPEC_CC_RP_1_5: |
2746 | + ctrl = USBC_CONTROL1_CURSRC_UA_180 | USBC_CONTROL1_MODE_SRC; |
2747 | + break; |
2748 | + case TYPEC_CC_RP_3_0: |
2749 | + ctrl = USBC_CONTROL1_CURSRC_UA_330 | USBC_CONTROL1_MODE_SRC; |
2750 | + break; |
2751 | + case TYPEC_CC_OPEN: |
2752 | + ctrl = 0; |
2753 | + break; |
2754 | + default: |
2755 | + return -EINVAL; |
2756 | + } |
2757 | + |
2758 | + return regmap_write(wcove->regmap, USBC_CONTROL1, ctrl); |
2759 | } |
2760 | |
2761 | static int wcove_set_polarity(struct tcpc_dev *tcpc, enum typec_cc_polarity pol) |
2762 | diff --git a/drivers/usb/usbip/vhci_sysfs.c b/drivers/usb/usbip/vhci_sysfs.c |
2763 | index 48808388ec33..be37aec250c2 100644 |
2764 | --- a/drivers/usb/usbip/vhci_sysfs.c |
2765 | +++ b/drivers/usb/usbip/vhci_sysfs.c |
2766 | @@ -10,6 +10,9 @@ |
2767 | #include <linux/platform_device.h> |
2768 | #include <linux/slab.h> |
2769 | |
2770 | +/* Hardening for Spectre-v1 */ |
2771 | +#include <linux/nospec.h> |
2772 | + |
2773 | #include "usbip_common.h" |
2774 | #include "vhci.h" |
2775 | |
2776 | @@ -205,16 +208,20 @@ static int vhci_port_disconnect(struct vhci_hcd *vhci_hcd, __u32 rhport) |
2777 | return 0; |
2778 | } |
2779 | |
2780 | -static int valid_port(__u32 pdev_nr, __u32 rhport) |
2781 | +static int valid_port(__u32 *pdev_nr, __u32 *rhport) |
2782 | { |
2783 | - if (pdev_nr >= vhci_num_controllers) { |
2784 | - pr_err("pdev %u\n", pdev_nr); |
2785 | + if (*pdev_nr >= vhci_num_controllers) { |
2786 | + pr_err("pdev %u\n", *pdev_nr); |
2787 | return 0; |
2788 | } |
2789 | - if (rhport >= VHCI_HC_PORTS) { |
2790 | - pr_err("rhport %u\n", rhport); |
2791 | + *pdev_nr = array_index_nospec(*pdev_nr, vhci_num_controllers); |
2792 | + |
2793 | + if (*rhport >= VHCI_HC_PORTS) { |
2794 | + pr_err("rhport %u\n", *rhport); |
2795 | return 0; |
2796 | } |
2797 | + *rhport = array_index_nospec(*rhport, VHCI_HC_PORTS); |
2798 | + |
2799 | return 1; |
2800 | } |
2801 | |
2802 | @@ -232,7 +239,7 @@ static ssize_t detach_store(struct device *dev, struct device_attribute *attr, |
2803 | pdev_nr = port_to_pdev_nr(port); |
2804 | rhport = port_to_rhport(port); |
2805 | |
2806 | - if (!valid_port(pdev_nr, rhport)) |
2807 | + if (!valid_port(&pdev_nr, &rhport)) |
2808 | return -EINVAL; |
2809 | |
2810 | hcd = platform_get_drvdata(vhcis[pdev_nr].pdev); |
2811 | @@ -258,7 +265,8 @@ static ssize_t detach_store(struct device *dev, struct device_attribute *attr, |
2812 | } |
2813 | static DEVICE_ATTR_WO(detach); |
2814 | |
2815 | -static int valid_args(__u32 pdev_nr, __u32 rhport, enum usb_device_speed speed) |
2816 | +static int valid_args(__u32 *pdev_nr, __u32 *rhport, |
2817 | + enum usb_device_speed speed) |
2818 | { |
2819 | if (!valid_port(pdev_nr, rhport)) { |
2820 | return 0; |
2821 | @@ -322,7 +330,7 @@ static ssize_t attach_store(struct device *dev, struct device_attribute *attr, |
2822 | sockfd, devid, speed); |
2823 | |
2824 | /* check received parameters */ |
2825 | - if (!valid_args(pdev_nr, rhport, speed)) |
2826 | + if (!valid_args(&pdev_nr, &rhport, speed)) |
2827 | return -EINVAL; |
2828 | |
2829 | hcd = platform_get_drvdata(vhcis[pdev_nr].pdev); |
2830 | diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h |
2831 | index b02c41e53d56..39e364c70caf 100644 |
2832 | --- a/include/uapi/linux/kvm.h |
2833 | +++ b/include/uapi/linux/kvm.h |
2834 | @@ -677,10 +677,10 @@ struct kvm_ioeventfd { |
2835 | }; |
2836 | |
2837 | #define KVM_X86_DISABLE_EXITS_MWAIT (1 << 0) |
2838 | -#define KVM_X86_DISABLE_EXITS_HTL (1 << 1) |
2839 | +#define KVM_X86_DISABLE_EXITS_HLT (1 << 1) |
2840 | #define KVM_X86_DISABLE_EXITS_PAUSE (1 << 2) |
2841 | #define KVM_X86_DISABLE_VALID_EXITS (KVM_X86_DISABLE_EXITS_MWAIT | \ |
2842 | - KVM_X86_DISABLE_EXITS_HTL | \ |
2843 | + KVM_X86_DISABLE_EXITS_HLT | \ |
2844 | KVM_X86_DISABLE_EXITS_PAUSE) |
2845 | |
2846 | /* for KVM_ENABLE_CAP */ |
2847 | diff --git a/tools/include/uapi/linux/kvm.h b/tools/include/uapi/linux/kvm.h |
2848 | index b02c41e53d56..39e364c70caf 100644 |
2849 | --- a/tools/include/uapi/linux/kvm.h |
2850 | +++ b/tools/include/uapi/linux/kvm.h |
2851 | @@ -677,10 +677,10 @@ struct kvm_ioeventfd { |
2852 | }; |
2853 | |
2854 | #define KVM_X86_DISABLE_EXITS_MWAIT (1 << 0) |
2855 | -#define KVM_X86_DISABLE_EXITS_HTL (1 << 1) |
2856 | +#define KVM_X86_DISABLE_EXITS_HLT (1 << 1) |
2857 | #define KVM_X86_DISABLE_EXITS_PAUSE (1 << 2) |
2858 | #define KVM_X86_DISABLE_VALID_EXITS (KVM_X86_DISABLE_EXITS_MWAIT | \ |
2859 | - KVM_X86_DISABLE_EXITS_HTL | \ |
2860 | + KVM_X86_DISABLE_EXITS_HLT | \ |
2861 | KVM_X86_DISABLE_EXITS_PAUSE) |
2862 | |
2863 | /* for KVM_ENABLE_CAP */ |