Annotation of /trunk/kernel-alx/patches-4.4/0101-4.4.2-all-fixes.patch
Parent Directory | Revision Log
Revision 2793 -
(hide annotations)
(download)
Mon May 30 12:45:29 2016 UTC (8 years, 3 months ago) by niro
File size: 169991 byte(s)
Mon May 30 12:45:29 2016 UTC (8 years, 3 months ago) by niro
File size: 169991 byte(s)
-linux-4.4.2
1 | niro | 2793 | diff --git a/Makefile b/Makefile |
2 | index c6a265b52c93..e7a2958eb771 100644 | ||
3 | --- a/Makefile | ||
4 | +++ b/Makefile | ||
5 | @@ -1,6 +1,6 @@ | ||
6 | VERSION = 4 | ||
7 | PATCHLEVEL = 4 | ||
8 | -SUBLEVEL = 1 | ||
9 | +SUBLEVEL = 2 | ||
10 | EXTRAVERSION = | ||
11 | NAME = Blurry Fish Butt | ||
12 | |||
13 | diff --git a/arch/parisc/include/asm/hugetlb.h b/arch/parisc/include/asm/hugetlb.h | ||
14 | index 7d56a9ccb752..a65d888716c4 100644 | ||
15 | --- a/arch/parisc/include/asm/hugetlb.h | ||
16 | +++ b/arch/parisc/include/asm/hugetlb.h | ||
17 | @@ -54,24 +54,12 @@ static inline pte_t huge_pte_wrprotect(pte_t pte) | ||
18 | return pte_wrprotect(pte); | ||
19 | } | ||
20 | |||
21 | -static inline void huge_ptep_set_wrprotect(struct mm_struct *mm, | ||
22 | - unsigned long addr, pte_t *ptep) | ||
23 | -{ | ||
24 | - pte_t old_pte = *ptep; | ||
25 | - set_huge_pte_at(mm, addr, ptep, pte_wrprotect(old_pte)); | ||
26 | -} | ||
27 | +void huge_ptep_set_wrprotect(struct mm_struct *mm, | ||
28 | + unsigned long addr, pte_t *ptep); | ||
29 | |||
30 | -static inline int huge_ptep_set_access_flags(struct vm_area_struct *vma, | ||
31 | +int huge_ptep_set_access_flags(struct vm_area_struct *vma, | ||
32 | unsigned long addr, pte_t *ptep, | ||
33 | - pte_t pte, int dirty) | ||
34 | -{ | ||
35 | - int changed = !pte_same(*ptep, pte); | ||
36 | - if (changed) { | ||
37 | - set_huge_pte_at(vma->vm_mm, addr, ptep, pte); | ||
38 | - flush_tlb_page(vma, addr); | ||
39 | - } | ||
40 | - return changed; | ||
41 | -} | ||
42 | + pte_t pte, int dirty); | ||
43 | |||
44 | static inline pte_t huge_ptep_get(pte_t *ptep) | ||
45 | { | ||
46 | diff --git a/arch/parisc/include/uapi/asm/siginfo.h b/arch/parisc/include/uapi/asm/siginfo.h | ||
47 | index d7034728f377..1c75565d984b 100644 | ||
48 | --- a/arch/parisc/include/uapi/asm/siginfo.h | ||
49 | +++ b/arch/parisc/include/uapi/asm/siginfo.h | ||
50 | @@ -1,6 +1,10 @@ | ||
51 | #ifndef _PARISC_SIGINFO_H | ||
52 | #define _PARISC_SIGINFO_H | ||
53 | |||
54 | +#if defined(__LP64__) | ||
55 | +#define __ARCH_SI_PREAMBLE_SIZE (4 * sizeof(int)) | ||
56 | +#endif | ||
57 | + | ||
58 | #include <asm-generic/siginfo.h> | ||
59 | |||
60 | #undef NSIGTRAP | ||
61 | diff --git a/arch/parisc/mm/hugetlbpage.c b/arch/parisc/mm/hugetlbpage.c | ||
62 | index f6fdc77a72bd..54ba39262b82 100644 | ||
63 | --- a/arch/parisc/mm/hugetlbpage.c | ||
64 | +++ b/arch/parisc/mm/hugetlbpage.c | ||
65 | @@ -105,15 +105,13 @@ static inline void purge_tlb_entries_huge(struct mm_struct *mm, unsigned long ad | ||
66 | addr |= _HUGE_PAGE_SIZE_ENCODING_DEFAULT; | ||
67 | |||
68 | for (i = 0; i < (1 << (HPAGE_SHIFT-REAL_HPAGE_SHIFT)); i++) { | ||
69 | - mtsp(mm->context, 1); | ||
70 | - pdtlb(addr); | ||
71 | - if (unlikely(split_tlb)) | ||
72 | - pitlb(addr); | ||
73 | + purge_tlb_entries(mm, addr); | ||
74 | addr += (1UL << REAL_HPAGE_SHIFT); | ||
75 | } | ||
76 | } | ||
77 | |||
78 | -void set_huge_pte_at(struct mm_struct *mm, unsigned long addr, | ||
79 | +/* __set_huge_pte_at() must be called holding the pa_tlb_lock. */ | ||
80 | +static void __set_huge_pte_at(struct mm_struct *mm, unsigned long addr, | ||
81 | pte_t *ptep, pte_t entry) | ||
82 | { | ||
83 | unsigned long addr_start; | ||
84 | @@ -123,14 +121,9 @@ void set_huge_pte_at(struct mm_struct *mm, unsigned long addr, | ||
85 | addr_start = addr; | ||
86 | |||
87 | for (i = 0; i < (1 << HUGETLB_PAGE_ORDER); i++) { | ||
88 | - /* Directly write pte entry. We could call set_pte_at(mm, addr, ptep, entry) | ||
89 | - * instead, but then we get double locking on pa_tlb_lock. */ | ||
90 | - *ptep = entry; | ||
91 | + set_pte(ptep, entry); | ||
92 | ptep++; | ||
93 | |||
94 | - /* Drop the PAGE_SIZE/non-huge tlb entry */ | ||
95 | - purge_tlb_entries(mm, addr); | ||
96 | - | ||
97 | addr += PAGE_SIZE; | ||
98 | pte_val(entry) += PAGE_SIZE; | ||
99 | } | ||
100 | @@ -138,18 +131,61 @@ void set_huge_pte_at(struct mm_struct *mm, unsigned long addr, | ||
101 | purge_tlb_entries_huge(mm, addr_start); | ||
102 | } | ||
103 | |||
104 | +void set_huge_pte_at(struct mm_struct *mm, unsigned long addr, | ||
105 | + pte_t *ptep, pte_t entry) | ||
106 | +{ | ||
107 | + unsigned long flags; | ||
108 | + | ||
109 | + purge_tlb_start(flags); | ||
110 | + __set_huge_pte_at(mm, addr, ptep, entry); | ||
111 | + purge_tlb_end(flags); | ||
112 | +} | ||
113 | + | ||
114 | |||
115 | pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, | ||
116 | pte_t *ptep) | ||
117 | { | ||
118 | + unsigned long flags; | ||
119 | pte_t entry; | ||
120 | |||
121 | + purge_tlb_start(flags); | ||
122 | entry = *ptep; | ||
123 | - set_huge_pte_at(mm, addr, ptep, __pte(0)); | ||
124 | + __set_huge_pte_at(mm, addr, ptep, __pte(0)); | ||
125 | + purge_tlb_end(flags); | ||
126 | |||
127 | return entry; | ||
128 | } | ||
129 | |||
130 | + | ||
131 | +void huge_ptep_set_wrprotect(struct mm_struct *mm, | ||
132 | + unsigned long addr, pte_t *ptep) | ||
133 | +{ | ||
134 | + unsigned long flags; | ||
135 | + pte_t old_pte; | ||
136 | + | ||
137 | + purge_tlb_start(flags); | ||
138 | + old_pte = *ptep; | ||
139 | + __set_huge_pte_at(mm, addr, ptep, pte_wrprotect(old_pte)); | ||
140 | + purge_tlb_end(flags); | ||
141 | +} | ||
142 | + | ||
143 | +int huge_ptep_set_access_flags(struct vm_area_struct *vma, | ||
144 | + unsigned long addr, pte_t *ptep, | ||
145 | + pte_t pte, int dirty) | ||
146 | +{ | ||
147 | + unsigned long flags; | ||
148 | + int changed; | ||
149 | + | ||
150 | + purge_tlb_start(flags); | ||
151 | + changed = !pte_same(*ptep, pte); | ||
152 | + if (changed) { | ||
153 | + __set_huge_pte_at(vma->vm_mm, addr, ptep, pte); | ||
154 | + } | ||
155 | + purge_tlb_end(flags); | ||
156 | + return changed; | ||
157 | +} | ||
158 | + | ||
159 | + | ||
160 | int pmd_huge(pmd_t pmd) | ||
161 | { | ||
162 | return 0; | ||
163 | diff --git a/arch/x86/crypto/chacha20-ssse3-x86_64.S b/arch/x86/crypto/chacha20-ssse3-x86_64.S | ||
164 | index 712b13047b41..3a33124e9112 100644 | ||
165 | --- a/arch/x86/crypto/chacha20-ssse3-x86_64.S | ||
166 | +++ b/arch/x86/crypto/chacha20-ssse3-x86_64.S | ||
167 | @@ -157,7 +157,9 @@ ENTRY(chacha20_4block_xor_ssse3) | ||
168 | # done with the slightly better performing SSSE3 byte shuffling, | ||
169 | # 7/12-bit word rotation uses traditional shift+OR. | ||
170 | |||
171 | - sub $0x40,%rsp | ||
172 | + mov %rsp,%r11 | ||
173 | + sub $0x80,%rsp | ||
174 | + and $~63,%rsp | ||
175 | |||
176 | # x0..15[0-3] = s0..3[0..3] | ||
177 | movq 0x00(%rdi),%xmm1 | ||
178 | @@ -620,6 +622,6 @@ ENTRY(chacha20_4block_xor_ssse3) | ||
179 | pxor %xmm1,%xmm15 | ||
180 | movdqu %xmm15,0xf0(%rsi) | ||
181 | |||
182 | - add $0x40,%rsp | ||
183 | + mov %r11,%rsp | ||
184 | ret | ||
185 | ENDPROC(chacha20_4block_xor_ssse3) | ||
186 | diff --git a/block/blk-merge.c b/block/blk-merge.c | ||
187 | index e01405a3e8b3..b966db8f3556 100644 | ||
188 | --- a/block/blk-merge.c | ||
189 | +++ b/block/blk-merge.c | ||
190 | @@ -68,6 +68,18 @@ static struct bio *blk_bio_write_same_split(struct request_queue *q, | ||
191 | return bio_split(bio, q->limits.max_write_same_sectors, GFP_NOIO, bs); | ||
192 | } | ||
193 | |||
194 | +static inline unsigned get_max_io_size(struct request_queue *q, | ||
195 | + struct bio *bio) | ||
196 | +{ | ||
197 | + unsigned sectors = blk_max_size_offset(q, bio->bi_iter.bi_sector); | ||
198 | + unsigned mask = queue_logical_block_size(q) - 1; | ||
199 | + | ||
200 | + /* aligned to logical block size */ | ||
201 | + sectors &= ~(mask >> 9); | ||
202 | + | ||
203 | + return sectors; | ||
204 | +} | ||
205 | + | ||
206 | static struct bio *blk_bio_segment_split(struct request_queue *q, | ||
207 | struct bio *bio, | ||
208 | struct bio_set *bs, | ||
209 | @@ -79,11 +91,9 @@ static struct bio *blk_bio_segment_split(struct request_queue *q, | ||
210 | unsigned front_seg_size = bio->bi_seg_front_size; | ||
211 | bool do_split = true; | ||
212 | struct bio *new = NULL; | ||
213 | + const unsigned max_sectors = get_max_io_size(q, bio); | ||
214 | |||
215 | bio_for_each_segment(bv, bio, iter) { | ||
216 | - if (sectors + (bv.bv_len >> 9) > queue_max_sectors(q)) | ||
217 | - goto split; | ||
218 | - | ||
219 | /* | ||
220 | * If the queue doesn't support SG gaps and adding this | ||
221 | * offset would create a gap, disallow it. | ||
222 | @@ -91,6 +101,21 @@ static struct bio *blk_bio_segment_split(struct request_queue *q, | ||
223 | if (bvprvp && bvec_gap_to_prev(q, bvprvp, bv.bv_offset)) | ||
224 | goto split; | ||
225 | |||
226 | + if (sectors + (bv.bv_len >> 9) > max_sectors) { | ||
227 | + /* | ||
228 | + * Consider this a new segment if we're splitting in | ||
229 | + * the middle of this vector. | ||
230 | + */ | ||
231 | + if (nsegs < queue_max_segments(q) && | ||
232 | + sectors < max_sectors) { | ||
233 | + nsegs++; | ||
234 | + sectors = max_sectors; | ||
235 | + } | ||
236 | + if (sectors) | ||
237 | + goto split; | ||
238 | + /* Make this single bvec as the 1st segment */ | ||
239 | + } | ||
240 | + | ||
241 | if (bvprvp && blk_queue_cluster(q)) { | ||
242 | if (seg_size + bv.bv_len > queue_max_segment_size(q)) | ||
243 | goto new_segment; | ||
244 | diff --git a/crypto/af_alg.c b/crypto/af_alg.c | ||
245 | index a8e7aa3e257b..f5e18c2a4852 100644 | ||
246 | --- a/crypto/af_alg.c | ||
247 | +++ b/crypto/af_alg.c | ||
248 | @@ -76,6 +76,8 @@ int af_alg_register_type(const struct af_alg_type *type) | ||
249 | goto unlock; | ||
250 | |||
251 | type->ops->owner = THIS_MODULE; | ||
252 | + if (type->ops_nokey) | ||
253 | + type->ops_nokey->owner = THIS_MODULE; | ||
254 | node->type = type; | ||
255 | list_add(&node->list, &alg_types); | ||
256 | err = 0; | ||
257 | @@ -125,6 +127,26 @@ int af_alg_release(struct socket *sock) | ||
258 | } | ||
259 | EXPORT_SYMBOL_GPL(af_alg_release); | ||
260 | |||
261 | +void af_alg_release_parent(struct sock *sk) | ||
262 | +{ | ||
263 | + struct alg_sock *ask = alg_sk(sk); | ||
264 | + unsigned int nokey = ask->nokey_refcnt; | ||
265 | + bool last = nokey && !ask->refcnt; | ||
266 | + | ||
267 | + sk = ask->parent; | ||
268 | + ask = alg_sk(sk); | ||
269 | + | ||
270 | + lock_sock(sk); | ||
271 | + ask->nokey_refcnt -= nokey; | ||
272 | + if (!last) | ||
273 | + last = !--ask->refcnt; | ||
274 | + release_sock(sk); | ||
275 | + | ||
276 | + if (last) | ||
277 | + sock_put(sk); | ||
278 | +} | ||
279 | +EXPORT_SYMBOL_GPL(af_alg_release_parent); | ||
280 | + | ||
281 | static int alg_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) | ||
282 | { | ||
283 | const u32 forbidden = CRYPTO_ALG_INTERNAL; | ||
284 | @@ -133,6 +155,7 @@ static int alg_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) | ||
285 | struct sockaddr_alg *sa = (void *)uaddr; | ||
286 | const struct af_alg_type *type; | ||
287 | void *private; | ||
288 | + int err; | ||
289 | |||
290 | if (sock->state == SS_CONNECTED) | ||
291 | return -EINVAL; | ||
292 | @@ -160,16 +183,22 @@ static int alg_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) | ||
293 | return PTR_ERR(private); | ||
294 | } | ||
295 | |||
296 | + err = -EBUSY; | ||
297 | lock_sock(sk); | ||
298 | + if (ask->refcnt | ask->nokey_refcnt) | ||
299 | + goto unlock; | ||
300 | |||
301 | swap(ask->type, type); | ||
302 | swap(ask->private, private); | ||
303 | |||
304 | + err = 0; | ||
305 | + | ||
306 | +unlock: | ||
307 | release_sock(sk); | ||
308 | |||
309 | alg_do_release(type, private); | ||
310 | |||
311 | - return 0; | ||
312 | + return err; | ||
313 | } | ||
314 | |||
315 | static int alg_setkey(struct sock *sk, char __user *ukey, | ||
316 | @@ -202,11 +231,15 @@ static int alg_setsockopt(struct socket *sock, int level, int optname, | ||
317 | struct sock *sk = sock->sk; | ||
318 | struct alg_sock *ask = alg_sk(sk); | ||
319 | const struct af_alg_type *type; | ||
320 | - int err = -ENOPROTOOPT; | ||
321 | + int err = -EBUSY; | ||
322 | |||
323 | lock_sock(sk); | ||
324 | + if (ask->refcnt) | ||
325 | + goto unlock; | ||
326 | + | ||
327 | type = ask->type; | ||
328 | |||
329 | + err = -ENOPROTOOPT; | ||
330 | if (level != SOL_ALG || !type) | ||
331 | goto unlock; | ||
332 | |||
333 | @@ -238,6 +271,7 @@ int af_alg_accept(struct sock *sk, struct socket *newsock) | ||
334 | struct alg_sock *ask = alg_sk(sk); | ||
335 | const struct af_alg_type *type; | ||
336 | struct sock *sk2; | ||
337 | + unsigned int nokey; | ||
338 | int err; | ||
339 | |||
340 | lock_sock(sk); | ||
341 | @@ -257,20 +291,29 @@ int af_alg_accept(struct sock *sk, struct socket *newsock) | ||
342 | security_sk_clone(sk, sk2); | ||
343 | |||
344 | err = type->accept(ask->private, sk2); | ||
345 | - if (err) { | ||
346 | - sk_free(sk2); | ||
347 | + | ||
348 | + nokey = err == -ENOKEY; | ||
349 | + if (nokey && type->accept_nokey) | ||
350 | + err = type->accept_nokey(ask->private, sk2); | ||
351 | + | ||
352 | + if (err) | ||
353 | goto unlock; | ||
354 | - } | ||
355 | |||
356 | sk2->sk_family = PF_ALG; | ||
357 | |||
358 | - sock_hold(sk); | ||
359 | + if (nokey || !ask->refcnt++) | ||
360 | + sock_hold(sk); | ||
361 | + ask->nokey_refcnt += nokey; | ||
362 | alg_sk(sk2)->parent = sk; | ||
363 | alg_sk(sk2)->type = type; | ||
364 | + alg_sk(sk2)->nokey_refcnt = nokey; | ||
365 | |||
366 | newsock->ops = type->ops; | ||
367 | newsock->state = SS_CONNECTED; | ||
368 | |||
369 | + if (nokey) | ||
370 | + newsock->ops = type->ops_nokey; | ||
371 | + | ||
372 | err = 0; | ||
373 | |||
374 | unlock: | ||
375 | diff --git a/crypto/ahash.c b/crypto/ahash.c | ||
376 | index 9c1dc8d6106a..d19b52324cf5 100644 | ||
377 | --- a/crypto/ahash.c | ||
378 | +++ b/crypto/ahash.c | ||
379 | @@ -451,6 +451,7 @@ static int crypto_ahash_init_tfm(struct crypto_tfm *tfm) | ||
380 | struct ahash_alg *alg = crypto_ahash_alg(hash); | ||
381 | |||
382 | hash->setkey = ahash_nosetkey; | ||
383 | + hash->has_setkey = false; | ||
384 | hash->export = ahash_no_export; | ||
385 | hash->import = ahash_no_import; | ||
386 | |||
387 | @@ -463,8 +464,10 @@ static int crypto_ahash_init_tfm(struct crypto_tfm *tfm) | ||
388 | hash->finup = alg->finup ?: ahash_def_finup; | ||
389 | hash->digest = alg->digest; | ||
390 | |||
391 | - if (alg->setkey) | ||
392 | + if (alg->setkey) { | ||
393 | hash->setkey = alg->setkey; | ||
394 | + hash->has_setkey = true; | ||
395 | + } | ||
396 | if (alg->export) | ||
397 | hash->export = alg->export; | ||
398 | if (alg->import) | ||
399 | diff --git a/crypto/algif_hash.c b/crypto/algif_hash.c | ||
400 | index b4c24fe3dcfb..68a5ceaa04c8 100644 | ||
401 | --- a/crypto/algif_hash.c | ||
402 | +++ b/crypto/algif_hash.c | ||
403 | @@ -34,6 +34,11 @@ struct hash_ctx { | ||
404 | struct ahash_request req; | ||
405 | }; | ||
406 | |||
407 | +struct algif_hash_tfm { | ||
408 | + struct crypto_ahash *hash; | ||
409 | + bool has_key; | ||
410 | +}; | ||
411 | + | ||
412 | static int hash_sendmsg(struct socket *sock, struct msghdr *msg, | ||
413 | size_t ignored) | ||
414 | { | ||
415 | @@ -49,7 +54,8 @@ static int hash_sendmsg(struct socket *sock, struct msghdr *msg, | ||
416 | |||
417 | lock_sock(sk); | ||
418 | if (!ctx->more) { | ||
419 | - err = crypto_ahash_init(&ctx->req); | ||
420 | + err = af_alg_wait_for_completion(crypto_ahash_init(&ctx->req), | ||
421 | + &ctx->completion); | ||
422 | if (err) | ||
423 | goto unlock; | ||
424 | } | ||
425 | @@ -120,6 +126,7 @@ static ssize_t hash_sendpage(struct socket *sock, struct page *page, | ||
426 | } else { | ||
427 | if (!ctx->more) { | ||
428 | err = crypto_ahash_init(&ctx->req); | ||
429 | + err = af_alg_wait_for_completion(err, &ctx->completion); | ||
430 | if (err) | ||
431 | goto unlock; | ||
432 | } | ||
433 | @@ -235,19 +242,151 @@ static struct proto_ops algif_hash_ops = { | ||
434 | .accept = hash_accept, | ||
435 | }; | ||
436 | |||
437 | +static int hash_check_key(struct socket *sock) | ||
438 | +{ | ||
439 | + int err = 0; | ||
440 | + struct sock *psk; | ||
441 | + struct alg_sock *pask; | ||
442 | + struct algif_hash_tfm *tfm; | ||
443 | + struct sock *sk = sock->sk; | ||
444 | + struct alg_sock *ask = alg_sk(sk); | ||
445 | + | ||
446 | + lock_sock(sk); | ||
447 | + if (ask->refcnt) | ||
448 | + goto unlock_child; | ||
449 | + | ||
450 | + psk = ask->parent; | ||
451 | + pask = alg_sk(ask->parent); | ||
452 | + tfm = pask->private; | ||
453 | + | ||
454 | + err = -ENOKEY; | ||
455 | + lock_sock_nested(psk, SINGLE_DEPTH_NESTING); | ||
456 | + if (!tfm->has_key) | ||
457 | + goto unlock; | ||
458 | + | ||
459 | + if (!pask->refcnt++) | ||
460 | + sock_hold(psk); | ||
461 | + | ||
462 | + ask->refcnt = 1; | ||
463 | + sock_put(psk); | ||
464 | + | ||
465 | + err = 0; | ||
466 | + | ||
467 | +unlock: | ||
468 | + release_sock(psk); | ||
469 | +unlock_child: | ||
470 | + release_sock(sk); | ||
471 | + | ||
472 | + return err; | ||
473 | +} | ||
474 | + | ||
475 | +static int hash_sendmsg_nokey(struct socket *sock, struct msghdr *msg, | ||
476 | + size_t size) | ||
477 | +{ | ||
478 | + int err; | ||
479 | + | ||
480 | + err = hash_check_key(sock); | ||
481 | + if (err) | ||
482 | + return err; | ||
483 | + | ||
484 | + return hash_sendmsg(sock, msg, size); | ||
485 | +} | ||
486 | + | ||
487 | +static ssize_t hash_sendpage_nokey(struct socket *sock, struct page *page, | ||
488 | + int offset, size_t size, int flags) | ||
489 | +{ | ||
490 | + int err; | ||
491 | + | ||
492 | + err = hash_check_key(sock); | ||
493 | + if (err) | ||
494 | + return err; | ||
495 | + | ||
496 | + return hash_sendpage(sock, page, offset, size, flags); | ||
497 | +} | ||
498 | + | ||
499 | +static int hash_recvmsg_nokey(struct socket *sock, struct msghdr *msg, | ||
500 | + size_t ignored, int flags) | ||
501 | +{ | ||
502 | + int err; | ||
503 | + | ||
504 | + err = hash_check_key(sock); | ||
505 | + if (err) | ||
506 | + return err; | ||
507 | + | ||
508 | + return hash_recvmsg(sock, msg, ignored, flags); | ||
509 | +} | ||
510 | + | ||
511 | +static int hash_accept_nokey(struct socket *sock, struct socket *newsock, | ||
512 | + int flags) | ||
513 | +{ | ||
514 | + int err; | ||
515 | + | ||
516 | + err = hash_check_key(sock); | ||
517 | + if (err) | ||
518 | + return err; | ||
519 | + | ||
520 | + return hash_accept(sock, newsock, flags); | ||
521 | +} | ||
522 | + | ||
523 | +static struct proto_ops algif_hash_ops_nokey = { | ||
524 | + .family = PF_ALG, | ||
525 | + | ||
526 | + .connect = sock_no_connect, | ||
527 | + .socketpair = sock_no_socketpair, | ||
528 | + .getname = sock_no_getname, | ||
529 | + .ioctl = sock_no_ioctl, | ||
530 | + .listen = sock_no_listen, | ||
531 | + .shutdown = sock_no_shutdown, | ||
532 | + .getsockopt = sock_no_getsockopt, | ||
533 | + .mmap = sock_no_mmap, | ||
534 | + .bind = sock_no_bind, | ||
535 | + .setsockopt = sock_no_setsockopt, | ||
536 | + .poll = sock_no_poll, | ||
537 | + | ||
538 | + .release = af_alg_release, | ||
539 | + .sendmsg = hash_sendmsg_nokey, | ||
540 | + .sendpage = hash_sendpage_nokey, | ||
541 | + .recvmsg = hash_recvmsg_nokey, | ||
542 | + .accept = hash_accept_nokey, | ||
543 | +}; | ||
544 | + | ||
545 | static void *hash_bind(const char *name, u32 type, u32 mask) | ||
546 | { | ||
547 | - return crypto_alloc_ahash(name, type, mask); | ||
548 | + struct algif_hash_tfm *tfm; | ||
549 | + struct crypto_ahash *hash; | ||
550 | + | ||
551 | + tfm = kzalloc(sizeof(*tfm), GFP_KERNEL); | ||
552 | + if (!tfm) | ||
553 | + return ERR_PTR(-ENOMEM); | ||
554 | + | ||
555 | + hash = crypto_alloc_ahash(name, type, mask); | ||
556 | + if (IS_ERR(hash)) { | ||
557 | + kfree(tfm); | ||
558 | + return ERR_CAST(hash); | ||
559 | + } | ||
560 | + | ||
561 | + tfm->hash = hash; | ||
562 | + | ||
563 | + return tfm; | ||
564 | } | ||
565 | |||
566 | static void hash_release(void *private) | ||
567 | { | ||
568 | - crypto_free_ahash(private); | ||
569 | + struct algif_hash_tfm *tfm = private; | ||
570 | + | ||
571 | + crypto_free_ahash(tfm->hash); | ||
572 | + kfree(tfm); | ||
573 | } | ||
574 | |||
575 | static int hash_setkey(void *private, const u8 *key, unsigned int keylen) | ||
576 | { | ||
577 | - return crypto_ahash_setkey(private, key, keylen); | ||
578 | + struct algif_hash_tfm *tfm = private; | ||
579 | + int err; | ||
580 | + | ||
581 | + err = crypto_ahash_setkey(tfm->hash, key, keylen); | ||
582 | + tfm->has_key = !err; | ||
583 | + | ||
584 | + return err; | ||
585 | } | ||
586 | |||
587 | static void hash_sock_destruct(struct sock *sk) | ||
588 | @@ -261,12 +400,14 @@ static void hash_sock_destruct(struct sock *sk) | ||
589 | af_alg_release_parent(sk); | ||
590 | } | ||
591 | |||
592 | -static int hash_accept_parent(void *private, struct sock *sk) | ||
593 | +static int hash_accept_parent_nokey(void *private, struct sock *sk) | ||
594 | { | ||
595 | struct hash_ctx *ctx; | ||
596 | struct alg_sock *ask = alg_sk(sk); | ||
597 | - unsigned len = sizeof(*ctx) + crypto_ahash_reqsize(private); | ||
598 | - unsigned ds = crypto_ahash_digestsize(private); | ||
599 | + struct algif_hash_tfm *tfm = private; | ||
600 | + struct crypto_ahash *hash = tfm->hash; | ||
601 | + unsigned len = sizeof(*ctx) + crypto_ahash_reqsize(hash); | ||
602 | + unsigned ds = crypto_ahash_digestsize(hash); | ||
603 | |||
604 | ctx = sock_kmalloc(sk, len, GFP_KERNEL); | ||
605 | if (!ctx) | ||
606 | @@ -286,7 +427,7 @@ static int hash_accept_parent(void *private, struct sock *sk) | ||
607 | |||
608 | ask->private = ctx; | ||
609 | |||
610 | - ahash_request_set_tfm(&ctx->req, private); | ||
611 | + ahash_request_set_tfm(&ctx->req, hash); | ||
612 | ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG, | ||
613 | af_alg_complete, &ctx->completion); | ||
614 | |||
615 | @@ -295,12 +436,24 @@ static int hash_accept_parent(void *private, struct sock *sk) | ||
616 | return 0; | ||
617 | } | ||
618 | |||
619 | +static int hash_accept_parent(void *private, struct sock *sk) | ||
620 | +{ | ||
621 | + struct algif_hash_tfm *tfm = private; | ||
622 | + | ||
623 | + if (!tfm->has_key && crypto_ahash_has_setkey(tfm->hash)) | ||
624 | + return -ENOKEY; | ||
625 | + | ||
626 | + return hash_accept_parent_nokey(private, sk); | ||
627 | +} | ||
628 | + | ||
629 | static const struct af_alg_type algif_type_hash = { | ||
630 | .bind = hash_bind, | ||
631 | .release = hash_release, | ||
632 | .setkey = hash_setkey, | ||
633 | .accept = hash_accept_parent, | ||
634 | + .accept_nokey = hash_accept_parent_nokey, | ||
635 | .ops = &algif_hash_ops, | ||
636 | + .ops_nokey = &algif_hash_ops_nokey, | ||
637 | .name = "hash", | ||
638 | .owner = THIS_MODULE | ||
639 | }; | ||
640 | diff --git a/crypto/algif_skcipher.c b/crypto/algif_skcipher.c | ||
641 | index 634b4d1ab681..f5e9f9310b48 100644 | ||
642 | --- a/crypto/algif_skcipher.c | ||
643 | +++ b/crypto/algif_skcipher.c | ||
644 | @@ -31,6 +31,11 @@ struct skcipher_sg_list { | ||
645 | struct scatterlist sg[0]; | ||
646 | }; | ||
647 | |||
648 | +struct skcipher_tfm { | ||
649 | + struct crypto_skcipher *skcipher; | ||
650 | + bool has_key; | ||
651 | +}; | ||
652 | + | ||
653 | struct skcipher_ctx { | ||
654 | struct list_head tsgl; | ||
655 | struct af_alg_sgl rsgl; | ||
656 | @@ -60,18 +65,10 @@ struct skcipher_async_req { | ||
657 | struct skcipher_async_rsgl first_sgl; | ||
658 | struct list_head list; | ||
659 | struct scatterlist *tsg; | ||
660 | - char iv[]; | ||
661 | + atomic_t *inflight; | ||
662 | + struct skcipher_request req; | ||
663 | }; | ||
664 | |||
665 | -#define GET_SREQ(areq, ctx) (struct skcipher_async_req *)((char *)areq + \ | ||
666 | - crypto_skcipher_reqsize(crypto_skcipher_reqtfm(&ctx->req))) | ||
667 | - | ||
668 | -#define GET_REQ_SIZE(ctx) \ | ||
669 | - crypto_skcipher_reqsize(crypto_skcipher_reqtfm(&ctx->req)) | ||
670 | - | ||
671 | -#define GET_IV_SIZE(ctx) \ | ||
672 | - crypto_skcipher_ivsize(crypto_skcipher_reqtfm(&ctx->req)) | ||
673 | - | ||
674 | #define MAX_SGL_ENTS ((4096 - sizeof(struct skcipher_sg_list)) / \ | ||
675 | sizeof(struct scatterlist) - 1) | ||
676 | |||
677 | @@ -97,15 +94,12 @@ static void skcipher_free_async_sgls(struct skcipher_async_req *sreq) | ||
678 | |||
679 | static void skcipher_async_cb(struct crypto_async_request *req, int err) | ||
680 | { | ||
681 | - struct sock *sk = req->data; | ||
682 | - struct alg_sock *ask = alg_sk(sk); | ||
683 | - struct skcipher_ctx *ctx = ask->private; | ||
684 | - struct skcipher_async_req *sreq = GET_SREQ(req, ctx); | ||
685 | + struct skcipher_async_req *sreq = req->data; | ||
686 | struct kiocb *iocb = sreq->iocb; | ||
687 | |||
688 | - atomic_dec(&ctx->inflight); | ||
689 | + atomic_dec(sreq->inflight); | ||
690 | skcipher_free_async_sgls(sreq); | ||
691 | - kfree(req); | ||
692 | + kzfree(sreq); | ||
693 | iocb->ki_complete(iocb, err, err); | ||
694 | } | ||
695 | |||
696 | @@ -301,8 +295,11 @@ static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg, | ||
697 | { | ||
698 | struct sock *sk = sock->sk; | ||
699 | struct alg_sock *ask = alg_sk(sk); | ||
700 | + struct sock *psk = ask->parent; | ||
701 | + struct alg_sock *pask = alg_sk(psk); | ||
702 | struct skcipher_ctx *ctx = ask->private; | ||
703 | - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(&ctx->req); | ||
704 | + struct skcipher_tfm *skc = pask->private; | ||
705 | + struct crypto_skcipher *tfm = skc->skcipher; | ||
706 | unsigned ivsize = crypto_skcipher_ivsize(tfm); | ||
707 | struct skcipher_sg_list *sgl; | ||
708 | struct af_alg_control con = {}; | ||
709 | @@ -387,7 +384,8 @@ static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg, | ||
710 | |||
711 | sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list); | ||
712 | sg = sgl->sg; | ||
713 | - sg_unmark_end(sg + sgl->cur); | ||
714 | + if (sgl->cur) | ||
715 | + sg_unmark_end(sg + sgl->cur - 1); | ||
716 | do { | ||
717 | i = sgl->cur; | ||
718 | plen = min_t(int, len, PAGE_SIZE); | ||
719 | @@ -503,37 +501,43 @@ static int skcipher_recvmsg_async(struct socket *sock, struct msghdr *msg, | ||
720 | { | ||
721 | struct sock *sk = sock->sk; | ||
722 | struct alg_sock *ask = alg_sk(sk); | ||
723 | + struct sock *psk = ask->parent; | ||
724 | + struct alg_sock *pask = alg_sk(psk); | ||
725 | struct skcipher_ctx *ctx = ask->private; | ||
726 | + struct skcipher_tfm *skc = pask->private; | ||
727 | + struct crypto_skcipher *tfm = skc->skcipher; | ||
728 | struct skcipher_sg_list *sgl; | ||
729 | struct scatterlist *sg; | ||
730 | struct skcipher_async_req *sreq; | ||
731 | struct skcipher_request *req; | ||
732 | struct skcipher_async_rsgl *last_rsgl = NULL; | ||
733 | - unsigned int txbufs = 0, len = 0, tx_nents = skcipher_all_sg_nents(ctx); | ||
734 | - unsigned int reqlen = sizeof(struct skcipher_async_req) + | ||
735 | - GET_REQ_SIZE(ctx) + GET_IV_SIZE(ctx); | ||
736 | + unsigned int txbufs = 0, len = 0, tx_nents; | ||
737 | + unsigned int reqsize = crypto_skcipher_reqsize(tfm); | ||
738 | + unsigned int ivsize = crypto_skcipher_ivsize(tfm); | ||
739 | int err = -ENOMEM; | ||
740 | bool mark = false; | ||
741 | + char *iv; | ||
742 | |||
743 | - lock_sock(sk); | ||
744 | - req = kmalloc(reqlen, GFP_KERNEL); | ||
745 | - if (unlikely(!req)) | ||
746 | - goto unlock; | ||
747 | + sreq = kzalloc(sizeof(*sreq) + reqsize + ivsize, GFP_KERNEL); | ||
748 | + if (unlikely(!sreq)) | ||
749 | + goto out; | ||
750 | |||
751 | - sreq = GET_SREQ(req, ctx); | ||
752 | + req = &sreq->req; | ||
753 | + iv = (char *)(req + 1) + reqsize; | ||
754 | sreq->iocb = msg->msg_iocb; | ||
755 | - memset(&sreq->first_sgl, '\0', sizeof(struct skcipher_async_rsgl)); | ||
756 | INIT_LIST_HEAD(&sreq->list); | ||
757 | + sreq->inflight = &ctx->inflight; | ||
758 | + | ||
759 | + lock_sock(sk); | ||
760 | + tx_nents = skcipher_all_sg_nents(ctx); | ||
761 | sreq->tsg = kcalloc(tx_nents, sizeof(*sg), GFP_KERNEL); | ||
762 | - if (unlikely(!sreq->tsg)) { | ||
763 | - kfree(req); | ||
764 | + if (unlikely(!sreq->tsg)) | ||
765 | goto unlock; | ||
766 | - } | ||
767 | sg_init_table(sreq->tsg, tx_nents); | ||
768 | - memcpy(sreq->iv, ctx->iv, GET_IV_SIZE(ctx)); | ||
769 | - skcipher_request_set_tfm(req, crypto_skcipher_reqtfm(&ctx->req)); | ||
770 | - skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, | ||
771 | - skcipher_async_cb, sk); | ||
772 | + memcpy(iv, ctx->iv, ivsize); | ||
773 | + skcipher_request_set_tfm(req, tfm); | ||
774 | + skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP, | ||
775 | + skcipher_async_cb, sreq); | ||
776 | |||
777 | while (iov_iter_count(&msg->msg_iter)) { | ||
778 | struct skcipher_async_rsgl *rsgl; | ||
779 | @@ -609,20 +613,22 @@ static int skcipher_recvmsg_async(struct socket *sock, struct msghdr *msg, | ||
780 | sg_mark_end(sreq->tsg + txbufs - 1); | ||
781 | |||
782 | skcipher_request_set_crypt(req, sreq->tsg, sreq->first_sgl.sgl.sg, | ||
783 | - len, sreq->iv); | ||
784 | + len, iv); | ||
785 | err = ctx->enc ? crypto_skcipher_encrypt(req) : | ||
786 | crypto_skcipher_decrypt(req); | ||
787 | if (err == -EINPROGRESS) { | ||
788 | atomic_inc(&ctx->inflight); | ||
789 | err = -EIOCBQUEUED; | ||
790 | + sreq = NULL; | ||
791 | goto unlock; | ||
792 | } | ||
793 | free: | ||
794 | skcipher_free_async_sgls(sreq); | ||
795 | - kfree(req); | ||
796 | unlock: | ||
797 | skcipher_wmem_wakeup(sk); | ||
798 | release_sock(sk); | ||
799 | + kzfree(sreq); | ||
800 | +out: | ||
801 | return err; | ||
802 | } | ||
803 | |||
804 | @@ -631,9 +637,12 @@ static int skcipher_recvmsg_sync(struct socket *sock, struct msghdr *msg, | ||
805 | { | ||
806 | struct sock *sk = sock->sk; | ||
807 | struct alg_sock *ask = alg_sk(sk); | ||
808 | + struct sock *psk = ask->parent; | ||
809 | + struct alg_sock *pask = alg_sk(psk); | ||
810 | struct skcipher_ctx *ctx = ask->private; | ||
811 | - unsigned bs = crypto_skcipher_blocksize(crypto_skcipher_reqtfm( | ||
812 | - &ctx->req)); | ||
813 | + struct skcipher_tfm *skc = pask->private; | ||
814 | + struct crypto_skcipher *tfm = skc->skcipher; | ||
815 | + unsigned bs = crypto_skcipher_blocksize(tfm); | ||
816 | struct skcipher_sg_list *sgl; | ||
817 | struct scatterlist *sg; | ||
818 | int err = -EAGAIN; | ||
819 | @@ -642,13 +651,6 @@ static int skcipher_recvmsg_sync(struct socket *sock, struct msghdr *msg, | ||
820 | |||
821 | lock_sock(sk); | ||
822 | while (msg_data_left(msg)) { | ||
823 | - sgl = list_first_entry(&ctx->tsgl, | ||
824 | - struct skcipher_sg_list, list); | ||
825 | - sg = sgl->sg; | ||
826 | - | ||
827 | - while (!sg->length) | ||
828 | - sg++; | ||
829 | - | ||
830 | if (!ctx->used) { | ||
831 | err = skcipher_wait_for_data(sk, flags); | ||
832 | if (err) | ||
833 | @@ -669,6 +671,13 @@ static int skcipher_recvmsg_sync(struct socket *sock, struct msghdr *msg, | ||
834 | if (!used) | ||
835 | goto free; | ||
836 | |||
837 | + sgl = list_first_entry(&ctx->tsgl, | ||
838 | + struct skcipher_sg_list, list); | ||
839 | + sg = sgl->sg; | ||
840 | + | ||
841 | + while (!sg->length) | ||
842 | + sg++; | ||
843 | + | ||
844 | skcipher_request_set_crypt(&ctx->req, sg, ctx->rsgl.sg, used, | ||
845 | ctx->iv); | ||
846 | |||
847 | @@ -748,19 +757,139 @@ static struct proto_ops algif_skcipher_ops = { | ||
848 | .poll = skcipher_poll, | ||
849 | }; | ||
850 | |||
851 | +static int skcipher_check_key(struct socket *sock) | ||
852 | +{ | ||
853 | + int err = 0; | ||
854 | + struct sock *psk; | ||
855 | + struct alg_sock *pask; | ||
856 | + struct skcipher_tfm *tfm; | ||
857 | + struct sock *sk = sock->sk; | ||
858 | + struct alg_sock *ask = alg_sk(sk); | ||
859 | + | ||
860 | + lock_sock(sk); | ||
861 | + if (ask->refcnt) | ||
862 | + goto unlock_child; | ||
863 | + | ||
864 | + psk = ask->parent; | ||
865 | + pask = alg_sk(ask->parent); | ||
866 | + tfm = pask->private; | ||
867 | + | ||
868 | + err = -ENOKEY; | ||
869 | + lock_sock_nested(psk, SINGLE_DEPTH_NESTING); | ||
870 | + if (!tfm->has_key) | ||
871 | + goto unlock; | ||
872 | + | ||
873 | + if (!pask->refcnt++) | ||
874 | + sock_hold(psk); | ||
875 | + | ||
876 | + ask->refcnt = 1; | ||
877 | + sock_put(psk); | ||
878 | + | ||
879 | + err = 0; | ||
880 | + | ||
881 | +unlock: | ||
882 | + release_sock(psk); | ||
883 | +unlock_child: | ||
884 | + release_sock(sk); | ||
885 | + | ||
886 | + return err; | ||
887 | +} | ||
888 | + | ||
889 | +static int skcipher_sendmsg_nokey(struct socket *sock, struct msghdr *msg, | ||
890 | + size_t size) | ||
891 | +{ | ||
892 | + int err; | ||
893 | + | ||
894 | + err = skcipher_check_key(sock); | ||
895 | + if (err) | ||
896 | + return err; | ||
897 | + | ||
898 | + return skcipher_sendmsg(sock, msg, size); | ||
899 | +} | ||
900 | + | ||
901 | +static ssize_t skcipher_sendpage_nokey(struct socket *sock, struct page *page, | ||
902 | + int offset, size_t size, int flags) | ||
903 | +{ | ||
904 | + int err; | ||
905 | + | ||
906 | + err = skcipher_check_key(sock); | ||
907 | + if (err) | ||
908 | + return err; | ||
909 | + | ||
910 | + return skcipher_sendpage(sock, page, offset, size, flags); | ||
911 | +} | ||
912 | + | ||
913 | +static int skcipher_recvmsg_nokey(struct socket *sock, struct msghdr *msg, | ||
914 | + size_t ignored, int flags) | ||
915 | +{ | ||
916 | + int err; | ||
917 | + | ||
918 | + err = skcipher_check_key(sock); | ||
919 | + if (err) | ||
920 | + return err; | ||
921 | + | ||
922 | + return skcipher_recvmsg(sock, msg, ignored, flags); | ||
923 | +} | ||
924 | + | ||
925 | +static struct proto_ops algif_skcipher_ops_nokey = { | ||
926 | + .family = PF_ALG, | ||
927 | + | ||
928 | + .connect = sock_no_connect, | ||
929 | + .socketpair = sock_no_socketpair, | ||
930 | + .getname = sock_no_getname, | ||
931 | + .ioctl = sock_no_ioctl, | ||
932 | + .listen = sock_no_listen, | ||
933 | + .shutdown = sock_no_shutdown, | ||
934 | + .getsockopt = sock_no_getsockopt, | ||
935 | + .mmap = sock_no_mmap, | ||
936 | + .bind = sock_no_bind, | ||
937 | + .accept = sock_no_accept, | ||
938 | + .setsockopt = sock_no_setsockopt, | ||
939 | + | ||
940 | + .release = af_alg_release, | ||
941 | + .sendmsg = skcipher_sendmsg_nokey, | ||
942 | + .sendpage = skcipher_sendpage_nokey, | ||
943 | + .recvmsg = skcipher_recvmsg_nokey, | ||
944 | + .poll = skcipher_poll, | ||
945 | +}; | ||
946 | + | ||
947 | static void *skcipher_bind(const char *name, u32 type, u32 mask) | ||
948 | { | ||
949 | - return crypto_alloc_skcipher(name, type, mask); | ||
950 | + struct skcipher_tfm *tfm; | ||
951 | + struct crypto_skcipher *skcipher; | ||
952 | + | ||
953 | + tfm = kzalloc(sizeof(*tfm), GFP_KERNEL); | ||
954 | + if (!tfm) | ||
955 | + return ERR_PTR(-ENOMEM); | ||
956 | + | ||
957 | + skcipher = crypto_alloc_skcipher(name, type, mask); | ||
958 | + if (IS_ERR(skcipher)) { | ||
959 | + kfree(tfm); | ||
960 | + return ERR_CAST(skcipher); | ||
961 | + } | ||
962 | + | ||
963 | + tfm->skcipher = skcipher; | ||
964 | + | ||
965 | + return tfm; | ||
966 | } | ||
967 | |||
968 | static void skcipher_release(void *private) | ||
969 | { | ||
970 | - crypto_free_skcipher(private); | ||
971 | + struct skcipher_tfm *tfm = private; | ||
972 | + | ||
973 | + crypto_free_skcipher(tfm->skcipher); | ||
974 | + kfree(tfm); | ||
975 | } | ||
976 | |||
977 | static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen) | ||
978 | { | ||
979 | - return crypto_skcipher_setkey(private, key, keylen); | ||
980 | + struct skcipher_tfm *tfm = private; | ||
981 | + int err; | ||
982 | + | ||
983 | + err = crypto_skcipher_setkey(tfm->skcipher, key, keylen); | ||
984 | + tfm->has_key = !err; | ||
985 | + | ||
986 | + return err; | ||
987 | } | ||
988 | |||
989 | static void skcipher_wait(struct sock *sk) | ||
990 | @@ -788,24 +917,26 @@ static void skcipher_sock_destruct(struct sock *sk) | ||
991 | af_alg_release_parent(sk); | ||
992 | } | ||
993 | |||
994 | -static int skcipher_accept_parent(void *private, struct sock *sk) | ||
995 | +static int skcipher_accept_parent_nokey(void *private, struct sock *sk) | ||
996 | { | ||
997 | struct skcipher_ctx *ctx; | ||
998 | struct alg_sock *ask = alg_sk(sk); | ||
999 | - unsigned int len = sizeof(*ctx) + crypto_skcipher_reqsize(private); | ||
1000 | + struct skcipher_tfm *tfm = private; | ||
1001 | + struct crypto_skcipher *skcipher = tfm->skcipher; | ||
1002 | + unsigned int len = sizeof(*ctx) + crypto_skcipher_reqsize(skcipher); | ||
1003 | |||
1004 | ctx = sock_kmalloc(sk, len, GFP_KERNEL); | ||
1005 | if (!ctx) | ||
1006 | return -ENOMEM; | ||
1007 | |||
1008 | - ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(private), | ||
1009 | + ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(skcipher), | ||
1010 | GFP_KERNEL); | ||
1011 | if (!ctx->iv) { | ||
1012 | sock_kfree_s(sk, ctx, len); | ||
1013 | return -ENOMEM; | ||
1014 | } | ||
1015 | |||
1016 | - memset(ctx->iv, 0, crypto_skcipher_ivsize(private)); | ||
1017 | + memset(ctx->iv, 0, crypto_skcipher_ivsize(skcipher)); | ||
1018 | |||
1019 | INIT_LIST_HEAD(&ctx->tsgl); | ||
1020 | ctx->len = len; | ||
1021 | @@ -818,8 +949,9 @@ static int skcipher_accept_parent(void *private, struct sock *sk) | ||
1022 | |||
1023 | ask->private = ctx; | ||
1024 | |||
1025 | - skcipher_request_set_tfm(&ctx->req, private); | ||
1026 | - skcipher_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG, | ||
1027 | + skcipher_request_set_tfm(&ctx->req, skcipher); | ||
1028 | + skcipher_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_SLEEP | | ||
1029 | + CRYPTO_TFM_REQ_MAY_BACKLOG, | ||
1030 | af_alg_complete, &ctx->completion); | ||
1031 | |||
1032 | sk->sk_destruct = skcipher_sock_destruct; | ||
1033 | @@ -827,12 +959,24 @@ static int skcipher_accept_parent(void *private, struct sock *sk) | ||
1034 | return 0; | ||
1035 | } | ||
1036 | |||
1037 | +static int skcipher_accept_parent(void *private, struct sock *sk) | ||
1038 | +{ | ||
1039 | + struct skcipher_tfm *tfm = private; | ||
1040 | + | ||
1041 | + if (!tfm->has_key && crypto_skcipher_has_setkey(tfm->skcipher)) | ||
1042 | + return -ENOKEY; | ||
1043 | + | ||
1044 | + return skcipher_accept_parent_nokey(private, sk); | ||
1045 | +} | ||
1046 | + | ||
1047 | static const struct af_alg_type algif_type_skcipher = { | ||
1048 | .bind = skcipher_bind, | ||
1049 | .release = skcipher_release, | ||
1050 | .setkey = skcipher_setkey, | ||
1051 | .accept = skcipher_accept_parent, | ||
1052 | + .accept_nokey = skcipher_accept_parent_nokey, | ||
1053 | .ops = &algif_skcipher_ops, | ||
1054 | + .ops_nokey = &algif_skcipher_ops_nokey, | ||
1055 | .name = "skcipher", | ||
1056 | .owner = THIS_MODULE | ||
1057 | }; | ||
1058 | diff --git a/crypto/crc32c_generic.c b/crypto/crc32c_generic.c | ||
1059 | index 06f1b60f02b2..4c0a0e271876 100644 | ||
1060 | --- a/crypto/crc32c_generic.c | ||
1061 | +++ b/crypto/crc32c_generic.c | ||
1062 | @@ -172,4 +172,3 @@ MODULE_DESCRIPTION("CRC32c (Castagnoli) calculations wrapper for lib/crc32c"); | ||
1063 | MODULE_LICENSE("GPL"); | ||
1064 | MODULE_ALIAS_CRYPTO("crc32c"); | ||
1065 | MODULE_ALIAS_CRYPTO("crc32c-generic"); | ||
1066 | -MODULE_SOFTDEP("pre: crc32c"); | ||
1067 | diff --git a/crypto/crypto_user.c b/crypto/crypto_user.c | ||
1068 | index 237f3795cfaa..43fe85f20d57 100644 | ||
1069 | --- a/crypto/crypto_user.c | ||
1070 | +++ b/crypto/crypto_user.c | ||
1071 | @@ -499,6 +499,7 @@ static int crypto_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) | ||
1072 | if (link->dump == NULL) | ||
1073 | return -EINVAL; | ||
1074 | |||
1075 | + down_read(&crypto_alg_sem); | ||
1076 | list_for_each_entry(alg, &crypto_alg_list, cra_list) | ||
1077 | dump_alloc += CRYPTO_REPORT_MAXSIZE; | ||
1078 | |||
1079 | @@ -508,8 +509,11 @@ static int crypto_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) | ||
1080 | .done = link->done, | ||
1081 | .min_dump_alloc = dump_alloc, | ||
1082 | }; | ||
1083 | - return netlink_dump_start(crypto_nlsk, skb, nlh, &c); | ||
1084 | + err = netlink_dump_start(crypto_nlsk, skb, nlh, &c); | ||
1085 | } | ||
1086 | + up_read(&crypto_alg_sem); | ||
1087 | + | ||
1088 | + return err; | ||
1089 | } | ||
1090 | |||
1091 | err = nlmsg_parse(nlh, crypto_msg_min[type], attrs, CRYPTOCFGA_MAX, | ||
1092 | diff --git a/crypto/shash.c b/crypto/shash.c | ||
1093 | index ecb1e3d39bf0..359754591653 100644 | ||
1094 | --- a/crypto/shash.c | ||
1095 | +++ b/crypto/shash.c | ||
1096 | @@ -354,9 +354,10 @@ int crypto_init_shash_ops_async(struct crypto_tfm *tfm) | ||
1097 | crt->final = shash_async_final; | ||
1098 | crt->finup = shash_async_finup; | ||
1099 | crt->digest = shash_async_digest; | ||
1100 | + crt->setkey = shash_async_setkey; | ||
1101 | + | ||
1102 | + crt->has_setkey = alg->setkey != shash_no_setkey; | ||
1103 | |||
1104 | - if (alg->setkey) | ||
1105 | - crt->setkey = shash_async_setkey; | ||
1106 | if (alg->export) | ||
1107 | crt->export = shash_async_export; | ||
1108 | if (alg->import) | ||
1109 | diff --git a/crypto/skcipher.c b/crypto/skcipher.c | ||
1110 | index 7591928be7ca..d199c0b1751c 100644 | ||
1111 | --- a/crypto/skcipher.c | ||
1112 | +++ b/crypto/skcipher.c | ||
1113 | @@ -118,6 +118,7 @@ static int crypto_init_skcipher_ops_blkcipher(struct crypto_tfm *tfm) | ||
1114 | skcipher->decrypt = skcipher_decrypt_blkcipher; | ||
1115 | |||
1116 | skcipher->ivsize = crypto_blkcipher_ivsize(blkcipher); | ||
1117 | + skcipher->has_setkey = calg->cra_blkcipher.max_keysize; | ||
1118 | |||
1119 | return 0; | ||
1120 | } | ||
1121 | @@ -210,6 +211,7 @@ static int crypto_init_skcipher_ops_ablkcipher(struct crypto_tfm *tfm) | ||
1122 | skcipher->ivsize = crypto_ablkcipher_ivsize(ablkcipher); | ||
1123 | skcipher->reqsize = crypto_ablkcipher_reqsize(ablkcipher) + | ||
1124 | sizeof(struct ablkcipher_request); | ||
1125 | + skcipher->has_setkey = calg->cra_ablkcipher.max_keysize; | ||
1126 | |||
1127 | return 0; | ||
1128 | } | ||
1129 | diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c | ||
1130 | index cdfbcc54821f..99921aa0daca 100644 | ||
1131 | --- a/drivers/ata/ahci.c | ||
1132 | +++ b/drivers/ata/ahci.c | ||
1133 | @@ -264,6 +264,26 @@ static const struct pci_device_id ahci_pci_tbl[] = { | ||
1134 | { PCI_VDEVICE(INTEL, 0x3b2b), board_ahci }, /* PCH RAID */ | ||
1135 | { PCI_VDEVICE(INTEL, 0x3b2c), board_ahci }, /* PCH RAID */ | ||
1136 | { PCI_VDEVICE(INTEL, 0x3b2f), board_ahci }, /* PCH AHCI */ | ||
1137 | + { PCI_VDEVICE(INTEL, 0x19b0), board_ahci }, /* DNV AHCI */ | ||
1138 | + { PCI_VDEVICE(INTEL, 0x19b1), board_ahci }, /* DNV AHCI */ | ||
1139 | + { PCI_VDEVICE(INTEL, 0x19b2), board_ahci }, /* DNV AHCI */ | ||
1140 | + { PCI_VDEVICE(INTEL, 0x19b3), board_ahci }, /* DNV AHCI */ | ||
1141 | + { PCI_VDEVICE(INTEL, 0x19b4), board_ahci }, /* DNV AHCI */ | ||
1142 | + { PCI_VDEVICE(INTEL, 0x19b5), board_ahci }, /* DNV AHCI */ | ||
1143 | + { PCI_VDEVICE(INTEL, 0x19b6), board_ahci }, /* DNV AHCI */ | ||
1144 | + { PCI_VDEVICE(INTEL, 0x19b7), board_ahci }, /* DNV AHCI */ | ||
1145 | + { PCI_VDEVICE(INTEL, 0x19bE), board_ahci }, /* DNV AHCI */ | ||
1146 | + { PCI_VDEVICE(INTEL, 0x19bF), board_ahci }, /* DNV AHCI */ | ||
1147 | + { PCI_VDEVICE(INTEL, 0x19c0), board_ahci }, /* DNV AHCI */ | ||
1148 | + { PCI_VDEVICE(INTEL, 0x19c1), board_ahci }, /* DNV AHCI */ | ||
1149 | + { PCI_VDEVICE(INTEL, 0x19c2), board_ahci }, /* DNV AHCI */ | ||
1150 | + { PCI_VDEVICE(INTEL, 0x19c3), board_ahci }, /* DNV AHCI */ | ||
1151 | + { PCI_VDEVICE(INTEL, 0x19c4), board_ahci }, /* DNV AHCI */ | ||
1152 | + { PCI_VDEVICE(INTEL, 0x19c5), board_ahci }, /* DNV AHCI */ | ||
1153 | + { PCI_VDEVICE(INTEL, 0x19c6), board_ahci }, /* DNV AHCI */ | ||
1154 | + { PCI_VDEVICE(INTEL, 0x19c7), board_ahci }, /* DNV AHCI */ | ||
1155 | + { PCI_VDEVICE(INTEL, 0x19cE), board_ahci }, /* DNV AHCI */ | ||
1156 | + { PCI_VDEVICE(INTEL, 0x19cF), board_ahci }, /* DNV AHCI */ | ||
1157 | { PCI_VDEVICE(INTEL, 0x1c02), board_ahci }, /* CPT AHCI */ | ||
1158 | { PCI_VDEVICE(INTEL, 0x1c03), board_ahci }, /* CPT AHCI */ | ||
1159 | { PCI_VDEVICE(INTEL, 0x1c04), board_ahci }, /* CPT RAID */ | ||
1160 | diff --git a/drivers/ata/libahci.c b/drivers/ata/libahci.c | ||
1161 | index 4665512dae44..1f225cc1827f 100644 | ||
1162 | --- a/drivers/ata/libahci.c | ||
1163 | +++ b/drivers/ata/libahci.c | ||
1164 | @@ -495,8 +495,8 @@ void ahci_save_initial_config(struct device *dev, struct ahci_host_priv *hpriv) | ||
1165 | } | ||
1166 | } | ||
1167 | |||
1168 | - /* fabricate port_map from cap.nr_ports */ | ||
1169 | - if (!port_map) { | ||
1170 | + /* fabricate port_map from cap.nr_ports for < AHCI 1.3 */ | ||
1171 | + if (!port_map && vers < 0x10300) { | ||
1172 | port_map = (1 << ahci_nr_ports(cap)) - 1; | ||
1173 | dev_warn(dev, "forcing PORTS_IMPL to 0x%x\n", port_map); | ||
1174 | |||
1175 | diff --git a/drivers/base/platform.c b/drivers/base/platform.c | ||
1176 | index 1dd6d3bf1098..176b59f5bc47 100644 | ||
1177 | --- a/drivers/base/platform.c | ||
1178 | +++ b/drivers/base/platform.c | ||
1179 | @@ -513,10 +513,15 @@ static int platform_drv_probe(struct device *_dev) | ||
1180 | return ret; | ||
1181 | |||
1182 | ret = dev_pm_domain_attach(_dev, true); | ||
1183 | - if (ret != -EPROBE_DEFER && drv->probe) { | ||
1184 | - ret = drv->probe(dev); | ||
1185 | - if (ret) | ||
1186 | - dev_pm_domain_detach(_dev, true); | ||
1187 | + if (ret != -EPROBE_DEFER) { | ||
1188 | + if (drv->probe) { | ||
1189 | + ret = drv->probe(dev); | ||
1190 | + if (ret) | ||
1191 | + dev_pm_domain_detach(_dev, true); | ||
1192 | + } else { | ||
1193 | + /* don't fail if just dev_pm_domain_attach failed */ | ||
1194 | + ret = 0; | ||
1195 | + } | ||
1196 | } | ||
1197 | |||
1198 | if (drv->prevent_deferred_probe && ret == -EPROBE_DEFER) { | ||
1199 | diff --git a/drivers/block/zram/zcomp.c b/drivers/block/zram/zcomp.c | ||
1200 | index 5cb13ca3a3ac..c53617752b93 100644 | ||
1201 | --- a/drivers/block/zram/zcomp.c | ||
1202 | +++ b/drivers/block/zram/zcomp.c | ||
1203 | @@ -76,7 +76,7 @@ static void zcomp_strm_free(struct zcomp *comp, struct zcomp_strm *zstrm) | ||
1204 | */ | ||
1205 | static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp) | ||
1206 | { | ||
1207 | - struct zcomp_strm *zstrm = kmalloc(sizeof(*zstrm), GFP_KERNEL); | ||
1208 | + struct zcomp_strm *zstrm = kmalloc(sizeof(*zstrm), GFP_NOIO); | ||
1209 | if (!zstrm) | ||
1210 | return NULL; | ||
1211 | |||
1212 | @@ -85,7 +85,7 @@ static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp) | ||
1213 | * allocate 2 pages. 1 for compressed data, plus 1 extra for the | ||
1214 | * case when compressed size is larger than the original one | ||
1215 | */ | ||
1216 | - zstrm->buffer = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, 1); | ||
1217 | + zstrm->buffer = (void *)__get_free_pages(GFP_NOIO | __GFP_ZERO, 1); | ||
1218 | if (!zstrm->private || !zstrm->buffer) { | ||
1219 | zcomp_strm_free(comp, zstrm); | ||
1220 | zstrm = NULL; | ||
1221 | diff --git a/drivers/block/zram/zcomp_lz4.c b/drivers/block/zram/zcomp_lz4.c | ||
1222 | index f2afb7e988c3..dd6083124276 100644 | ||
1223 | --- a/drivers/block/zram/zcomp_lz4.c | ||
1224 | +++ b/drivers/block/zram/zcomp_lz4.c | ||
1225 | @@ -10,17 +10,36 @@ | ||
1226 | #include <linux/kernel.h> | ||
1227 | #include <linux/slab.h> | ||
1228 | #include <linux/lz4.h> | ||
1229 | +#include <linux/vmalloc.h> | ||
1230 | +#include <linux/mm.h> | ||
1231 | |||
1232 | #include "zcomp_lz4.h" | ||
1233 | |||
1234 | static void *zcomp_lz4_create(void) | ||
1235 | { | ||
1236 | - return kzalloc(LZ4_MEM_COMPRESS, GFP_KERNEL); | ||
1237 | + void *ret; | ||
1238 | + | ||
1239 | + /* | ||
1240 | + * This function can be called in swapout/fs write path | ||
1241 | + * so we can't use GFP_FS|IO. And it assumes we already | ||
1242 | + * have at least one stream in zram initialization so we | ||
1243 | + * don't do best effort to allocate more stream in here. | ||
1244 | + * A default stream will work well without further multiple | ||
1245 | + * streams. That's why we use NORETRY | NOWARN. | ||
1246 | + */ | ||
1247 | + ret = kzalloc(LZ4_MEM_COMPRESS, GFP_NOIO | __GFP_NORETRY | | ||
1248 | + __GFP_NOWARN); | ||
1249 | + if (!ret) | ||
1250 | + ret = __vmalloc(LZ4_MEM_COMPRESS, | ||
1251 | + GFP_NOIO | __GFP_NORETRY | __GFP_NOWARN | | ||
1252 | + __GFP_ZERO | __GFP_HIGHMEM, | ||
1253 | + PAGE_KERNEL); | ||
1254 | + return ret; | ||
1255 | } | ||
1256 | |||
1257 | static void zcomp_lz4_destroy(void *private) | ||
1258 | { | ||
1259 | - kfree(private); | ||
1260 | + kvfree(private); | ||
1261 | } | ||
1262 | |||
1263 | static int zcomp_lz4_compress(const unsigned char *src, unsigned char *dst, | ||
1264 | diff --git a/drivers/block/zram/zcomp_lzo.c b/drivers/block/zram/zcomp_lzo.c | ||
1265 | index da1bc47d588e..edc549920fa0 100644 | ||
1266 | --- a/drivers/block/zram/zcomp_lzo.c | ||
1267 | +++ b/drivers/block/zram/zcomp_lzo.c | ||
1268 | @@ -10,17 +10,36 @@ | ||
1269 | #include <linux/kernel.h> | ||
1270 | #include <linux/slab.h> | ||
1271 | #include <linux/lzo.h> | ||
1272 | +#include <linux/vmalloc.h> | ||
1273 | +#include <linux/mm.h> | ||
1274 | |||
1275 | #include "zcomp_lzo.h" | ||
1276 | |||
1277 | static void *lzo_create(void) | ||
1278 | { | ||
1279 | - return kzalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL); | ||
1280 | + void *ret; | ||
1281 | + | ||
1282 | + /* | ||
1283 | + * This function can be called in swapout/fs write path | ||
1284 | + * so we can't use GFP_FS|IO. And it assumes we already | ||
1285 | + * have at least one stream in zram initialization so we | ||
1286 | + * don't do best effort to allocate more stream in here. | ||
1287 | + * A default stream will work well without further multiple | ||
1288 | + * streams. That's why we use NORETRY | NOWARN. | ||
1289 | + */ | ||
1290 | + ret = kzalloc(LZO1X_MEM_COMPRESS, GFP_NOIO | __GFP_NORETRY | | ||
1291 | + __GFP_NOWARN); | ||
1292 | + if (!ret) | ||
1293 | + ret = __vmalloc(LZO1X_MEM_COMPRESS, | ||
1294 | + GFP_NOIO | __GFP_NORETRY | __GFP_NOWARN | | ||
1295 | + __GFP_ZERO | __GFP_HIGHMEM, | ||
1296 | + PAGE_KERNEL); | ||
1297 | + return ret; | ||
1298 | } | ||
1299 | |||
1300 | static void lzo_destroy(void *private) | ||
1301 | { | ||
1302 | - kfree(private); | ||
1303 | + kvfree(private); | ||
1304 | } | ||
1305 | |||
1306 | static int lzo_compress(const unsigned char *src, unsigned char *dst, | ||
1307 | diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c | ||
1308 | index 47915d736f8d..370c2f76016d 100644 | ||
1309 | --- a/drivers/block/zram/zram_drv.c | ||
1310 | +++ b/drivers/block/zram/zram_drv.c | ||
1311 | @@ -1325,7 +1325,6 @@ static int zram_remove(struct zram *zram) | ||
1312 | |||
1313 | pr_info("Removed device: %s\n", zram->disk->disk_name); | ||
1314 | |||
1315 | - idr_remove(&zram_index_idr, zram->disk->first_minor); | ||
1316 | blk_cleanup_queue(zram->disk->queue); | ||
1317 | del_gendisk(zram->disk); | ||
1318 | put_disk(zram->disk); | ||
1319 | @@ -1367,10 +1366,12 @@ static ssize_t hot_remove_store(struct class *class, | ||
1320 | mutex_lock(&zram_index_mutex); | ||
1321 | |||
1322 | zram = idr_find(&zram_index_idr, dev_id); | ||
1323 | - if (zram) | ||
1324 | + if (zram) { | ||
1325 | ret = zram_remove(zram); | ||
1326 | - else | ||
1327 | + idr_remove(&zram_index_idr, dev_id); | ||
1328 | + } else { | ||
1329 | ret = -ENODEV; | ||
1330 | + } | ||
1331 | |||
1332 | mutex_unlock(&zram_index_mutex); | ||
1333 | return ret ? ret : count; | ||
1334 | diff --git a/drivers/crypto/atmel-sha.c b/drivers/crypto/atmel-sha.c | ||
1335 | index 660d8c06540b..3178f84d2757 100644 | ||
1336 | --- a/drivers/crypto/atmel-sha.c | ||
1337 | +++ b/drivers/crypto/atmel-sha.c | ||
1338 | @@ -783,7 +783,7 @@ static void atmel_sha_finish_req(struct ahash_request *req, int err) | ||
1339 | dd->flags &= ~(SHA_FLAGS_BUSY | SHA_FLAGS_FINAL | SHA_FLAGS_CPU | | ||
1340 | SHA_FLAGS_DMA_READY | SHA_FLAGS_OUTPUT_READY); | ||
1341 | |||
1342 | - clk_disable_unprepare(dd->iclk); | ||
1343 | + clk_disable(dd->iclk); | ||
1344 | |||
1345 | if (req->base.complete) | ||
1346 | req->base.complete(&req->base, err); | ||
1347 | @@ -796,7 +796,7 @@ static int atmel_sha_hw_init(struct atmel_sha_dev *dd) | ||
1348 | { | ||
1349 | int err; | ||
1350 | |||
1351 | - err = clk_prepare_enable(dd->iclk); | ||
1352 | + err = clk_enable(dd->iclk); | ||
1353 | if (err) | ||
1354 | return err; | ||
1355 | |||
1356 | @@ -823,7 +823,7 @@ static void atmel_sha_hw_version_init(struct atmel_sha_dev *dd) | ||
1357 | dev_info(dd->dev, | ||
1358 | "version: 0x%x\n", dd->hw_version); | ||
1359 | |||
1360 | - clk_disable_unprepare(dd->iclk); | ||
1361 | + clk_disable(dd->iclk); | ||
1362 | } | ||
1363 | |||
1364 | static int atmel_sha_handle_queue(struct atmel_sha_dev *dd, | ||
1365 | @@ -1411,6 +1411,10 @@ static int atmel_sha_probe(struct platform_device *pdev) | ||
1366 | goto res_err; | ||
1367 | } | ||
1368 | |||
1369 | + err = clk_prepare(sha_dd->iclk); | ||
1370 | + if (err) | ||
1371 | + goto res_err; | ||
1372 | + | ||
1373 | atmel_sha_hw_version_init(sha_dd); | ||
1374 | |||
1375 | atmel_sha_get_cap(sha_dd); | ||
1376 | @@ -1422,12 +1426,12 @@ static int atmel_sha_probe(struct platform_device *pdev) | ||
1377 | if (IS_ERR(pdata)) { | ||
1378 | dev_err(&pdev->dev, "platform data not available\n"); | ||
1379 | err = PTR_ERR(pdata); | ||
1380 | - goto res_err; | ||
1381 | + goto iclk_unprepare; | ||
1382 | } | ||
1383 | } | ||
1384 | if (!pdata->dma_slave) { | ||
1385 | err = -ENXIO; | ||
1386 | - goto res_err; | ||
1387 | + goto iclk_unprepare; | ||
1388 | } | ||
1389 | err = atmel_sha_dma_init(sha_dd, pdata); | ||
1390 | if (err) | ||
1391 | @@ -1458,6 +1462,8 @@ err_algs: | ||
1392 | if (sha_dd->caps.has_dma) | ||
1393 | atmel_sha_dma_cleanup(sha_dd); | ||
1394 | err_sha_dma: | ||
1395 | +iclk_unprepare: | ||
1396 | + clk_unprepare(sha_dd->iclk); | ||
1397 | res_err: | ||
1398 | tasklet_kill(&sha_dd->done_task); | ||
1399 | sha_dd_err: | ||
1400 | @@ -1484,12 +1490,7 @@ static int atmel_sha_remove(struct platform_device *pdev) | ||
1401 | if (sha_dd->caps.has_dma) | ||
1402 | atmel_sha_dma_cleanup(sha_dd); | ||
1403 | |||
1404 | - iounmap(sha_dd->io_base); | ||
1405 | - | ||
1406 | - clk_put(sha_dd->iclk); | ||
1407 | - | ||
1408 | - if (sha_dd->irq >= 0) | ||
1409 | - free_irq(sha_dd->irq, sha_dd); | ||
1410 | + clk_unprepare(sha_dd->iclk); | ||
1411 | |||
1412 | return 0; | ||
1413 | } | ||
1414 | diff --git a/drivers/crypto/caam/ctrl.c b/drivers/crypto/caam/ctrl.c | ||
1415 | index 8abb4bc548cc..69d4a1326fee 100644 | ||
1416 | --- a/drivers/crypto/caam/ctrl.c | ||
1417 | +++ b/drivers/crypto/caam/ctrl.c | ||
1418 | @@ -534,8 +534,8 @@ static int caam_probe(struct platform_device *pdev) | ||
1419 | * long pointers in master configuration register | ||
1420 | */ | ||
1421 | clrsetbits_32(&ctrl->mcr, MCFGR_AWCACHE_MASK, MCFGR_AWCACHE_CACH | | ||
1422 | - MCFGR_WDENABLE | (sizeof(dma_addr_t) == sizeof(u64) ? | ||
1423 | - MCFGR_LONG_PTR : 0)); | ||
1424 | + MCFGR_AWCACHE_BUFF | MCFGR_WDENABLE | | ||
1425 | + (sizeof(dma_addr_t) == sizeof(u64) ? MCFGR_LONG_PTR : 0)); | ||
1426 | |||
1427 | /* | ||
1428 | * Read the Compile Time paramters and SCFGR to determine | ||
1429 | diff --git a/drivers/crypto/marvell/cesa.c b/drivers/crypto/marvell/cesa.c | ||
1430 | index 0643e3366e33..c0656e7f37b5 100644 | ||
1431 | --- a/drivers/crypto/marvell/cesa.c | ||
1432 | +++ b/drivers/crypto/marvell/cesa.c | ||
1433 | @@ -306,7 +306,7 @@ static int mv_cesa_dev_dma_init(struct mv_cesa_dev *cesa) | ||
1434 | return -ENOMEM; | ||
1435 | |||
1436 | dma->padding_pool = dmam_pool_create("cesa_padding", dev, 72, 1, 0); | ||
1437 | - if (!dma->cache_pool) | ||
1438 | + if (!dma->padding_pool) | ||
1439 | return -ENOMEM; | ||
1440 | |||
1441 | cesa->dma = dma; | ||
1442 | diff --git a/drivers/crypto/sunxi-ss/sun4i-ss-core.c b/drivers/crypto/sunxi-ss/sun4i-ss-core.c | ||
1443 | index eab6fe227fa0..107cd2a41cae 100644 | ||
1444 | --- a/drivers/crypto/sunxi-ss/sun4i-ss-core.c | ||
1445 | +++ b/drivers/crypto/sunxi-ss/sun4i-ss-core.c | ||
1446 | @@ -39,6 +39,7 @@ static struct sun4i_ss_alg_template ss_algs[] = { | ||
1447 | .import = sun4i_hash_import_md5, | ||
1448 | .halg = { | ||
1449 | .digestsize = MD5_DIGEST_SIZE, | ||
1450 | + .statesize = sizeof(struct md5_state), | ||
1451 | .base = { | ||
1452 | .cra_name = "md5", | ||
1453 | .cra_driver_name = "md5-sun4i-ss", | ||
1454 | @@ -66,6 +67,7 @@ static struct sun4i_ss_alg_template ss_algs[] = { | ||
1455 | .import = sun4i_hash_import_sha1, | ||
1456 | .halg = { | ||
1457 | .digestsize = SHA1_DIGEST_SIZE, | ||
1458 | + .statesize = sizeof(struct sha1_state), | ||
1459 | .base = { | ||
1460 | .cra_name = "sha1", | ||
1461 | .cra_driver_name = "sha1-sun4i-ss", | ||
1462 | diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c | ||
1463 | index 3d664d01305e..2b8ff18d3713 100644 | ||
1464 | --- a/drivers/hid/hid-multitouch.c | ||
1465 | +++ b/drivers/hid/hid-multitouch.c | ||
1466 | @@ -357,8 +357,19 @@ static void mt_feature_mapping(struct hid_device *hdev, | ||
1467 | break; | ||
1468 | } | ||
1469 | |||
1470 | - td->inputmode = field->report->id; | ||
1471 | - td->inputmode_index = usage->usage_index; | ||
1472 | + if (td->inputmode < 0) { | ||
1473 | + td->inputmode = field->report->id; | ||
1474 | + td->inputmode_index = usage->usage_index; | ||
1475 | + } else { | ||
1476 | + /* | ||
1477 | + * Some elan panels wrongly declare 2 input mode | ||
1478 | + * features, and silently ignore when we set the | ||
1479 | + * value in the second field. Skip the second feature | ||
1480 | + * and hope for the best. | ||
1481 | + */ | ||
1482 | + dev_info(&hdev->dev, | ||
1483 | + "Ignoring the extra HID_DG_INPUTMODE\n"); | ||
1484 | + } | ||
1485 | |||
1486 | break; | ||
1487 | case HID_DG_CONTACTMAX: | ||
1488 | diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c | ||
1489 | index 36712e9f56c2..5dd426fee8cc 100644 | ||
1490 | --- a/drivers/hid/usbhid/hid-core.c | ||
1491 | +++ b/drivers/hid/usbhid/hid-core.c | ||
1492 | @@ -477,8 +477,6 @@ static void hid_ctrl(struct urb *urb) | ||
1493 | struct usbhid_device *usbhid = hid->driver_data; | ||
1494 | int unplug = 0, status = urb->status; | ||
1495 | |||
1496 | - spin_lock(&usbhid->lock); | ||
1497 | - | ||
1498 | switch (status) { | ||
1499 | case 0: /* success */ | ||
1500 | if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN) | ||
1501 | @@ -498,6 +496,8 @@ static void hid_ctrl(struct urb *urb) | ||
1502 | hid_warn(urb->dev, "ctrl urb status %d received\n", status); | ||
1503 | } | ||
1504 | |||
1505 | + spin_lock(&usbhid->lock); | ||
1506 | + | ||
1507 | if (unplug) { | ||
1508 | usbhid->ctrltail = usbhid->ctrlhead; | ||
1509 | } else { | ||
1510 | diff --git a/drivers/iommu/io-pgtable-arm.c b/drivers/iommu/io-pgtable-arm.c | ||
1511 | index 7df97777662d..dad768caa9c5 100644 | ||
1512 | --- a/drivers/iommu/io-pgtable-arm.c | ||
1513 | +++ b/drivers/iommu/io-pgtable-arm.c | ||
1514 | @@ -405,17 +405,18 @@ static void __arm_lpae_free_pgtable(struct arm_lpae_io_pgtable *data, int lvl, | ||
1515 | arm_lpae_iopte *start, *end; | ||
1516 | unsigned long table_size; | ||
1517 | |||
1518 | - /* Only leaf entries at the last level */ | ||
1519 | - if (lvl == ARM_LPAE_MAX_LEVELS - 1) | ||
1520 | - return; | ||
1521 | - | ||
1522 | if (lvl == ARM_LPAE_START_LVL(data)) | ||
1523 | table_size = data->pgd_size; | ||
1524 | else | ||
1525 | table_size = 1UL << data->pg_shift; | ||
1526 | |||
1527 | start = ptep; | ||
1528 | - end = (void *)ptep + table_size; | ||
1529 | + | ||
1530 | + /* Only leaf entries at the last level */ | ||
1531 | + if (lvl == ARM_LPAE_MAX_LEVELS - 1) | ||
1532 | + end = ptep; | ||
1533 | + else | ||
1534 | + end = (void *)ptep + table_size; | ||
1535 | |||
1536 | while (ptep != end) { | ||
1537 | arm_lpae_iopte pte = *ptep++; | ||
1538 | diff --git a/drivers/md/md.c b/drivers/md/md.c | ||
1539 | index 61aacab424cf..b1e1f6b95782 100644 | ||
1540 | --- a/drivers/md/md.c | ||
1541 | +++ b/drivers/md/md.c | ||
1542 | @@ -2017,28 +2017,32 @@ int md_integrity_register(struct mddev *mddev) | ||
1543 | } | ||
1544 | EXPORT_SYMBOL(md_integrity_register); | ||
1545 | |||
1546 | -/* Disable data integrity if non-capable/non-matching disk is being added */ | ||
1547 | -void md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev) | ||
1548 | +/* | ||
1549 | + * Attempt to add an rdev, but only if it is consistent with the current | ||
1550 | + * integrity profile | ||
1551 | + */ | ||
1552 | +int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev) | ||
1553 | { | ||
1554 | struct blk_integrity *bi_rdev; | ||
1555 | struct blk_integrity *bi_mddev; | ||
1556 | + char name[BDEVNAME_SIZE]; | ||
1557 | |||
1558 | if (!mddev->gendisk) | ||
1559 | - return; | ||
1560 | + return 0; | ||
1561 | |||
1562 | bi_rdev = bdev_get_integrity(rdev->bdev); | ||
1563 | bi_mddev = blk_get_integrity(mddev->gendisk); | ||
1564 | |||
1565 | if (!bi_mddev) /* nothing to do */ | ||
1566 | - return; | ||
1567 | - if (rdev->raid_disk < 0) /* skip spares */ | ||
1568 | - return; | ||
1569 | - if (bi_rdev && blk_integrity_compare(mddev->gendisk, | ||
1570 | - rdev->bdev->bd_disk) >= 0) | ||
1571 | - return; | ||
1572 | - WARN_ON_ONCE(!mddev->suspended); | ||
1573 | - printk(KERN_NOTICE "disabling data integrity on %s\n", mdname(mddev)); | ||
1574 | - blk_integrity_unregister(mddev->gendisk); | ||
1575 | + return 0; | ||
1576 | + | ||
1577 | + if (blk_integrity_compare(mddev->gendisk, rdev->bdev->bd_disk) != 0) { | ||
1578 | + printk(KERN_NOTICE "%s: incompatible integrity profile for %s\n", | ||
1579 | + mdname(mddev), bdevname(rdev->bdev, name)); | ||
1580 | + return -ENXIO; | ||
1581 | + } | ||
1582 | + | ||
1583 | + return 0; | ||
1584 | } | ||
1585 | EXPORT_SYMBOL(md_integrity_add_rdev); | ||
1586 | |||
1587 | diff --git a/drivers/md/md.h b/drivers/md/md.h | ||
1588 | index ca0b643fe3c1..dfa57b41541b 100644 | ||
1589 | --- a/drivers/md/md.h | ||
1590 | +++ b/drivers/md/md.h | ||
1591 | @@ -657,7 +657,7 @@ extern void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev); | ||
1592 | extern void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors); | ||
1593 | extern int md_check_no_bitmap(struct mddev *mddev); | ||
1594 | extern int md_integrity_register(struct mddev *mddev); | ||
1595 | -extern void md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev); | ||
1596 | +extern int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev); | ||
1597 | extern int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale); | ||
1598 | |||
1599 | extern void mddev_init(struct mddev *mddev); | ||
1600 | diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c | ||
1601 | index 7331a80d89f1..0a72ab6e6c20 100644 | ||
1602 | --- a/drivers/md/multipath.c | ||
1603 | +++ b/drivers/md/multipath.c | ||
1604 | @@ -257,6 +257,9 @@ static int multipath_add_disk(struct mddev *mddev, struct md_rdev *rdev) | ||
1605 | disk_stack_limits(mddev->gendisk, rdev->bdev, | ||
1606 | rdev->data_offset << 9); | ||
1607 | |||
1608 | + err = md_integrity_add_rdev(rdev, mddev); | ||
1609 | + if (err) | ||
1610 | + break; | ||
1611 | spin_lock_irq(&conf->device_lock); | ||
1612 | mddev->degraded--; | ||
1613 | rdev->raid_disk = path; | ||
1614 | @@ -264,9 +267,6 @@ static int multipath_add_disk(struct mddev *mddev, struct md_rdev *rdev) | ||
1615 | spin_unlock_irq(&conf->device_lock); | ||
1616 | rcu_assign_pointer(p->rdev, rdev); | ||
1617 | err = 0; | ||
1618 | - mddev_suspend(mddev); | ||
1619 | - md_integrity_add_rdev(rdev, mddev); | ||
1620 | - mddev_resume(mddev); | ||
1621 | break; | ||
1622 | } | ||
1623 | |||
1624 | diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c | ||
1625 | index e2169ff6e0f0..c4b913409226 100644 | ||
1626 | --- a/drivers/md/raid1.c | ||
1627 | +++ b/drivers/md/raid1.c | ||
1628 | @@ -1589,6 +1589,9 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev) | ||
1629 | if (mddev->recovery_disabled == conf->recovery_disabled) | ||
1630 | return -EBUSY; | ||
1631 | |||
1632 | + if (md_integrity_add_rdev(rdev, mddev)) | ||
1633 | + return -ENXIO; | ||
1634 | + | ||
1635 | if (rdev->raid_disk >= 0) | ||
1636 | first = last = rdev->raid_disk; | ||
1637 | |||
1638 | @@ -1632,9 +1635,6 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev) | ||
1639 | break; | ||
1640 | } | ||
1641 | } | ||
1642 | - mddev_suspend(mddev); | ||
1643 | - md_integrity_add_rdev(rdev, mddev); | ||
1644 | - mddev_resume(mddev); | ||
1645 | if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev))) | ||
1646 | queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue); | ||
1647 | print_conf(conf); | ||
1648 | diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c | ||
1649 | index 84e597e1c489..ce959b4ae4df 100644 | ||
1650 | --- a/drivers/md/raid10.c | ||
1651 | +++ b/drivers/md/raid10.c | ||
1652 | @@ -1698,6 +1698,9 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev) | ||
1653 | if (rdev->saved_raid_disk < 0 && !_enough(conf, 1, -1)) | ||
1654 | return -EINVAL; | ||
1655 | |||
1656 | + if (md_integrity_add_rdev(rdev, mddev)) | ||
1657 | + return -ENXIO; | ||
1658 | + | ||
1659 | if (rdev->raid_disk >= 0) | ||
1660 | first = last = rdev->raid_disk; | ||
1661 | |||
1662 | @@ -1739,9 +1742,6 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev) | ||
1663 | rcu_assign_pointer(p->rdev, rdev); | ||
1664 | break; | ||
1665 | } | ||
1666 | - mddev_suspend(mddev); | ||
1667 | - md_integrity_add_rdev(rdev, mddev); | ||
1668 | - mddev_resume(mddev); | ||
1669 | if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev))) | ||
1670 | queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue); | ||
1671 | |||
1672 | diff --git a/drivers/media/i2c/ir-kbd-i2c.c b/drivers/media/i2c/ir-kbd-i2c.c | ||
1673 | index 728d2cc8a3e7..175a76114953 100644 | ||
1674 | --- a/drivers/media/i2c/ir-kbd-i2c.c | ||
1675 | +++ b/drivers/media/i2c/ir-kbd-i2c.c | ||
1676 | @@ -478,7 +478,6 @@ static const struct i2c_device_id ir_kbd_id[] = { | ||
1677 | { "ir_rx_z8f0811_hdpvr", 0 }, | ||
1678 | { } | ||
1679 | }; | ||
1680 | -MODULE_DEVICE_TABLE(i2c, ir_kbd_id); | ||
1681 | |||
1682 | static struct i2c_driver ir_kbd_driver = { | ||
1683 | .driver = { | ||
1684 | diff --git a/drivers/media/pci/saa7134/saa7134-alsa.c b/drivers/media/pci/saa7134/saa7134-alsa.c | ||
1685 | index 1d2c310ce838..94f816244407 100644 | ||
1686 | --- a/drivers/media/pci/saa7134/saa7134-alsa.c | ||
1687 | +++ b/drivers/media/pci/saa7134/saa7134-alsa.c | ||
1688 | @@ -1211,6 +1211,8 @@ static int alsa_device_init(struct saa7134_dev *dev) | ||
1689 | |||
1690 | static int alsa_device_exit(struct saa7134_dev *dev) | ||
1691 | { | ||
1692 | + if (!snd_saa7134_cards[dev->nr]) | ||
1693 | + return 1; | ||
1694 | |||
1695 | snd_card_free(snd_saa7134_cards[dev->nr]); | ||
1696 | snd_saa7134_cards[dev->nr] = NULL; | ||
1697 | @@ -1260,7 +1262,8 @@ static void saa7134_alsa_exit(void) | ||
1698 | int idx; | ||
1699 | |||
1700 | for (idx = 0; idx < SNDRV_CARDS; idx++) { | ||
1701 | - snd_card_free(snd_saa7134_cards[idx]); | ||
1702 | + if (snd_saa7134_cards[idx]) | ||
1703 | + snd_card_free(snd_saa7134_cards[idx]); | ||
1704 | } | ||
1705 | |||
1706 | saa7134_dmasound_init = NULL; | ||
1707 | diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c | ||
1708 | index ece544efccc3..3ff583f165cd 100644 | ||
1709 | --- a/drivers/mtd/nand/nand_base.c | ||
1710 | +++ b/drivers/mtd/nand/nand_base.c | ||
1711 | @@ -3995,6 +3995,9 @@ int nand_scan_ident(struct mtd_info *mtd, int maxchips, | ||
1712 | return ret; | ||
1713 | } | ||
1714 | |||
1715 | + if (!mtd->name && mtd->dev.parent) | ||
1716 | + mtd->name = dev_name(mtd->dev.parent); | ||
1717 | + | ||
1718 | /* Set the default functions */ | ||
1719 | nand_set_defaults(chip, chip->options & NAND_BUSWIDTH_16); | ||
1720 | |||
1721 | diff --git a/drivers/net/wireless/realtek/rtlwifi/regd.c b/drivers/net/wireless/realtek/rtlwifi/regd.c | ||
1722 | index a62bf0a65c32..5be34118e0af 100644 | ||
1723 | --- a/drivers/net/wireless/realtek/rtlwifi/regd.c | ||
1724 | +++ b/drivers/net/wireless/realtek/rtlwifi/regd.c | ||
1725 | @@ -351,7 +351,6 @@ static const struct ieee80211_regdomain *_rtl_regdomain_select( | ||
1726 | case COUNTRY_CODE_SPAIN: | ||
1727 | case COUNTRY_CODE_FRANCE: | ||
1728 | case COUNTRY_CODE_ISRAEL: | ||
1729 | - case COUNTRY_CODE_WORLD_WIDE_13: | ||
1730 | return &rtl_regdom_12_13; | ||
1731 | case COUNTRY_CODE_MKK: | ||
1732 | case COUNTRY_CODE_MKK1: | ||
1733 | @@ -360,6 +359,7 @@ static const struct ieee80211_regdomain *_rtl_regdomain_select( | ||
1734 | return &rtl_regdom_14_60_64; | ||
1735 | case COUNTRY_CODE_GLOBAL_DOMAIN: | ||
1736 | return &rtl_regdom_14; | ||
1737 | + case COUNTRY_CODE_WORLD_WIDE_13: | ||
1738 | case COUNTRY_CODE_WORLD_WIDE_13_5G_ALL: | ||
1739 | return &rtl_regdom_12_13_5g_all; | ||
1740 | default: | ||
1741 | diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/sw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/sw.c | ||
1742 | index 142bdff4ed60..4159f9b14db6 100644 | ||
1743 | --- a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/sw.c | ||
1744 | +++ b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/sw.c | ||
1745 | @@ -95,8 +95,6 @@ int rtl8821ae_init_sw_vars(struct ieee80211_hw *hw) | ||
1746 | struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); | ||
1747 | |||
1748 | rtl8821ae_bt_reg_init(hw); | ||
1749 | - rtlpci->msi_support = rtlpriv->cfg->mod_params->msi_support; | ||
1750 | - rtlpci->int_clear = rtlpriv->cfg->mod_params->int_clear; | ||
1751 | rtlpriv->btcoexist.btc_ops = rtl_btc_get_ops_pointer(); | ||
1752 | |||
1753 | rtlpriv->dm.dm_initialgain_enable = 1; | ||
1754 | @@ -168,12 +166,15 @@ int rtl8821ae_init_sw_vars(struct ieee80211_hw *hw) | ||
1755 | rtlpriv->psc.swctrl_lps = rtlpriv->cfg->mod_params->swctrl_lps; | ||
1756 | rtlpriv->psc.fwctrl_lps = rtlpriv->cfg->mod_params->fwctrl_lps; | ||
1757 | rtlpci->msi_support = rtlpriv->cfg->mod_params->msi_support; | ||
1758 | - rtlpci->msi_support = rtlpriv->cfg->mod_params->int_clear; | ||
1759 | + rtlpci->int_clear = rtlpriv->cfg->mod_params->int_clear; | ||
1760 | + rtlpriv->cfg->mod_params->sw_crypto = | ||
1761 | + rtlpriv->cfg->mod_params->sw_crypto; | ||
1762 | + rtlpriv->cfg->mod_params->disable_watchdog = | ||
1763 | + rtlpriv->cfg->mod_params->disable_watchdog; | ||
1764 | if (rtlpriv->cfg->mod_params->disable_watchdog) | ||
1765 | pr_info("watchdog disabled\n"); | ||
1766 | rtlpriv->psc.reg_fwctrl_lps = 3; | ||
1767 | rtlpriv->psc.reg_max_lps_awakeintvl = 5; | ||
1768 | - rtlpci->msi_support = rtlpriv->cfg->mod_params->msi_support; | ||
1769 | |||
1770 | /* for ASPM, you can close aspm through | ||
1771 | * set const_support_pciaspm = 0 | ||
1772 | diff --git a/drivers/net/wireless/ti/wlcore/io.h b/drivers/net/wireless/ti/wlcore/io.h | ||
1773 | index 0305729d0986..10cf3747694d 100644 | ||
1774 | --- a/drivers/net/wireless/ti/wlcore/io.h | ||
1775 | +++ b/drivers/net/wireless/ti/wlcore/io.h | ||
1776 | @@ -207,19 +207,23 @@ static inline int __must_check wlcore_write_reg(struct wl1271 *wl, int reg, | ||
1777 | |||
1778 | static inline void wl1271_power_off(struct wl1271 *wl) | ||
1779 | { | ||
1780 | - int ret; | ||
1781 | + int ret = 0; | ||
1782 | |||
1783 | if (!test_bit(WL1271_FLAG_GPIO_POWER, &wl->flags)) | ||
1784 | return; | ||
1785 | |||
1786 | - ret = wl->if_ops->power(wl->dev, false); | ||
1787 | + if (wl->if_ops->power) | ||
1788 | + ret = wl->if_ops->power(wl->dev, false); | ||
1789 | if (!ret) | ||
1790 | clear_bit(WL1271_FLAG_GPIO_POWER, &wl->flags); | ||
1791 | } | ||
1792 | |||
1793 | static inline int wl1271_power_on(struct wl1271 *wl) | ||
1794 | { | ||
1795 | - int ret = wl->if_ops->power(wl->dev, true); | ||
1796 | + int ret = 0; | ||
1797 | + | ||
1798 | + if (wl->if_ops->power) | ||
1799 | + ret = wl->if_ops->power(wl->dev, true); | ||
1800 | if (ret == 0) | ||
1801 | set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags); | ||
1802 | |||
1803 | diff --git a/drivers/net/wireless/ti/wlcore/spi.c b/drivers/net/wireless/ti/wlcore/spi.c | ||
1804 | index 236b41090827..44f059f7f34e 100644 | ||
1805 | --- a/drivers/net/wireless/ti/wlcore/spi.c | ||
1806 | +++ b/drivers/net/wireless/ti/wlcore/spi.c | ||
1807 | @@ -73,7 +73,10 @@ | ||
1808 | */ | ||
1809 | #define SPI_AGGR_BUFFER_SIZE (4 * PAGE_SIZE) | ||
1810 | |||
1811 | -#define WSPI_MAX_NUM_OF_CHUNKS (SPI_AGGR_BUFFER_SIZE / WSPI_MAX_CHUNK_SIZE) | ||
1812 | +/* Maximum number of SPI write chunks */ | ||
1813 | +#define WSPI_MAX_NUM_OF_CHUNKS \ | ||
1814 | + ((SPI_AGGR_BUFFER_SIZE / WSPI_MAX_CHUNK_SIZE) + 1) | ||
1815 | + | ||
1816 | |||
1817 | struct wl12xx_spi_glue { | ||
1818 | struct device *dev; | ||
1819 | @@ -268,9 +271,10 @@ static int __must_check wl12xx_spi_raw_write(struct device *child, int addr, | ||
1820 | void *buf, size_t len, bool fixed) | ||
1821 | { | ||
1822 | struct wl12xx_spi_glue *glue = dev_get_drvdata(child->parent); | ||
1823 | - struct spi_transfer t[2 * (WSPI_MAX_NUM_OF_CHUNKS + 1)]; | ||
1824 | + /* SPI write buffers - 2 for each chunk */ | ||
1825 | + struct spi_transfer t[2 * WSPI_MAX_NUM_OF_CHUNKS]; | ||
1826 | struct spi_message m; | ||
1827 | - u32 commands[WSPI_MAX_NUM_OF_CHUNKS]; | ||
1828 | + u32 commands[WSPI_MAX_NUM_OF_CHUNKS]; /* 1 command per chunk */ | ||
1829 | u32 *cmd; | ||
1830 | u32 chunk_len; | ||
1831 | int i; | ||
1832 | diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c | ||
1833 | index d3346d23963b..89b3befc7155 100644 | ||
1834 | --- a/drivers/pci/bus.c | ||
1835 | +++ b/drivers/pci/bus.c | ||
1836 | @@ -140,6 +140,8 @@ static int pci_bus_alloc_from_region(struct pci_bus *bus, struct resource *res, | ||
1837 | type_mask |= IORESOURCE_TYPE_BITS; | ||
1838 | |||
1839 | pci_bus_for_each_resource(bus, r, i) { | ||
1840 | + resource_size_t min_used = min; | ||
1841 | + | ||
1842 | if (!r) | ||
1843 | continue; | ||
1844 | |||
1845 | @@ -163,12 +165,12 @@ static int pci_bus_alloc_from_region(struct pci_bus *bus, struct resource *res, | ||
1846 | * overrides "min". | ||
1847 | */ | ||
1848 | if (avail.start) | ||
1849 | - min = avail.start; | ||
1850 | + min_used = avail.start; | ||
1851 | |||
1852 | max = avail.end; | ||
1853 | |||
1854 | /* Ok, try it out.. */ | ||
1855 | - ret = allocate_resource(r, res, size, min, max, | ||
1856 | + ret = allocate_resource(r, res, size, min_used, max, | ||
1857 | align, alignf, alignf_data); | ||
1858 | if (ret == 0) | ||
1859 | return 0; | ||
1860 | diff --git a/drivers/pci/host/pci-dra7xx.c b/drivers/pci/host/pci-dra7xx.c | ||
1861 | index 8c3688046c02..923607bdabc5 100644 | ||
1862 | --- a/drivers/pci/host/pci-dra7xx.c | ||
1863 | +++ b/drivers/pci/host/pci-dra7xx.c | ||
1864 | @@ -302,7 +302,8 @@ static int __init dra7xx_add_pcie_port(struct dra7xx_pcie *dra7xx, | ||
1865 | } | ||
1866 | |||
1867 | ret = devm_request_irq(&pdev->dev, pp->irq, | ||
1868 | - dra7xx_pcie_msi_irq_handler, IRQF_SHARED, | ||
1869 | + dra7xx_pcie_msi_irq_handler, | ||
1870 | + IRQF_SHARED | IRQF_NO_THREAD, | ||
1871 | "dra7-pcie-msi", pp); | ||
1872 | if (ret) { | ||
1873 | dev_err(&pdev->dev, "failed to request irq\n"); | ||
1874 | diff --git a/drivers/pci/host/pci-exynos.c b/drivers/pci/host/pci-exynos.c | ||
1875 | index 01095e1160a4..d997d22d4231 100644 | ||
1876 | --- a/drivers/pci/host/pci-exynos.c | ||
1877 | +++ b/drivers/pci/host/pci-exynos.c | ||
1878 | @@ -522,7 +522,8 @@ static int __init exynos_add_pcie_port(struct pcie_port *pp, | ||
1879 | |||
1880 | ret = devm_request_irq(&pdev->dev, pp->msi_irq, | ||
1881 | exynos_pcie_msi_irq_handler, | ||
1882 | - IRQF_SHARED, "exynos-pcie", pp); | ||
1883 | + IRQF_SHARED | IRQF_NO_THREAD, | ||
1884 | + "exynos-pcie", pp); | ||
1885 | if (ret) { | ||
1886 | dev_err(&pdev->dev, "failed to request msi irq\n"); | ||
1887 | return ret; | ||
1888 | diff --git a/drivers/pci/host/pci-imx6.c b/drivers/pci/host/pci-imx6.c | ||
1889 | index 22e8224126fd..9ce7cd148c86 100644 | ||
1890 | --- a/drivers/pci/host/pci-imx6.c | ||
1891 | +++ b/drivers/pci/host/pci-imx6.c | ||
1892 | @@ -537,7 +537,8 @@ static int __init imx6_add_pcie_port(struct pcie_port *pp, | ||
1893 | |||
1894 | ret = devm_request_irq(&pdev->dev, pp->msi_irq, | ||
1895 | imx6_pcie_msi_handler, | ||
1896 | - IRQF_SHARED, "mx6-pcie-msi", pp); | ||
1897 | + IRQF_SHARED | IRQF_NO_THREAD, | ||
1898 | + "mx6-pcie-msi", pp); | ||
1899 | if (ret) { | ||
1900 | dev_err(&pdev->dev, "failed to request MSI irq\n"); | ||
1901 | return ret; | ||
1902 | diff --git a/drivers/pci/host/pci-tegra.c b/drivers/pci/host/pci-tegra.c | ||
1903 | index 3018ae52e092..30323114c53c 100644 | ||
1904 | --- a/drivers/pci/host/pci-tegra.c | ||
1905 | +++ b/drivers/pci/host/pci-tegra.c | ||
1906 | @@ -1288,7 +1288,7 @@ static int tegra_pcie_enable_msi(struct tegra_pcie *pcie) | ||
1907 | |||
1908 | msi->irq = err; | ||
1909 | |||
1910 | - err = request_irq(msi->irq, tegra_pcie_msi_irq, 0, | ||
1911 | + err = request_irq(msi->irq, tegra_pcie_msi_irq, IRQF_NO_THREAD, | ||
1912 | tegra_msi_irq_chip.name, pcie); | ||
1913 | if (err < 0) { | ||
1914 | dev_err(&pdev->dev, "failed to request IRQ: %d\n", err); | ||
1915 | diff --git a/drivers/pci/host/pcie-rcar.c b/drivers/pci/host/pcie-rcar.c | ||
1916 | index f4fa6c537448..414c33686621 100644 | ||
1917 | --- a/drivers/pci/host/pcie-rcar.c | ||
1918 | +++ b/drivers/pci/host/pcie-rcar.c | ||
1919 | @@ -720,14 +720,16 @@ static int rcar_pcie_enable_msi(struct rcar_pcie *pcie) | ||
1920 | |||
1921 | /* Two irqs are for MSI, but they are also used for non-MSI irqs */ | ||
1922 | err = devm_request_irq(&pdev->dev, msi->irq1, rcar_pcie_msi_irq, | ||
1923 | - IRQF_SHARED, rcar_msi_irq_chip.name, pcie); | ||
1924 | + IRQF_SHARED | IRQF_NO_THREAD, | ||
1925 | + rcar_msi_irq_chip.name, pcie); | ||
1926 | if (err < 0) { | ||
1927 | dev_err(&pdev->dev, "failed to request IRQ: %d\n", err); | ||
1928 | goto err; | ||
1929 | } | ||
1930 | |||
1931 | err = devm_request_irq(&pdev->dev, msi->irq2, rcar_pcie_msi_irq, | ||
1932 | - IRQF_SHARED, rcar_msi_irq_chip.name, pcie); | ||
1933 | + IRQF_SHARED | IRQF_NO_THREAD, | ||
1934 | + rcar_msi_irq_chip.name, pcie); | ||
1935 | if (err < 0) { | ||
1936 | dev_err(&pdev->dev, "failed to request IRQ: %d\n", err); | ||
1937 | goto err; | ||
1938 | diff --git a/drivers/pci/host/pcie-spear13xx.c b/drivers/pci/host/pcie-spear13xx.c | ||
1939 | index b95b7563c052..a6cd8233e8c0 100644 | ||
1940 | --- a/drivers/pci/host/pcie-spear13xx.c | ||
1941 | +++ b/drivers/pci/host/pcie-spear13xx.c | ||
1942 | @@ -279,7 +279,8 @@ static int spear13xx_add_pcie_port(struct pcie_port *pp, | ||
1943 | return -ENODEV; | ||
1944 | } | ||
1945 | ret = devm_request_irq(dev, pp->irq, spear13xx_pcie_irq_handler, | ||
1946 | - IRQF_SHARED, "spear1340-pcie", pp); | ||
1947 | + IRQF_SHARED | IRQF_NO_THREAD, | ||
1948 | + "spear1340-pcie", pp); | ||
1949 | if (ret) { | ||
1950 | dev_err(dev, "failed to request irq %d\n", pp->irq); | ||
1951 | return ret; | ||
1952 | diff --git a/drivers/pci/host/pcie-xilinx.c b/drivers/pci/host/pcie-xilinx.c | ||
1953 | index 3c7a0d580b1e..4cfa46360d12 100644 | ||
1954 | --- a/drivers/pci/host/pcie-xilinx.c | ||
1955 | +++ b/drivers/pci/host/pcie-xilinx.c | ||
1956 | @@ -781,7 +781,8 @@ static int xilinx_pcie_parse_dt(struct xilinx_pcie_port *port) | ||
1957 | |||
1958 | port->irq = irq_of_parse_and_map(node, 0); | ||
1959 | err = devm_request_irq(dev, port->irq, xilinx_pcie_intr_handler, | ||
1960 | - IRQF_SHARED, "xilinx-pcie", port); | ||
1961 | + IRQF_SHARED | IRQF_NO_THREAD, | ||
1962 | + "xilinx-pcie", port); | ||
1963 | if (err) { | ||
1964 | dev_err(dev, "unable to request irq %d\n", port->irq); | ||
1965 | return err; | ||
1966 | diff --git a/drivers/tty/n_tty.c b/drivers/tty/n_tty.c | ||
1967 | index e49c2bce551d..cf000b331eed 100644 | ||
1968 | --- a/drivers/tty/n_tty.c | ||
1969 | +++ b/drivers/tty/n_tty.c | ||
1970 | @@ -258,16 +258,13 @@ static void n_tty_check_throttle(struct tty_struct *tty) | ||
1971 | |||
1972 | static void n_tty_check_unthrottle(struct tty_struct *tty) | ||
1973 | { | ||
1974 | - if (tty->driver->type == TTY_DRIVER_TYPE_PTY && | ||
1975 | - tty->link->ldisc->ops->write_wakeup == n_tty_write_wakeup) { | ||
1976 | + if (tty->driver->type == TTY_DRIVER_TYPE_PTY) { | ||
1977 | if (chars_in_buffer(tty) > TTY_THRESHOLD_UNTHROTTLE) | ||
1978 | return; | ||
1979 | if (!tty->count) | ||
1980 | return; | ||
1981 | n_tty_kick_worker(tty); | ||
1982 | - n_tty_write_wakeup(tty->link); | ||
1983 | - if (waitqueue_active(&tty->link->write_wait)) | ||
1984 | - wake_up_interruptible_poll(&tty->link->write_wait, POLLOUT); | ||
1985 | + tty_wakeup(tty->link); | ||
1986 | return; | ||
1987 | } | ||
1988 | |||
1989 | diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c | ||
1990 | index bcc8e1e8bb72..7cef54334b12 100644 | ||
1991 | --- a/drivers/tty/tty_io.c | ||
1992 | +++ b/drivers/tty/tty_io.c | ||
1993 | @@ -1462,13 +1462,13 @@ static int tty_reopen(struct tty_struct *tty) | ||
1994 | { | ||
1995 | struct tty_driver *driver = tty->driver; | ||
1996 | |||
1997 | - if (!tty->count) | ||
1998 | - return -EIO; | ||
1999 | - | ||
2000 | if (driver->type == TTY_DRIVER_TYPE_PTY && | ||
2001 | driver->subtype == PTY_TYPE_MASTER) | ||
2002 | return -EIO; | ||
2003 | |||
2004 | + if (!tty->count) | ||
2005 | + return -EAGAIN; | ||
2006 | + | ||
2007 | if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN)) | ||
2008 | return -EBUSY; | ||
2009 | |||
2010 | @@ -2069,7 +2069,12 @@ retry_open: | ||
2011 | |||
2012 | if (tty) { | ||
2013 | mutex_unlock(&tty_mutex); | ||
2014 | - tty_lock(tty); | ||
2015 | + retval = tty_lock_interruptible(tty); | ||
2016 | + if (retval) { | ||
2017 | + if (retval == -EINTR) | ||
2018 | + retval = -ERESTARTSYS; | ||
2019 | + goto err_unref; | ||
2020 | + } | ||
2021 | /* safe to drop the kref from tty_driver_lookup_tty() */ | ||
2022 | tty_kref_put(tty); | ||
2023 | retval = tty_reopen(tty); | ||
2024 | @@ -2087,7 +2092,11 @@ retry_open: | ||
2025 | |||
2026 | if (IS_ERR(tty)) { | ||
2027 | retval = PTR_ERR(tty); | ||
2028 | - goto err_file; | ||
2029 | + if (retval != -EAGAIN || signal_pending(current)) | ||
2030 | + goto err_file; | ||
2031 | + tty_free_file(filp); | ||
2032 | + schedule(); | ||
2033 | + goto retry_open; | ||
2034 | } | ||
2035 | |||
2036 | tty_add_file(tty, filp); | ||
2037 | @@ -2156,6 +2165,7 @@ retry_open: | ||
2038 | return 0; | ||
2039 | err_unlock: | ||
2040 | mutex_unlock(&tty_mutex); | ||
2041 | +err_unref: | ||
2042 | /* after locks to avoid deadlock */ | ||
2043 | if (!IS_ERR_OR_NULL(driver)) | ||
2044 | tty_driver_kref_put(driver); | ||
2045 | @@ -2653,6 +2663,28 @@ static int tiocsetd(struct tty_struct *tty, int __user *p) | ||
2046 | } | ||
2047 | |||
2048 | /** | ||
2049 | + * tiocgetd - get line discipline | ||
2050 | + * @tty: tty device | ||
2051 | + * @p: pointer to user data | ||
2052 | + * | ||
2053 | + * Retrieves the line discipline id directly from the ldisc. | ||
2054 | + * | ||
2055 | + * Locking: waits for ldisc reference (in case the line discipline | ||
2056 | + * is changing or the tty is being hungup) | ||
2057 | + */ | ||
2058 | + | ||
2059 | +static int tiocgetd(struct tty_struct *tty, int __user *p) | ||
2060 | +{ | ||
2061 | + struct tty_ldisc *ld; | ||
2062 | + int ret; | ||
2063 | + | ||
2064 | + ld = tty_ldisc_ref_wait(tty); | ||
2065 | + ret = put_user(ld->ops->num, p); | ||
2066 | + tty_ldisc_deref(ld); | ||
2067 | + return ret; | ||
2068 | +} | ||
2069 | + | ||
2070 | +/** | ||
2071 | * send_break - performed time break | ||
2072 | * @tty: device to break on | ||
2073 | * @duration: timeout in mS | ||
2074 | @@ -2878,7 +2910,7 @@ long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | ||
2075 | case TIOCGSID: | ||
2076 | return tiocgsid(tty, real_tty, p); | ||
2077 | case TIOCGETD: | ||
2078 | - return put_user(tty->ldisc->ops->num, (int __user *)p); | ||
2079 | + return tiocgetd(tty, p); | ||
2080 | case TIOCSETD: | ||
2081 | return tiocsetd(tty, p); | ||
2082 | case TIOCVHANGUP: | ||
2083 | diff --git a/drivers/tty/tty_mutex.c b/drivers/tty/tty_mutex.c | ||
2084 | index 0efcf713b756..d09293bc0e04 100644 | ||
2085 | --- a/drivers/tty/tty_mutex.c | ||
2086 | +++ b/drivers/tty/tty_mutex.c | ||
2087 | @@ -22,6 +22,14 @@ void __lockfunc tty_lock(struct tty_struct *tty) | ||
2088 | } | ||
2089 | EXPORT_SYMBOL(tty_lock); | ||
2090 | |||
2091 | +int tty_lock_interruptible(struct tty_struct *tty) | ||
2092 | +{ | ||
2093 | + if (WARN(tty->magic != TTY_MAGIC, "L Bad %p\n", tty)) | ||
2094 | + return -EIO; | ||
2095 | + tty_kref_get(tty); | ||
2096 | + return mutex_lock_interruptible(&tty->legacy_mutex); | ||
2097 | +} | ||
2098 | + | ||
2099 | void __lockfunc tty_unlock(struct tty_struct *tty) | ||
2100 | { | ||
2101 | if (tty->magic != TTY_MAGIC) { | ||
2102 | diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c | ||
2103 | index 26ca4f910cb0..e4c70dce3e7c 100644 | ||
2104 | --- a/drivers/usb/class/cdc-acm.c | ||
2105 | +++ b/drivers/usb/class/cdc-acm.c | ||
2106 | @@ -428,7 +428,8 @@ static void acm_read_bulk_callback(struct urb *urb) | ||
2107 | set_bit(rb->index, &acm->read_urbs_free); | ||
2108 | dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n", | ||
2109 | __func__, status); | ||
2110 | - return; | ||
2111 | + if ((status != -ENOENT) || (urb->actual_length == 0)) | ||
2112 | + return; | ||
2113 | } | ||
2114 | |||
2115 | usb_mark_last_busy(acm->dev); | ||
2116 | @@ -1404,6 +1405,8 @@ made_compressed_probe: | ||
2117 | usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress), | ||
2118 | NULL, acm->writesize, acm_write_bulk, snd); | ||
2119 | snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; | ||
2120 | + if (quirks & SEND_ZERO_PACKET) | ||
2121 | + snd->urb->transfer_flags |= URB_ZERO_PACKET; | ||
2122 | snd->instance = acm; | ||
2123 | } | ||
2124 | |||
2125 | @@ -1861,6 +1864,10 @@ static const struct usb_device_id acm_ids[] = { | ||
2126 | { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, | ||
2127 | USB_CDC_ACM_PROTO_AT_CDMA) }, | ||
2128 | |||
2129 | + { USB_DEVICE(0x1519, 0x0452), /* Intel 7260 modem */ | ||
2130 | + .driver_info = SEND_ZERO_PACKET, | ||
2131 | + }, | ||
2132 | + | ||
2133 | { } | ||
2134 | }; | ||
2135 | |||
2136 | diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h | ||
2137 | index dd9af38e7cda..ccfaba9ab4e4 100644 | ||
2138 | --- a/drivers/usb/class/cdc-acm.h | ||
2139 | +++ b/drivers/usb/class/cdc-acm.h | ||
2140 | @@ -134,3 +134,4 @@ struct acm { | ||
2141 | #define IGNORE_DEVICE BIT(5) | ||
2142 | #define QUIRK_CONTROL_LINE_STATE BIT(6) | ||
2143 | #define CLEAR_HALT_CONDITIONS BIT(7) | ||
2144 | +#define SEND_ZERO_PACKET BIT(8) | ||
2145 | diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c | ||
2146 | index 8683436788c3..1560f3f3e756 100644 | ||
2147 | --- a/drivers/usb/core/hub.c | ||
2148 | +++ b/drivers/usb/core/hub.c | ||
2149 | @@ -5386,7 +5386,6 @@ static int usb_reset_and_verify_device(struct usb_device *udev) | ||
2150 | } | ||
2151 | |||
2152 | bos = udev->bos; | ||
2153 | - udev->bos = NULL; | ||
2154 | |||
2155 | for (i = 0; i < SET_CONFIG_TRIES; ++i) { | ||
2156 | |||
2157 | @@ -5479,8 +5478,11 @@ done: | ||
2158 | usb_set_usb2_hardware_lpm(udev, 1); | ||
2159 | usb_unlocked_enable_lpm(udev); | ||
2160 | usb_enable_ltm(udev); | ||
2161 | - usb_release_bos_descriptor(udev); | ||
2162 | - udev->bos = bos; | ||
2163 | + /* release the new BOS descriptor allocated by hub_port_init() */ | ||
2164 | + if (udev->bos != bos) { | ||
2165 | + usb_release_bos_descriptor(udev); | ||
2166 | + udev->bos = bos; | ||
2167 | + } | ||
2168 | return 0; | ||
2169 | |||
2170 | re_enumerate: | ||
2171 | diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c | ||
2172 | index c62109091d12..c2d65206ec6c 100644 | ||
2173 | --- a/drivers/usb/host/xhci-pci.c | ||
2174 | +++ b/drivers/usb/host/xhci-pci.c | ||
2175 | @@ -28,7 +28,9 @@ | ||
2176 | #include "xhci.h" | ||
2177 | #include "xhci-trace.h" | ||
2178 | |||
2179 | -#define PORT2_SSIC_CONFIG_REG2 0x883c | ||
2180 | +#define SSIC_PORT_NUM 2 | ||
2181 | +#define SSIC_PORT_CFG2 0x880c | ||
2182 | +#define SSIC_PORT_CFG2_OFFSET 0x30 | ||
2183 | #define PROG_DONE (1 << 30) | ||
2184 | #define SSIC_PORT_UNUSED (1 << 31) | ||
2185 | |||
2186 | @@ -45,6 +47,7 @@ | ||
2187 | #define PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI 0x22b5 | ||
2188 | #define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_XHCI 0xa12f | ||
2189 | #define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_XHCI 0x9d2f | ||
2190 | +#define PCI_DEVICE_ID_INTEL_BROXTON_M_XHCI 0x0aa8 | ||
2191 | |||
2192 | static const char hcd_name[] = "xhci_hcd"; | ||
2193 | |||
2194 | @@ -152,7 +155,8 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci) | ||
2195 | if (pdev->vendor == PCI_VENDOR_ID_INTEL && | ||
2196 | (pdev->device == PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_XHCI || | ||
2197 | pdev->device == PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_XHCI || | ||
2198 | - pdev->device == PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI)) { | ||
2199 | + pdev->device == PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI || | ||
2200 | + pdev->device == PCI_DEVICE_ID_INTEL_BROXTON_M_XHCI)) { | ||
2201 | xhci->quirks |= XHCI_PME_STUCK_QUIRK; | ||
2202 | } | ||
2203 | if (pdev->vendor == PCI_VENDOR_ID_ETRON && | ||
2204 | @@ -322,28 +326,36 @@ static void xhci_pme_quirk(struct usb_hcd *hcd, bool suspend) | ||
2205 | struct pci_dev *pdev = to_pci_dev(hcd->self.controller); | ||
2206 | u32 val; | ||
2207 | void __iomem *reg; | ||
2208 | + int i; | ||
2209 | |||
2210 | if (pdev->vendor == PCI_VENDOR_ID_INTEL && | ||
2211 | pdev->device == PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI) { | ||
2212 | |||
2213 | - reg = (void __iomem *) xhci->cap_regs + PORT2_SSIC_CONFIG_REG2; | ||
2214 | - | ||
2215 | - /* Notify SSIC that SSIC profile programming is not done */ | ||
2216 | - val = readl(reg) & ~PROG_DONE; | ||
2217 | - writel(val, reg); | ||
2218 | - | ||
2219 | - /* Mark SSIC port as unused(suspend) or used(resume) */ | ||
2220 | - val = readl(reg); | ||
2221 | - if (suspend) | ||
2222 | - val |= SSIC_PORT_UNUSED; | ||
2223 | - else | ||
2224 | - val &= ~SSIC_PORT_UNUSED; | ||
2225 | - writel(val, reg); | ||
2226 | - | ||
2227 | - /* Notify SSIC that SSIC profile programming is done */ | ||
2228 | - val = readl(reg) | PROG_DONE; | ||
2229 | - writel(val, reg); | ||
2230 | - readl(reg); | ||
2231 | + for (i = 0; i < SSIC_PORT_NUM; i++) { | ||
2232 | + reg = (void __iomem *) xhci->cap_regs + | ||
2233 | + SSIC_PORT_CFG2 + | ||
2234 | + i * SSIC_PORT_CFG2_OFFSET; | ||
2235 | + | ||
2236 | + /* | ||
2237 | + * Notify SSIC that SSIC profile programming | ||
2238 | + * is not done. | ||
2239 | + */ | ||
2240 | + val = readl(reg) & ~PROG_DONE; | ||
2241 | + writel(val, reg); | ||
2242 | + | ||
2243 | + /* Mark SSIC port as unused(suspend) or used(resume) */ | ||
2244 | + val = readl(reg); | ||
2245 | + if (suspend) | ||
2246 | + val |= SSIC_PORT_UNUSED; | ||
2247 | + else | ||
2248 | + val &= ~SSIC_PORT_UNUSED; | ||
2249 | + writel(val, reg); | ||
2250 | + | ||
2251 | + /* Notify SSIC that SSIC profile programming is done */ | ||
2252 | + val = readl(reg) | PROG_DONE; | ||
2253 | + writel(val, reg); | ||
2254 | + readl(reg); | ||
2255 | + } | ||
2256 | } | ||
2257 | |||
2258 | reg = (void __iomem *) xhci->cap_regs + 0x80a4; | ||
2259 | diff --git a/drivers/usb/phy/phy-msm-usb.c b/drivers/usb/phy/phy-msm-usb.c | ||
2260 | index 0d19a6d61a71..970a30e155cb 100644 | ||
2261 | --- a/drivers/usb/phy/phy-msm-usb.c | ||
2262 | +++ b/drivers/usb/phy/phy-msm-usb.c | ||
2263 | @@ -1599,6 +1599,8 @@ static int msm_otg_read_dt(struct platform_device *pdev, struct msm_otg *motg) | ||
2264 | &motg->id.nb); | ||
2265 | if (ret < 0) { | ||
2266 | dev_err(&pdev->dev, "register ID notifier failed\n"); | ||
2267 | + extcon_unregister_notifier(motg->vbus.extcon, | ||
2268 | + EXTCON_USB, &motg->vbus.nb); | ||
2269 | return ret; | ||
2270 | } | ||
2271 | |||
2272 | @@ -1660,15 +1662,6 @@ static int msm_otg_probe(struct platform_device *pdev) | ||
2273 | if (!motg) | ||
2274 | return -ENOMEM; | ||
2275 | |||
2276 | - pdata = dev_get_platdata(&pdev->dev); | ||
2277 | - if (!pdata) { | ||
2278 | - if (!np) | ||
2279 | - return -ENXIO; | ||
2280 | - ret = msm_otg_read_dt(pdev, motg); | ||
2281 | - if (ret) | ||
2282 | - return ret; | ||
2283 | - } | ||
2284 | - | ||
2285 | motg->phy.otg = devm_kzalloc(&pdev->dev, sizeof(struct usb_otg), | ||
2286 | GFP_KERNEL); | ||
2287 | if (!motg->phy.otg) | ||
2288 | @@ -1710,6 +1703,15 @@ static int msm_otg_probe(struct platform_device *pdev) | ||
2289 | if (!motg->regs) | ||
2290 | return -ENOMEM; | ||
2291 | |||
2292 | + pdata = dev_get_platdata(&pdev->dev); | ||
2293 | + if (!pdata) { | ||
2294 | + if (!np) | ||
2295 | + return -ENXIO; | ||
2296 | + ret = msm_otg_read_dt(pdev, motg); | ||
2297 | + if (ret) | ||
2298 | + return ret; | ||
2299 | + } | ||
2300 | + | ||
2301 | /* | ||
2302 | * NOTE: The PHYs can be multiplexed between the chipidea controller | ||
2303 | * and the dwc3 controller, using a single bit. It is important that | ||
2304 | @@ -1717,8 +1719,10 @@ static int msm_otg_probe(struct platform_device *pdev) | ||
2305 | */ | ||
2306 | if (motg->phy_number) { | ||
2307 | phy_select = devm_ioremap_nocache(&pdev->dev, USB2_PHY_SEL, 4); | ||
2308 | - if (!phy_select) | ||
2309 | - return -ENOMEM; | ||
2310 | + if (!phy_select) { | ||
2311 | + ret = -ENOMEM; | ||
2312 | + goto unregister_extcon; | ||
2313 | + } | ||
2314 | /* Enable second PHY with the OTG port */ | ||
2315 | writel(0x1, phy_select); | ||
2316 | } | ||
2317 | @@ -1728,7 +1732,8 @@ static int msm_otg_probe(struct platform_device *pdev) | ||
2318 | motg->irq = platform_get_irq(pdev, 0); | ||
2319 | if (motg->irq < 0) { | ||
2320 | dev_err(&pdev->dev, "platform_get_irq failed\n"); | ||
2321 | - return motg->irq; | ||
2322 | + ret = motg->irq; | ||
2323 | + goto unregister_extcon; | ||
2324 | } | ||
2325 | |||
2326 | regs[0].supply = "vddcx"; | ||
2327 | @@ -1737,7 +1742,7 @@ static int msm_otg_probe(struct platform_device *pdev) | ||
2328 | |||
2329 | ret = devm_regulator_bulk_get(motg->phy.dev, ARRAY_SIZE(regs), regs); | ||
2330 | if (ret) | ||
2331 | - return ret; | ||
2332 | + goto unregister_extcon; | ||
2333 | |||
2334 | motg->vddcx = regs[0].consumer; | ||
2335 | motg->v3p3 = regs[1].consumer; | ||
2336 | @@ -1834,6 +1839,12 @@ disable_clks: | ||
2337 | clk_disable_unprepare(motg->clk); | ||
2338 | if (!IS_ERR(motg->core_clk)) | ||
2339 | clk_disable_unprepare(motg->core_clk); | ||
2340 | +unregister_extcon: | ||
2341 | + extcon_unregister_notifier(motg->id.extcon, | ||
2342 | + EXTCON_USB_HOST, &motg->id.nb); | ||
2343 | + extcon_unregister_notifier(motg->vbus.extcon, | ||
2344 | + EXTCON_USB, &motg->vbus.nb); | ||
2345 | + | ||
2346 | return ret; | ||
2347 | } | ||
2348 | |||
2349 | diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c | ||
2350 | index 59b2126b21a3..1dd9919081f8 100644 | ||
2351 | --- a/drivers/usb/serial/cp210x.c | ||
2352 | +++ b/drivers/usb/serial/cp210x.c | ||
2353 | @@ -98,6 +98,7 @@ static const struct usb_device_id id_table[] = { | ||
2354 | { USB_DEVICE(0x10C4, 0x81AC) }, /* MSD Dash Hawk */ | ||
2355 | { USB_DEVICE(0x10C4, 0x81AD) }, /* INSYS USB Modem */ | ||
2356 | { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */ | ||
2357 | + { USB_DEVICE(0x10C4, 0x81D7) }, /* IAI Corp. RCB-CV-USB USB to RS485 Adaptor */ | ||
2358 | { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */ | ||
2359 | { USB_DEVICE(0x10C4, 0x81E7) }, /* Aerocomm Radio */ | ||
2360 | { USB_DEVICE(0x10C4, 0x81E8) }, /* Zephyr Bioharness */ | ||
2361 | diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c | ||
2362 | index a5a0376bbd48..8c660ae401d8 100644 | ||
2363 | --- a/drivers/usb/serial/ftdi_sio.c | ||
2364 | +++ b/drivers/usb/serial/ftdi_sio.c | ||
2365 | @@ -824,6 +824,7 @@ static const struct usb_device_id id_table_combined[] = { | ||
2366 | { USB_DEVICE(FTDI_VID, FTDI_TURTELIZER_PID), | ||
2367 | .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk }, | ||
2368 | { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) }, | ||
2369 | + { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_SCU18) }, | ||
2370 | { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) }, | ||
2371 | |||
2372 | /* Papouch devices based on FTDI chip */ | ||
2373 | diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h | ||
2374 | index 67c6d4469730..a84df2513994 100644 | ||
2375 | --- a/drivers/usb/serial/ftdi_sio_ids.h | ||
2376 | +++ b/drivers/usb/serial/ftdi_sio_ids.h | ||
2377 | @@ -615,6 +615,7 @@ | ||
2378 | */ | ||
2379 | #define RATOC_VENDOR_ID 0x0584 | ||
2380 | #define RATOC_PRODUCT_ID_USB60F 0xb020 | ||
2381 | +#define RATOC_PRODUCT_ID_SCU18 0xb03a | ||
2382 | |||
2383 | /* | ||
2384 | * Infineon Technologies | ||
2385 | diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c | ||
2386 | index f2280606b73c..db86e512e0fc 100644 | ||
2387 | --- a/drivers/usb/serial/option.c | ||
2388 | +++ b/drivers/usb/serial/option.c | ||
2389 | @@ -268,6 +268,8 @@ static void option_instat_callback(struct urb *urb); | ||
2390 | #define TELIT_PRODUCT_CC864_SINGLE 0x1006 | ||
2391 | #define TELIT_PRODUCT_DE910_DUAL 0x1010 | ||
2392 | #define TELIT_PRODUCT_UE910_V2 0x1012 | ||
2393 | +#define TELIT_PRODUCT_LE922_USBCFG0 0x1042 | ||
2394 | +#define TELIT_PRODUCT_LE922_USBCFG3 0x1043 | ||
2395 | #define TELIT_PRODUCT_LE920 0x1200 | ||
2396 | #define TELIT_PRODUCT_LE910 0x1201 | ||
2397 | |||
2398 | @@ -615,6 +617,16 @@ static const struct option_blacklist_info telit_le920_blacklist = { | ||
2399 | .reserved = BIT(1) | BIT(5), | ||
2400 | }; | ||
2401 | |||
2402 | +static const struct option_blacklist_info telit_le922_blacklist_usbcfg0 = { | ||
2403 | + .sendsetup = BIT(2), | ||
2404 | + .reserved = BIT(0) | BIT(1) | BIT(3), | ||
2405 | +}; | ||
2406 | + | ||
2407 | +static const struct option_blacklist_info telit_le922_blacklist_usbcfg3 = { | ||
2408 | + .sendsetup = BIT(0), | ||
2409 | + .reserved = BIT(1) | BIT(2) | BIT(3), | ||
2410 | +}; | ||
2411 | + | ||
2412 | static const struct usb_device_id option_ids[] = { | ||
2413 | { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) }, | ||
2414 | { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) }, | ||
2415 | @@ -1160,6 +1172,10 @@ static const struct usb_device_id option_ids[] = { | ||
2416 | { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_CC864_SINGLE) }, | ||
2417 | { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_DE910_DUAL) }, | ||
2418 | { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UE910_V2) }, | ||
2419 | + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE922_USBCFG0), | ||
2420 | + .driver_info = (kernel_ulong_t)&telit_le922_blacklist_usbcfg0 }, | ||
2421 | + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE922_USBCFG3), | ||
2422 | + .driver_info = (kernel_ulong_t)&telit_le922_blacklist_usbcfg3 }, | ||
2423 | { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910), | ||
2424 | .driver_info = (kernel_ulong_t)&telit_le910_blacklist }, | ||
2425 | { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE920), | ||
2426 | @@ -1679,7 +1695,7 @@ static const struct usb_device_id option_ids[] = { | ||
2427 | { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_EU3_P) }, | ||
2428 | { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_PH8), | ||
2429 | .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, | ||
2430 | - { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX) }, | ||
2431 | + { USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX, 0xff) }, | ||
2432 | { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_PLXX), | ||
2433 | .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, | ||
2434 | { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) }, | ||
2435 | diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c | ||
2436 | index 60afb39eb73c..337a0be89fcf 100644 | ||
2437 | --- a/drivers/usb/serial/visor.c | ||
2438 | +++ b/drivers/usb/serial/visor.c | ||
2439 | @@ -544,6 +544,11 @@ static int treo_attach(struct usb_serial *serial) | ||
2440 | (serial->num_interrupt_in == 0)) | ||
2441 | return 0; | ||
2442 | |||
2443 | + if (serial->num_bulk_in < 2 || serial->num_interrupt_in < 2) { | ||
2444 | + dev_err(&serial->interface->dev, "missing endpoints\n"); | ||
2445 | + return -ENODEV; | ||
2446 | + } | ||
2447 | + | ||
2448 | /* | ||
2449 | * It appears that Treos and Kyoceras want to use the | ||
2450 | * 1st bulk in endpoint to communicate with the 2nd bulk out endpoint, | ||
2451 | @@ -597,8 +602,10 @@ static int clie_5_attach(struct usb_serial *serial) | ||
2452 | */ | ||
2453 | |||
2454 | /* some sanity check */ | ||
2455 | - if (serial->num_ports < 2) | ||
2456 | - return -1; | ||
2457 | + if (serial->num_bulk_out < 2) { | ||
2458 | + dev_err(&serial->interface->dev, "missing bulk out endpoints\n"); | ||
2459 | + return -ENODEV; | ||
2460 | + } | ||
2461 | |||
2462 | /* port 0 now uses the modified endpoint Address */ | ||
2463 | port = serial->port[0]; | ||
2464 | diff --git a/fs/ext4/crypto_key.c b/fs/ext4/crypto_key.c | ||
2465 | index c5882b36e558..9a16d1e75a49 100644 | ||
2466 | --- a/fs/ext4/crypto_key.c | ||
2467 | +++ b/fs/ext4/crypto_key.c | ||
2468 | @@ -213,9 +213,11 @@ retry: | ||
2469 | res = -ENOKEY; | ||
2470 | goto out; | ||
2471 | } | ||
2472 | + down_read(&keyring_key->sem); | ||
2473 | ukp = user_key_payload(keyring_key); | ||
2474 | if (ukp->datalen != sizeof(struct ext4_encryption_key)) { | ||
2475 | res = -EINVAL; | ||
2476 | + up_read(&keyring_key->sem); | ||
2477 | goto out; | ||
2478 | } | ||
2479 | master_key = (struct ext4_encryption_key *)ukp->data; | ||
2480 | @@ -226,10 +228,12 @@ retry: | ||
2481 | "ext4: key size incorrect: %d\n", | ||
2482 | master_key->size); | ||
2483 | res = -ENOKEY; | ||
2484 | + up_read(&keyring_key->sem); | ||
2485 | goto out; | ||
2486 | } | ||
2487 | res = ext4_derive_key_aes(ctx.nonce, master_key->raw, | ||
2488 | raw_key); | ||
2489 | + up_read(&keyring_key->sem); | ||
2490 | if (res) | ||
2491 | goto out; | ||
2492 | got_key: | ||
2493 | diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c | ||
2494 | index 89818036f035..343b0f1f15b1 100644 | ||
2495 | --- a/fs/nfs/nfs4proc.c | ||
2496 | +++ b/fs/nfs/nfs4proc.c | ||
2497 | @@ -8054,7 +8054,6 @@ static void nfs4_layoutreturn_release(void *calldata) | ||
2498 | pnfs_set_layout_stateid(lo, &lrp->res.stateid, true); | ||
2499 | pnfs_mark_matching_lsegs_invalid(lo, &freeme, &lrp->args.range); | ||
2500 | pnfs_clear_layoutreturn_waitbit(lo); | ||
2501 | - lo->plh_block_lgets--; | ||
2502 | spin_unlock(&lo->plh_inode->i_lock); | ||
2503 | pnfs_free_lseg_list(&freeme); | ||
2504 | pnfs_put_layout_hdr(lrp->args.layout); | ||
2505 | diff --git a/fs/ocfs2/dlm/dlmmaster.c b/fs/ocfs2/dlm/dlmmaster.c | ||
2506 | index 84f2f8079466..4e2162b355db 100644 | ||
2507 | --- a/fs/ocfs2/dlm/dlmmaster.c | ||
2508 | +++ b/fs/ocfs2/dlm/dlmmaster.c | ||
2509 | @@ -2519,6 +2519,11 @@ static int dlm_migrate_lockres(struct dlm_ctxt *dlm, | ||
2510 | spin_lock(&dlm->master_lock); | ||
2511 | ret = dlm_add_migration_mle(dlm, res, mle, &oldmle, name, | ||
2512 | namelen, target, dlm->node_num); | ||
2513 | + /* get an extra reference on the mle. | ||
2514 | + * otherwise the assert_master from the new | ||
2515 | + * master will destroy this. | ||
2516 | + */ | ||
2517 | + dlm_get_mle_inuse(mle); | ||
2518 | spin_unlock(&dlm->master_lock); | ||
2519 | spin_unlock(&dlm->spinlock); | ||
2520 | |||
2521 | @@ -2554,6 +2559,7 @@ fail: | ||
2522 | if (mle_added) { | ||
2523 | dlm_mle_detach_hb_events(dlm, mle); | ||
2524 | dlm_put_mle(mle); | ||
2525 | + dlm_put_mle_inuse(mle); | ||
2526 | } else if (mle) { | ||
2527 | kmem_cache_free(dlm_mle_cache, mle); | ||
2528 | mle = NULL; | ||
2529 | @@ -2571,17 +2577,6 @@ fail: | ||
2530 | * ensure that all assert_master work is flushed. */ | ||
2531 | flush_workqueue(dlm->dlm_worker); | ||
2532 | |||
2533 | - /* get an extra reference on the mle. | ||
2534 | - * otherwise the assert_master from the new | ||
2535 | - * master will destroy this. | ||
2536 | - * also, make sure that all callers of dlm_get_mle | ||
2537 | - * take both dlm->spinlock and dlm->master_lock */ | ||
2538 | - spin_lock(&dlm->spinlock); | ||
2539 | - spin_lock(&dlm->master_lock); | ||
2540 | - dlm_get_mle_inuse(mle); | ||
2541 | - spin_unlock(&dlm->master_lock); | ||
2542 | - spin_unlock(&dlm->spinlock); | ||
2543 | - | ||
2544 | /* notify new node and send all lock state */ | ||
2545 | /* call send_one_lockres with migration flag. | ||
2546 | * this serves as notice to the target node that a | ||
2547 | @@ -3312,6 +3307,15 @@ top: | ||
2548 | mle->new_master != dead_node) | ||
2549 | continue; | ||
2550 | |||
2551 | + if (mle->new_master == dead_node && mle->inuse) { | ||
2552 | + mlog(ML_NOTICE, "%s: target %u died during " | ||
2553 | + "migration from %u, the MLE is " | ||
2554 | + "still keep used, ignore it!\n", | ||
2555 | + dlm->name, dead_node, | ||
2556 | + mle->master); | ||
2557 | + continue; | ||
2558 | + } | ||
2559 | + | ||
2560 | /* If we have reached this point, this mle needs to be | ||
2561 | * removed from the list and freed. */ | ||
2562 | dlm_clean_migration_mle(dlm, mle); | ||
2563 | diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c | ||
2564 | index 9e4f862d20fe..42f0cae93a0a 100644 | ||
2565 | --- a/fs/ocfs2/dlm/dlmrecovery.c | ||
2566 | +++ b/fs/ocfs2/dlm/dlmrecovery.c | ||
2567 | @@ -2360,6 +2360,8 @@ static void dlm_do_local_recovery_cleanup(struct dlm_ctxt *dlm, u8 dead_node) | ||
2568 | break; | ||
2569 | } | ||
2570 | } | ||
2571 | + dlm_lockres_clear_refmap_bit(dlm, res, | ||
2572 | + dead_node); | ||
2573 | spin_unlock(&res->spinlock); | ||
2574 | continue; | ||
2575 | } | ||
2576 | diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c | ||
2577 | index 20276e340339..b002acf50203 100644 | ||
2578 | --- a/fs/ocfs2/dlmglue.c | ||
2579 | +++ b/fs/ocfs2/dlmglue.c | ||
2580 | @@ -1390,6 +1390,7 @@ static int __ocfs2_cluster_lock(struct ocfs2_super *osb, | ||
2581 | unsigned int gen; | ||
2582 | int noqueue_attempted = 0; | ||
2583 | int dlm_locked = 0; | ||
2584 | + int kick_dc = 0; | ||
2585 | |||
2586 | if (!(lockres->l_flags & OCFS2_LOCK_INITIALIZED)) { | ||
2587 | mlog_errno(-EINVAL); | ||
2588 | @@ -1524,7 +1525,12 @@ update_holders: | ||
2589 | unlock: | ||
2590 | lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING); | ||
2591 | |||
2592 | + /* ocfs2_unblock_lock reques on seeing OCFS2_LOCK_UPCONVERT_FINISHING */ | ||
2593 | + kick_dc = (lockres->l_flags & OCFS2_LOCK_BLOCKED); | ||
2594 | + | ||
2595 | spin_unlock_irqrestore(&lockres->l_lock, flags); | ||
2596 | + if (kick_dc) | ||
2597 | + ocfs2_wake_downconvert_thread(osb); | ||
2598 | out: | ||
2599 | /* | ||
2600 | * This is helping work around a lock inversion between the page lock | ||
2601 | diff --git a/include/crypto/hash.h b/include/crypto/hash.h | ||
2602 | index 3d69c93d50e8..6361892ea737 100644 | ||
2603 | --- a/include/crypto/hash.h | ||
2604 | +++ b/include/crypto/hash.h | ||
2605 | @@ -204,6 +204,7 @@ struct crypto_ahash { | ||
2606 | unsigned int keylen); | ||
2607 | |||
2608 | unsigned int reqsize; | ||
2609 | + bool has_setkey; | ||
2610 | struct crypto_tfm base; | ||
2611 | }; | ||
2612 | |||
2613 | @@ -375,6 +376,11 @@ static inline void *ahash_request_ctx(struct ahash_request *req) | ||
2614 | int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key, | ||
2615 | unsigned int keylen); | ||
2616 | |||
2617 | +static inline bool crypto_ahash_has_setkey(struct crypto_ahash *tfm) | ||
2618 | +{ | ||
2619 | + return tfm->has_setkey; | ||
2620 | +} | ||
2621 | + | ||
2622 | /** | ||
2623 | * crypto_ahash_finup() - update and finalize message digest | ||
2624 | * @req: reference to the ahash_request handle that holds all information | ||
2625 | diff --git a/include/crypto/if_alg.h b/include/crypto/if_alg.h | ||
2626 | index 018afb264ac2..a2bfd7843f18 100644 | ||
2627 | --- a/include/crypto/if_alg.h | ||
2628 | +++ b/include/crypto/if_alg.h | ||
2629 | @@ -30,6 +30,9 @@ struct alg_sock { | ||
2630 | |||
2631 | struct sock *parent; | ||
2632 | |||
2633 | + unsigned int refcnt; | ||
2634 | + unsigned int nokey_refcnt; | ||
2635 | + | ||
2636 | const struct af_alg_type *type; | ||
2637 | void *private; | ||
2638 | }; | ||
2639 | @@ -50,9 +53,11 @@ struct af_alg_type { | ||
2640 | void (*release)(void *private); | ||
2641 | int (*setkey)(void *private, const u8 *key, unsigned int keylen); | ||
2642 | int (*accept)(void *private, struct sock *sk); | ||
2643 | + int (*accept_nokey)(void *private, struct sock *sk); | ||
2644 | int (*setauthsize)(void *private, unsigned int authsize); | ||
2645 | |||
2646 | struct proto_ops *ops; | ||
2647 | + struct proto_ops *ops_nokey; | ||
2648 | struct module *owner; | ||
2649 | char name[14]; | ||
2650 | }; | ||
2651 | @@ -67,6 +72,7 @@ int af_alg_register_type(const struct af_alg_type *type); | ||
2652 | int af_alg_unregister_type(const struct af_alg_type *type); | ||
2653 | |||
2654 | int af_alg_release(struct socket *sock); | ||
2655 | +void af_alg_release_parent(struct sock *sk); | ||
2656 | int af_alg_accept(struct sock *sk, struct socket *newsock); | ||
2657 | |||
2658 | int af_alg_make_sg(struct af_alg_sgl *sgl, struct iov_iter *iter, int len); | ||
2659 | @@ -83,11 +89,6 @@ static inline struct alg_sock *alg_sk(struct sock *sk) | ||
2660 | return (struct alg_sock *)sk; | ||
2661 | } | ||
2662 | |||
2663 | -static inline void af_alg_release_parent(struct sock *sk) | ||
2664 | -{ | ||
2665 | - sock_put(alg_sk(sk)->parent); | ||
2666 | -} | ||
2667 | - | ||
2668 | static inline void af_alg_init_completion(struct af_alg_completion *completion) | ||
2669 | { | ||
2670 | init_completion(&completion->completion); | ||
2671 | diff --git a/include/crypto/skcipher.h b/include/crypto/skcipher.h | ||
2672 | index d8dd41fb034f..fd8742a40ff3 100644 | ||
2673 | --- a/include/crypto/skcipher.h | ||
2674 | +++ b/include/crypto/skcipher.h | ||
2675 | @@ -61,6 +61,8 @@ struct crypto_skcipher { | ||
2676 | unsigned int ivsize; | ||
2677 | unsigned int reqsize; | ||
2678 | |||
2679 | + bool has_setkey; | ||
2680 | + | ||
2681 | struct crypto_tfm base; | ||
2682 | }; | ||
2683 | |||
2684 | @@ -305,6 +307,11 @@ static inline int crypto_skcipher_setkey(struct crypto_skcipher *tfm, | ||
2685 | return tfm->setkey(tfm, key, keylen); | ||
2686 | } | ||
2687 | |||
2688 | +static inline bool crypto_skcipher_has_setkey(struct crypto_skcipher *tfm) | ||
2689 | +{ | ||
2690 | + return tfm->has_setkey; | ||
2691 | +} | ||
2692 | + | ||
2693 | /** | ||
2694 | * crypto_skcipher_reqtfm() - obtain cipher handle from request | ||
2695 | * @req: skcipher_request out of which the cipher handle is to be obtained | ||
2696 | diff --git a/include/linux/console.h b/include/linux/console.h | ||
2697 | index bd194343c346..ea731af2451e 100644 | ||
2698 | --- a/include/linux/console.h | ||
2699 | +++ b/include/linux/console.h | ||
2700 | @@ -150,6 +150,7 @@ extern int console_trylock(void); | ||
2701 | extern void console_unlock(void); | ||
2702 | extern void console_conditional_schedule(void); | ||
2703 | extern void console_unblank(void); | ||
2704 | +extern void console_flush_on_panic(void); | ||
2705 | extern struct tty_driver *console_device(int *); | ||
2706 | extern void console_stop(struct console *); | ||
2707 | extern void console_start(struct console *); | ||
2708 | diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h | ||
2709 | index 76dd4f0da5ca..2ead22dd74a0 100644 | ||
2710 | --- a/include/linux/hrtimer.h | ||
2711 | +++ b/include/linux/hrtimer.h | ||
2712 | @@ -87,7 +87,8 @@ enum hrtimer_restart { | ||
2713 | * @function: timer expiry callback function | ||
2714 | * @base: pointer to the timer base (per cpu and per clock) | ||
2715 | * @state: state information (See bit values above) | ||
2716 | - * @start_pid: timer statistics field to store the pid of the task which | ||
2717 | + * @is_rel: Set if the timer was armed relative | ||
2718 | + * @start_pid: timer statistics field to store the pid of the task which | ||
2719 | * started the timer | ||
2720 | * @start_site: timer statistics field to store the site where the timer | ||
2721 | * was started | ||
2722 | @@ -101,7 +102,8 @@ struct hrtimer { | ||
2723 | ktime_t _softexpires; | ||
2724 | enum hrtimer_restart (*function)(struct hrtimer *); | ||
2725 | struct hrtimer_clock_base *base; | ||
2726 | - unsigned long state; | ||
2727 | + u8 state; | ||
2728 | + u8 is_rel; | ||
2729 | #ifdef CONFIG_TIMER_STATS | ||
2730 | int start_pid; | ||
2731 | void *start_site; | ||
2732 | @@ -321,6 +323,27 @@ static inline void clock_was_set_delayed(void) { } | ||
2733 | |||
2734 | #endif | ||
2735 | |||
2736 | +static inline ktime_t | ||
2737 | +__hrtimer_expires_remaining_adjusted(const struct hrtimer *timer, ktime_t now) | ||
2738 | +{ | ||
2739 | + ktime_t rem = ktime_sub(timer->node.expires, now); | ||
2740 | + | ||
2741 | + /* | ||
2742 | + * Adjust relative timers for the extra we added in | ||
2743 | + * hrtimer_start_range_ns() to prevent short timeouts. | ||
2744 | + */ | ||
2745 | + if (IS_ENABLED(CONFIG_TIME_LOW_RES) && timer->is_rel) | ||
2746 | + rem.tv64 -= hrtimer_resolution; | ||
2747 | + return rem; | ||
2748 | +} | ||
2749 | + | ||
2750 | +static inline ktime_t | ||
2751 | +hrtimer_expires_remaining_adjusted(const struct hrtimer *timer) | ||
2752 | +{ | ||
2753 | + return __hrtimer_expires_remaining_adjusted(timer, | ||
2754 | + timer->base->get_time()); | ||
2755 | +} | ||
2756 | + | ||
2757 | extern void clock_was_set(void); | ||
2758 | #ifdef CONFIG_TIMERFD | ||
2759 | extern void timerfd_clock_was_set(void); | ||
2760 | @@ -390,7 +413,12 @@ static inline void hrtimer_restart(struct hrtimer *timer) | ||
2761 | } | ||
2762 | |||
2763 | /* Query timers: */ | ||
2764 | -extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer); | ||
2765 | +extern ktime_t __hrtimer_get_remaining(const struct hrtimer *timer, bool adjust); | ||
2766 | + | ||
2767 | +static inline ktime_t hrtimer_get_remaining(const struct hrtimer *timer) | ||
2768 | +{ | ||
2769 | + return __hrtimer_get_remaining(timer, false); | ||
2770 | +} | ||
2771 | |||
2772 | extern u64 hrtimer_get_next_event(void); | ||
2773 | |||
2774 | diff --git a/include/linux/tty.h b/include/linux/tty.h | ||
2775 | index 5e31f1b99037..6b6e811f4575 100644 | ||
2776 | --- a/include/linux/tty.h | ||
2777 | +++ b/include/linux/tty.h | ||
2778 | @@ -654,6 +654,7 @@ extern long vt_compat_ioctl(struct tty_struct *tty, | ||
2779 | /* tty_mutex.c */ | ||
2780 | /* functions for preparation of BKL removal */ | ||
2781 | extern void __lockfunc tty_lock(struct tty_struct *tty); | ||
2782 | +extern int tty_lock_interruptible(struct tty_struct *tty); | ||
2783 | extern void __lockfunc tty_unlock(struct tty_struct *tty); | ||
2784 | extern void __lockfunc tty_lock_slave(struct tty_struct *tty); | ||
2785 | extern void __lockfunc tty_unlock_slave(struct tty_struct *tty); | ||
2786 | diff --git a/include/sound/rawmidi.h b/include/sound/rawmidi.h | ||
2787 | index f6cbef78db62..3b91ad5d5115 100644 | ||
2788 | --- a/include/sound/rawmidi.h | ||
2789 | +++ b/include/sound/rawmidi.h | ||
2790 | @@ -167,6 +167,10 @@ int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, | ||
2791 | int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count); | ||
2792 | int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, | ||
2793 | unsigned char *buffer, int count); | ||
2794 | +int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, | ||
2795 | + unsigned char *buffer, int count); | ||
2796 | +int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, | ||
2797 | + int count); | ||
2798 | |||
2799 | /* main midi functions */ | ||
2800 | |||
2801 | diff --git a/kernel/panic.c b/kernel/panic.c | ||
2802 | index 4b150bc0c6c1..41e2b54f36b5 100644 | ||
2803 | --- a/kernel/panic.c | ||
2804 | +++ b/kernel/panic.c | ||
2805 | @@ -157,8 +157,7 @@ void panic(const char *fmt, ...) | ||
2806 | * panic() is not being callled from OOPS. | ||
2807 | */ | ||
2808 | debug_locks_off(); | ||
2809 | - console_trylock(); | ||
2810 | - console_unlock(); | ||
2811 | + console_flush_on_panic(); | ||
2812 | |||
2813 | if (!panic_blink) | ||
2814 | panic_blink = no_blink; | ||
2815 | diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c | ||
2816 | index 2ce8826f1053..c048e34b177f 100644 | ||
2817 | --- a/kernel/printk/printk.c | ||
2818 | +++ b/kernel/printk/printk.c | ||
2819 | @@ -2233,13 +2233,24 @@ void console_unlock(void) | ||
2820 | static u64 seen_seq; | ||
2821 | unsigned long flags; | ||
2822 | bool wake_klogd = false; | ||
2823 | - bool retry; | ||
2824 | + bool do_cond_resched, retry; | ||
2825 | |||
2826 | if (console_suspended) { | ||
2827 | up_console_sem(); | ||
2828 | return; | ||
2829 | } | ||
2830 | |||
2831 | + /* | ||
2832 | + * Console drivers are called under logbuf_lock, so | ||
2833 | + * @console_may_schedule should be cleared before; however, we may | ||
2834 | + * end up dumping a lot of lines, for example, if called from | ||
2835 | + * console registration path, and should invoke cond_resched() | ||
2836 | + * between lines if allowable. Not doing so can cause a very long | ||
2837 | + * scheduling stall on a slow console leading to RCU stall and | ||
2838 | + * softlockup warnings which exacerbate the issue with more | ||
2839 | + * messages practically incapacitating the system. | ||
2840 | + */ | ||
2841 | + do_cond_resched = console_may_schedule; | ||
2842 | console_may_schedule = 0; | ||
2843 | |||
2844 | /* flush buffered message fragment immediately to console */ | ||
2845 | @@ -2311,6 +2322,9 @@ skip: | ||
2846 | call_console_drivers(level, ext_text, ext_len, text, len); | ||
2847 | start_critical_timings(); | ||
2848 | local_irq_restore(flags); | ||
2849 | + | ||
2850 | + if (do_cond_resched) | ||
2851 | + cond_resched(); | ||
2852 | } | ||
2853 | console_locked = 0; | ||
2854 | |||
2855 | @@ -2378,6 +2392,25 @@ void console_unblank(void) | ||
2856 | console_unlock(); | ||
2857 | } | ||
2858 | |||
2859 | +/** | ||
2860 | + * console_flush_on_panic - flush console content on panic | ||
2861 | + * | ||
2862 | + * Immediately output all pending messages no matter what. | ||
2863 | + */ | ||
2864 | +void console_flush_on_panic(void) | ||
2865 | +{ | ||
2866 | + /* | ||
2867 | + * If someone else is holding the console lock, trylock will fail | ||
2868 | + * and may_schedule may be set. Ignore and proceed to unlock so | ||
2869 | + * that messages are flushed out. As this can be called from any | ||
2870 | + * context and we don't want to get preempted while flushing, | ||
2871 | + * ensure may_schedule is cleared. | ||
2872 | + */ | ||
2873 | + console_trylock(); | ||
2874 | + console_may_schedule = 0; | ||
2875 | + console_unlock(); | ||
2876 | +} | ||
2877 | + | ||
2878 | /* | ||
2879 | * Return the console tty driver structure and its associated index | ||
2880 | */ | ||
2881 | diff --git a/kernel/sched/core.c b/kernel/sched/core.c | ||
2882 | index 732e993b564b..eb70592f03f6 100644 | ||
2883 | --- a/kernel/sched/core.c | ||
2884 | +++ b/kernel/sched/core.c | ||
2885 | @@ -6738,7 +6738,7 @@ static void sched_init_numa(void) | ||
2886 | |||
2887 | sched_domains_numa_masks[i][j] = mask; | ||
2888 | |||
2889 | - for (k = 0; k < nr_node_ids; k++) { | ||
2890 | + for_each_node(k) { | ||
2891 | if (node_distance(j, k) > sched_domains_numa_distance[i]) | ||
2892 | continue; | ||
2893 | |||
2894 | diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c | ||
2895 | index 435b8850dd80..fa909f9fd559 100644 | ||
2896 | --- a/kernel/time/hrtimer.c | ||
2897 | +++ b/kernel/time/hrtimer.c | ||
2898 | @@ -897,10 +897,10 @@ static int enqueue_hrtimer(struct hrtimer *timer, | ||
2899 | */ | ||
2900 | static void __remove_hrtimer(struct hrtimer *timer, | ||
2901 | struct hrtimer_clock_base *base, | ||
2902 | - unsigned long newstate, int reprogram) | ||
2903 | + u8 newstate, int reprogram) | ||
2904 | { | ||
2905 | struct hrtimer_cpu_base *cpu_base = base->cpu_base; | ||
2906 | - unsigned int state = timer->state; | ||
2907 | + u8 state = timer->state; | ||
2908 | |||
2909 | timer->state = newstate; | ||
2910 | if (!(state & HRTIMER_STATE_ENQUEUED)) | ||
2911 | @@ -930,7 +930,7 @@ static inline int | ||
2912 | remove_hrtimer(struct hrtimer *timer, struct hrtimer_clock_base *base, bool restart) | ||
2913 | { | ||
2914 | if (hrtimer_is_queued(timer)) { | ||
2915 | - unsigned long state = timer->state; | ||
2916 | + u8 state = timer->state; | ||
2917 | int reprogram; | ||
2918 | |||
2919 | /* | ||
2920 | @@ -954,6 +954,22 @@ remove_hrtimer(struct hrtimer *timer, struct hrtimer_clock_base *base, bool rest | ||
2921 | return 0; | ||
2922 | } | ||
2923 | |||
2924 | +static inline ktime_t hrtimer_update_lowres(struct hrtimer *timer, ktime_t tim, | ||
2925 | + const enum hrtimer_mode mode) | ||
2926 | +{ | ||
2927 | +#ifdef CONFIG_TIME_LOW_RES | ||
2928 | + /* | ||
2929 | + * CONFIG_TIME_LOW_RES indicates that the system has no way to return | ||
2930 | + * granular time values. For relative timers we add hrtimer_resolution | ||
2931 | + * (i.e. one jiffie) to prevent short timeouts. | ||
2932 | + */ | ||
2933 | + timer->is_rel = mode & HRTIMER_MODE_REL; | ||
2934 | + if (timer->is_rel) | ||
2935 | + tim = ktime_add_safe(tim, ktime_set(0, hrtimer_resolution)); | ||
2936 | +#endif | ||
2937 | + return tim; | ||
2938 | +} | ||
2939 | + | ||
2940 | /** | ||
2941 | * hrtimer_start_range_ns - (re)start an hrtimer on the current CPU | ||
2942 | * @timer: the timer to be added | ||
2943 | @@ -974,19 +990,10 @@ void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, | ||
2944 | /* Remove an active timer from the queue: */ | ||
2945 | remove_hrtimer(timer, base, true); | ||
2946 | |||
2947 | - if (mode & HRTIMER_MODE_REL) { | ||
2948 | + if (mode & HRTIMER_MODE_REL) | ||
2949 | tim = ktime_add_safe(tim, base->get_time()); | ||
2950 | - /* | ||
2951 | - * CONFIG_TIME_LOW_RES is a temporary way for architectures | ||
2952 | - * to signal that they simply return xtime in | ||
2953 | - * do_gettimeoffset(). In this case we want to round up by | ||
2954 | - * resolution when starting a relative timer, to avoid short | ||
2955 | - * timeouts. This will go away with the GTOD framework. | ||
2956 | - */ | ||
2957 | -#ifdef CONFIG_TIME_LOW_RES | ||
2958 | - tim = ktime_add_safe(tim, ktime_set(0, hrtimer_resolution)); | ||
2959 | -#endif | ||
2960 | - } | ||
2961 | + | ||
2962 | + tim = hrtimer_update_lowres(timer, tim, mode); | ||
2963 | |||
2964 | hrtimer_set_expires_range_ns(timer, tim, delta_ns); | ||
2965 | |||
2966 | @@ -1074,19 +1081,23 @@ EXPORT_SYMBOL_GPL(hrtimer_cancel); | ||
2967 | /** | ||
2968 | * hrtimer_get_remaining - get remaining time for the timer | ||
2969 | * @timer: the timer to read | ||
2970 | + * @adjust: adjust relative timers when CONFIG_TIME_LOW_RES=y | ||
2971 | */ | ||
2972 | -ktime_t hrtimer_get_remaining(const struct hrtimer *timer) | ||
2973 | +ktime_t __hrtimer_get_remaining(const struct hrtimer *timer, bool adjust) | ||
2974 | { | ||
2975 | unsigned long flags; | ||
2976 | ktime_t rem; | ||
2977 | |||
2978 | lock_hrtimer_base(timer, &flags); | ||
2979 | - rem = hrtimer_expires_remaining(timer); | ||
2980 | + if (IS_ENABLED(CONFIG_TIME_LOW_RES) && adjust) | ||
2981 | + rem = hrtimer_expires_remaining_adjusted(timer); | ||
2982 | + else | ||
2983 | + rem = hrtimer_expires_remaining(timer); | ||
2984 | unlock_hrtimer_base(timer, &flags); | ||
2985 | |||
2986 | return rem; | ||
2987 | } | ||
2988 | -EXPORT_SYMBOL_GPL(hrtimer_get_remaining); | ||
2989 | +EXPORT_SYMBOL_GPL(__hrtimer_get_remaining); | ||
2990 | |||
2991 | #ifdef CONFIG_NO_HZ_COMMON | ||
2992 | /** | ||
2993 | @@ -1220,6 +1231,14 @@ static void __run_hrtimer(struct hrtimer_cpu_base *cpu_base, | ||
2994 | fn = timer->function; | ||
2995 | |||
2996 | /* | ||
2997 | + * Clear the 'is relative' flag for the TIME_LOW_RES case. If the | ||
2998 | + * timer is restarted with a period then it becomes an absolute | ||
2999 | + * timer. If its not restarted it does not matter. | ||
3000 | + */ | ||
3001 | + if (IS_ENABLED(CONFIG_TIME_LOW_RES)) | ||
3002 | + timer->is_rel = false; | ||
3003 | + | ||
3004 | + /* | ||
3005 | * Because we run timers from hardirq context, there is no chance | ||
3006 | * they get migrated to another cpu, therefore its safe to unlock | ||
3007 | * the timer base. | ||
3008 | diff --git a/kernel/time/timer_list.c b/kernel/time/timer_list.c | ||
3009 | index f75e35b60149..ba7d8b288bb3 100644 | ||
3010 | --- a/kernel/time/timer_list.c | ||
3011 | +++ b/kernel/time/timer_list.c | ||
3012 | @@ -69,7 +69,7 @@ print_timer(struct seq_file *m, struct hrtimer *taddr, struct hrtimer *timer, | ||
3013 | print_name_offset(m, taddr); | ||
3014 | SEQ_printf(m, ", "); | ||
3015 | print_name_offset(m, timer->function); | ||
3016 | - SEQ_printf(m, ", S:%02lx", timer->state); | ||
3017 | + SEQ_printf(m, ", S:%02x", timer->state); | ||
3018 | #ifdef CONFIG_TIMER_STATS | ||
3019 | SEQ_printf(m, ", "); | ||
3020 | print_name_offset(m, timer->start_site); | ||
3021 | diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c | ||
3022 | index 87fb9801bd9e..d9293402ee68 100644 | ||
3023 | --- a/kernel/trace/trace.c | ||
3024 | +++ b/kernel/trace/trace.c | ||
3025 | @@ -1751,7 +1751,7 @@ void trace_buffer_unlock_commit_regs(struct trace_array *tr, | ||
3026 | { | ||
3027 | __buffer_unlock_commit(buffer, event); | ||
3028 | |||
3029 | - ftrace_trace_stack(tr, buffer, flags, 6, pc, regs); | ||
3030 | + ftrace_trace_stack(tr, buffer, flags, 0, pc, regs); | ||
3031 | ftrace_trace_userstack(buffer, flags, pc); | ||
3032 | } | ||
3033 | EXPORT_SYMBOL_GPL(trace_buffer_unlock_commit_regs); | ||
3034 | diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c | ||
3035 | index dda9e6742950..202df6cffcca 100644 | ||
3036 | --- a/kernel/trace/trace_stack.c | ||
3037 | +++ b/kernel/trace/trace_stack.c | ||
3038 | @@ -126,6 +126,13 @@ check_stack(unsigned long ip, unsigned long *stack) | ||
3039 | } | ||
3040 | |||
3041 | /* | ||
3042 | + * Some archs may not have the passed in ip in the dump. | ||
3043 | + * If that happens, we need to show everything. | ||
3044 | + */ | ||
3045 | + if (i == stack_trace_max.nr_entries) | ||
3046 | + i = 0; | ||
3047 | + | ||
3048 | + /* | ||
3049 | * Now find where in the stack these are. | ||
3050 | */ | ||
3051 | x = 0; | ||
3052 | diff --git a/lib/libcrc32c.c b/lib/libcrc32c.c | ||
3053 | index 6a08ce7d6adc..acf9da449f81 100644 | ||
3054 | --- a/lib/libcrc32c.c | ||
3055 | +++ b/lib/libcrc32c.c | ||
3056 | @@ -74,3 +74,4 @@ module_exit(libcrc32c_mod_fini); | ||
3057 | MODULE_AUTHOR("Clay Haapala <chaapala@cisco.com>"); | ||
3058 | MODULE_DESCRIPTION("CRC32c (Castagnoli) calculations"); | ||
3059 | MODULE_LICENSE("GPL"); | ||
3060 | +MODULE_SOFTDEP("pre: crc32c"); | ||
3061 | diff --git a/mm/backing-dev.c b/mm/backing-dev.c | ||
3062 | index 7340353f8aea..cbe6f0b96f29 100644 | ||
3063 | --- a/mm/backing-dev.c | ||
3064 | +++ b/mm/backing-dev.c | ||
3065 | @@ -989,7 +989,7 @@ long wait_iff_congested(struct zone *zone, int sync, long timeout) | ||
3066 | * here rather than calling cond_resched(). | ||
3067 | */ | ||
3068 | if (current->flags & PF_WQ_WORKER) | ||
3069 | - schedule_timeout(1); | ||
3070 | + schedule_timeout_uninterruptible(1); | ||
3071 | else | ||
3072 | cond_resched(); | ||
3073 | |||
3074 | diff --git a/mm/zsmalloc.c b/mm/zsmalloc.c | ||
3075 | index 9f15bdd9163c..fc083996e40a 100644 | ||
3076 | --- a/mm/zsmalloc.c | ||
3077 | +++ b/mm/zsmalloc.c | ||
3078 | @@ -309,7 +309,12 @@ static void free_handle(struct zs_pool *pool, unsigned long handle) | ||
3079 | |||
3080 | static void record_obj(unsigned long handle, unsigned long obj) | ||
3081 | { | ||
3082 | - *(unsigned long *)handle = obj; | ||
3083 | + /* | ||
3084 | + * lsb of @obj represents handle lock while other bits | ||
3085 | + * represent object value the handle is pointing so | ||
3086 | + * updating shouldn't do store tearing. | ||
3087 | + */ | ||
3088 | + WRITE_ONCE(*(unsigned long *)handle, obj); | ||
3089 | } | ||
3090 | |||
3091 | /* zpool driver */ | ||
3092 | @@ -1635,6 +1640,13 @@ static int migrate_zspage(struct zs_pool *pool, struct size_class *class, | ||
3093 | free_obj = obj_malloc(d_page, class, handle); | ||
3094 | zs_object_copy(free_obj, used_obj, class); | ||
3095 | index++; | ||
3096 | + /* | ||
3097 | + * record_obj updates handle's value to free_obj and it will | ||
3098 | + * invalidate lock bit(ie, HANDLE_PIN_BIT) of handle, which | ||
3099 | + * breaks synchronization using pin_tag(e,g, zs_free) so | ||
3100 | + * let's keep the lock bit. | ||
3101 | + */ | ||
3102 | + free_obj |= BIT(HANDLE_PIN_BIT); | ||
3103 | record_obj(handle, free_obj); | ||
3104 | unpin_tag(handle); | ||
3105 | obj_free(pool, class, used_obj); | ||
3106 | diff --git a/security/integrity/evm/evm_main.c b/security/integrity/evm/evm_main.c | ||
3107 | index 1334e02ae8f4..3d145a3ffccf 100644 | ||
3108 | --- a/security/integrity/evm/evm_main.c | ||
3109 | +++ b/security/integrity/evm/evm_main.c | ||
3110 | @@ -23,6 +23,7 @@ | ||
3111 | #include <linux/integrity.h> | ||
3112 | #include <linux/evm.h> | ||
3113 | #include <crypto/hash.h> | ||
3114 | +#include <crypto/algapi.h> | ||
3115 | #include "evm.h" | ||
3116 | |||
3117 | int evm_initialized; | ||
3118 | @@ -148,7 +149,7 @@ static enum integrity_status evm_verify_hmac(struct dentry *dentry, | ||
3119 | xattr_value_len, calc.digest); | ||
3120 | if (rc) | ||
3121 | break; | ||
3122 | - rc = memcmp(xattr_data->digest, calc.digest, | ||
3123 | + rc = crypto_memneq(xattr_data->digest, calc.digest, | ||
3124 | sizeof(calc.digest)); | ||
3125 | if (rc) | ||
3126 | rc = -EINVAL; | ||
3127 | diff --git a/sound/core/compress_offload.c b/sound/core/compress_offload.c | ||
3128 | index b123c42e7dc8..b554d7f9e3be 100644 | ||
3129 | --- a/sound/core/compress_offload.c | ||
3130 | +++ b/sound/core/compress_offload.c | ||
3131 | @@ -44,6 +44,13 @@ | ||
3132 | #include <sound/compress_offload.h> | ||
3133 | #include <sound/compress_driver.h> | ||
3134 | |||
3135 | +/* struct snd_compr_codec_caps overflows the ioctl bit size for some | ||
3136 | + * architectures, so we need to disable the relevant ioctls. | ||
3137 | + */ | ||
3138 | +#if _IOC_SIZEBITS < 14 | ||
3139 | +#define COMPR_CODEC_CAPS_OVERFLOW | ||
3140 | +#endif | ||
3141 | + | ||
3142 | /* TODO: | ||
3143 | * - add substream support for multiple devices in case of | ||
3144 | * SND_DYNAMIC_MINORS is not used | ||
3145 | @@ -438,6 +445,7 @@ out: | ||
3146 | return retval; | ||
3147 | } | ||
3148 | |||
3149 | +#ifndef COMPR_CODEC_CAPS_OVERFLOW | ||
3150 | static int | ||
3151 | snd_compr_get_codec_caps(struct snd_compr_stream *stream, unsigned long arg) | ||
3152 | { | ||
3153 | @@ -461,6 +469,7 @@ out: | ||
3154 | kfree(caps); | ||
3155 | return retval; | ||
3156 | } | ||
3157 | +#endif /* !COMPR_CODEC_CAPS_OVERFLOW */ | ||
3158 | |||
3159 | /* revisit this with snd_pcm_preallocate_xxx */ | ||
3160 | static int snd_compr_allocate_buffer(struct snd_compr_stream *stream, | ||
3161 | @@ -799,9 +808,11 @@ static long snd_compr_ioctl(struct file *f, unsigned int cmd, unsigned long arg) | ||
3162 | case _IOC_NR(SNDRV_COMPRESS_GET_CAPS): | ||
3163 | retval = snd_compr_get_caps(stream, arg); | ||
3164 | break; | ||
3165 | +#ifndef COMPR_CODEC_CAPS_OVERFLOW | ||
3166 | case _IOC_NR(SNDRV_COMPRESS_GET_CODEC_CAPS): | ||
3167 | retval = snd_compr_get_codec_caps(stream, arg); | ||
3168 | break; | ||
3169 | +#endif | ||
3170 | case _IOC_NR(SNDRV_COMPRESS_SET_PARAMS): | ||
3171 | retval = snd_compr_set_params(stream, arg); | ||
3172 | break; | ||
3173 | diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c | ||
3174 | index 58550cc93f28..33e72c809e50 100644 | ||
3175 | --- a/sound/core/oss/pcm_oss.c | ||
3176 | +++ b/sound/core/oss/pcm_oss.c | ||
3177 | @@ -834,7 +834,8 @@ static int choose_rate(struct snd_pcm_substream *substream, | ||
3178 | return snd_pcm_hw_param_near(substream, params, SNDRV_PCM_HW_PARAM_RATE, best_rate, NULL); | ||
3179 | } | ||
3180 | |||
3181 | -static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream) | ||
3182 | +static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream, | ||
3183 | + bool trylock) | ||
3184 | { | ||
3185 | struct snd_pcm_runtime *runtime = substream->runtime; | ||
3186 | struct snd_pcm_hw_params *params, *sparams; | ||
3187 | @@ -848,7 +849,10 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream) | ||
3188 | struct snd_mask sformat_mask; | ||
3189 | struct snd_mask mask; | ||
3190 | |||
3191 | - if (mutex_lock_interruptible(&runtime->oss.params_lock)) | ||
3192 | + if (trylock) { | ||
3193 | + if (!(mutex_trylock(&runtime->oss.params_lock))) | ||
3194 | + return -EAGAIN; | ||
3195 | + } else if (mutex_lock_interruptible(&runtime->oss.params_lock)) | ||
3196 | return -EINTR; | ||
3197 | sw_params = kmalloc(sizeof(*sw_params), GFP_KERNEL); | ||
3198 | params = kmalloc(sizeof(*params), GFP_KERNEL); | ||
3199 | @@ -1092,7 +1096,7 @@ static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_fil | ||
3200 | if (asubstream == NULL) | ||
3201 | asubstream = substream; | ||
3202 | if (substream->runtime->oss.params) { | ||
3203 | - err = snd_pcm_oss_change_params(substream); | ||
3204 | + err = snd_pcm_oss_change_params(substream, false); | ||
3205 | if (err < 0) | ||
3206 | return err; | ||
3207 | } | ||
3208 | @@ -1132,7 +1136,7 @@ static int snd_pcm_oss_make_ready(struct snd_pcm_substream *substream) | ||
3209 | return 0; | ||
3210 | runtime = substream->runtime; | ||
3211 | if (runtime->oss.params) { | ||
3212 | - err = snd_pcm_oss_change_params(substream); | ||
3213 | + err = snd_pcm_oss_change_params(substream, false); | ||
3214 | if (err < 0) | ||
3215 | return err; | ||
3216 | } | ||
3217 | @@ -2163,7 +2167,7 @@ static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stre | ||
3218 | runtime = substream->runtime; | ||
3219 | |||
3220 | if (runtime->oss.params && | ||
3221 | - (err = snd_pcm_oss_change_params(substream)) < 0) | ||
3222 | + (err = snd_pcm_oss_change_params(substream, false)) < 0) | ||
3223 | return err; | ||
3224 | |||
3225 | info.fragsize = runtime->oss.period_bytes; | ||
3226 | @@ -2800,7 +2804,12 @@ static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area) | ||
3227 | return -EIO; | ||
3228 | |||
3229 | if (runtime->oss.params) { | ||
3230 | - if ((err = snd_pcm_oss_change_params(substream)) < 0) | ||
3231 | + /* use mutex_trylock() for params_lock for avoiding a deadlock | ||
3232 | + * between mmap_sem and params_lock taken by | ||
3233 | + * copy_from/to_user() in snd_pcm_oss_write/read() | ||
3234 | + */ | ||
3235 | + err = snd_pcm_oss_change_params(substream, true); | ||
3236 | + if (err < 0) | ||
3237 | return err; | ||
3238 | } | ||
3239 | #ifdef CONFIG_SND_PCM_OSS_PLUGINS | ||
3240 | diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c | ||
3241 | index a7759846fbaa..795437b10082 100644 | ||
3242 | --- a/sound/core/rawmidi.c | ||
3243 | +++ b/sound/core/rawmidi.c | ||
3244 | @@ -942,31 +942,36 @@ static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream, | ||
3245 | unsigned long flags; | ||
3246 | long result = 0, count1; | ||
3247 | struct snd_rawmidi_runtime *runtime = substream->runtime; | ||
3248 | + unsigned long appl_ptr; | ||
3249 | |||
3250 | + spin_lock_irqsave(&runtime->lock, flags); | ||
3251 | while (count > 0 && runtime->avail) { | ||
3252 | count1 = runtime->buffer_size - runtime->appl_ptr; | ||
3253 | if (count1 > count) | ||
3254 | count1 = count; | ||
3255 | - spin_lock_irqsave(&runtime->lock, flags); | ||
3256 | if (count1 > (int)runtime->avail) | ||
3257 | count1 = runtime->avail; | ||
3258 | + | ||
3259 | + /* update runtime->appl_ptr before unlocking for userbuf */ | ||
3260 | + appl_ptr = runtime->appl_ptr; | ||
3261 | + runtime->appl_ptr += count1; | ||
3262 | + runtime->appl_ptr %= runtime->buffer_size; | ||
3263 | + runtime->avail -= count1; | ||
3264 | + | ||
3265 | if (kernelbuf) | ||
3266 | - memcpy(kernelbuf + result, runtime->buffer + runtime->appl_ptr, count1); | ||
3267 | + memcpy(kernelbuf + result, runtime->buffer + appl_ptr, count1); | ||
3268 | if (userbuf) { | ||
3269 | spin_unlock_irqrestore(&runtime->lock, flags); | ||
3270 | if (copy_to_user(userbuf + result, | ||
3271 | - runtime->buffer + runtime->appl_ptr, count1)) { | ||
3272 | + runtime->buffer + appl_ptr, count1)) { | ||
3273 | return result > 0 ? result : -EFAULT; | ||
3274 | } | ||
3275 | spin_lock_irqsave(&runtime->lock, flags); | ||
3276 | } | ||
3277 | - runtime->appl_ptr += count1; | ||
3278 | - runtime->appl_ptr %= runtime->buffer_size; | ||
3279 | - runtime->avail -= count1; | ||
3280 | - spin_unlock_irqrestore(&runtime->lock, flags); | ||
3281 | result += count1; | ||
3282 | count -= count1; | ||
3283 | } | ||
3284 | + spin_unlock_irqrestore(&runtime->lock, flags); | ||
3285 | return result; | ||
3286 | } | ||
3287 | |||
3288 | @@ -1055,23 +1060,16 @@ int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream) | ||
3289 | EXPORT_SYMBOL(snd_rawmidi_transmit_empty); | ||
3290 | |||
3291 | /** | ||
3292 | - * snd_rawmidi_transmit_peek - copy data from the internal buffer | ||
3293 | + * __snd_rawmidi_transmit_peek - copy data from the internal buffer | ||
3294 | * @substream: the rawmidi substream | ||
3295 | * @buffer: the buffer pointer | ||
3296 | * @count: data size to transfer | ||
3297 | * | ||
3298 | - * Copies data from the internal output buffer to the given buffer. | ||
3299 | - * | ||
3300 | - * Call this in the interrupt handler when the midi output is ready, | ||
3301 | - * and call snd_rawmidi_transmit_ack() after the transmission is | ||
3302 | - * finished. | ||
3303 | - * | ||
3304 | - * Return: The size of copied data, or a negative error code on failure. | ||
3305 | + * This is a variant of snd_rawmidi_transmit_peek() without spinlock. | ||
3306 | */ | ||
3307 | -int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, | ||
3308 | +int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, | ||
3309 | unsigned char *buffer, int count) | ||
3310 | { | ||
3311 | - unsigned long flags; | ||
3312 | int result, count1; | ||
3313 | struct snd_rawmidi_runtime *runtime = substream->runtime; | ||
3314 | |||
3315 | @@ -1081,7 +1079,6 @@ int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, | ||
3316 | return -EINVAL; | ||
3317 | } | ||
3318 | result = 0; | ||
3319 | - spin_lock_irqsave(&runtime->lock, flags); | ||
3320 | if (runtime->avail >= runtime->buffer_size) { | ||
3321 | /* warning: lowlevel layer MUST trigger down the hardware */ | ||
3322 | goto __skip; | ||
3323 | @@ -1106,25 +1103,47 @@ int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, | ||
3324 | } | ||
3325 | } | ||
3326 | __skip: | ||
3327 | + return result; | ||
3328 | +} | ||
3329 | +EXPORT_SYMBOL(__snd_rawmidi_transmit_peek); | ||
3330 | + | ||
3331 | +/** | ||
3332 | + * snd_rawmidi_transmit_peek - copy data from the internal buffer | ||
3333 | + * @substream: the rawmidi substream | ||
3334 | + * @buffer: the buffer pointer | ||
3335 | + * @count: data size to transfer | ||
3336 | + * | ||
3337 | + * Copies data from the internal output buffer to the given buffer. | ||
3338 | + * | ||
3339 | + * Call this in the interrupt handler when the midi output is ready, | ||
3340 | + * and call snd_rawmidi_transmit_ack() after the transmission is | ||
3341 | + * finished. | ||
3342 | + * | ||
3343 | + * Return: The size of copied data, or a negative error code on failure. | ||
3344 | + */ | ||
3345 | +int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, | ||
3346 | + unsigned char *buffer, int count) | ||
3347 | +{ | ||
3348 | + struct snd_rawmidi_runtime *runtime = substream->runtime; | ||
3349 | + int result; | ||
3350 | + unsigned long flags; | ||
3351 | + | ||
3352 | + spin_lock_irqsave(&runtime->lock, flags); | ||
3353 | + result = __snd_rawmidi_transmit_peek(substream, buffer, count); | ||
3354 | spin_unlock_irqrestore(&runtime->lock, flags); | ||
3355 | return result; | ||
3356 | } | ||
3357 | EXPORT_SYMBOL(snd_rawmidi_transmit_peek); | ||
3358 | |||
3359 | /** | ||
3360 | - * snd_rawmidi_transmit_ack - acknowledge the transmission | ||
3361 | + * __snd_rawmidi_transmit_ack - acknowledge the transmission | ||
3362 | * @substream: the rawmidi substream | ||
3363 | * @count: the transferred count | ||
3364 | * | ||
3365 | - * Advances the hardware pointer for the internal output buffer with | ||
3366 | - * the given size and updates the condition. | ||
3367 | - * Call after the transmission is finished. | ||
3368 | - * | ||
3369 | - * Return: The advanced size if successful, or a negative error code on failure. | ||
3370 | + * This is a variant of __snd_rawmidi_transmit_ack() without spinlock. | ||
3371 | */ | ||
3372 | -int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) | ||
3373 | +int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) | ||
3374 | { | ||
3375 | - unsigned long flags; | ||
3376 | struct snd_rawmidi_runtime *runtime = substream->runtime; | ||
3377 | |||
3378 | if (runtime->buffer == NULL) { | ||
3379 | @@ -1132,7 +1151,6 @@ int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) | ||
3380 | "snd_rawmidi_transmit_ack: output is not active!!!\n"); | ||
3381 | return -EINVAL; | ||
3382 | } | ||
3383 | - spin_lock_irqsave(&runtime->lock, flags); | ||
3384 | snd_BUG_ON(runtime->avail + count > runtime->buffer_size); | ||
3385 | runtime->hw_ptr += count; | ||
3386 | runtime->hw_ptr %= runtime->buffer_size; | ||
3387 | @@ -1142,9 +1160,32 @@ int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) | ||
3388 | if (runtime->drain || snd_rawmidi_ready(substream)) | ||
3389 | wake_up(&runtime->sleep); | ||
3390 | } | ||
3391 | - spin_unlock_irqrestore(&runtime->lock, flags); | ||
3392 | return count; | ||
3393 | } | ||
3394 | +EXPORT_SYMBOL(__snd_rawmidi_transmit_ack); | ||
3395 | + | ||
3396 | +/** | ||
3397 | + * snd_rawmidi_transmit_ack - acknowledge the transmission | ||
3398 | + * @substream: the rawmidi substream | ||
3399 | + * @count: the transferred count | ||
3400 | + * | ||
3401 | + * Advances the hardware pointer for the internal output buffer with | ||
3402 | + * the given size and updates the condition. | ||
3403 | + * Call after the transmission is finished. | ||
3404 | + * | ||
3405 | + * Return: The advanced size if successful, or a negative error code on failure. | ||
3406 | + */ | ||
3407 | +int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) | ||
3408 | +{ | ||
3409 | + struct snd_rawmidi_runtime *runtime = substream->runtime; | ||
3410 | + int result; | ||
3411 | + unsigned long flags; | ||
3412 | + | ||
3413 | + spin_lock_irqsave(&runtime->lock, flags); | ||
3414 | + result = __snd_rawmidi_transmit_ack(substream, count); | ||
3415 | + spin_unlock_irqrestore(&runtime->lock, flags); | ||
3416 | + return result; | ||
3417 | +} | ||
3418 | EXPORT_SYMBOL(snd_rawmidi_transmit_ack); | ||
3419 | |||
3420 | /** | ||
3421 | @@ -1160,12 +1201,22 @@ EXPORT_SYMBOL(snd_rawmidi_transmit_ack); | ||
3422 | int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, | ||
3423 | unsigned char *buffer, int count) | ||
3424 | { | ||
3425 | + struct snd_rawmidi_runtime *runtime = substream->runtime; | ||
3426 | + int result; | ||
3427 | + unsigned long flags; | ||
3428 | + | ||
3429 | + spin_lock_irqsave(&runtime->lock, flags); | ||
3430 | if (!substream->opened) | ||
3431 | - return -EBADFD; | ||
3432 | - count = snd_rawmidi_transmit_peek(substream, buffer, count); | ||
3433 | - if (count < 0) | ||
3434 | - return count; | ||
3435 | - return snd_rawmidi_transmit_ack(substream, count); | ||
3436 | + result = -EBADFD; | ||
3437 | + else { | ||
3438 | + count = __snd_rawmidi_transmit_peek(substream, buffer, count); | ||
3439 | + if (count <= 0) | ||
3440 | + result = count; | ||
3441 | + else | ||
3442 | + result = __snd_rawmidi_transmit_ack(substream, count); | ||
3443 | + } | ||
3444 | + spin_unlock_irqrestore(&runtime->lock, flags); | ||
3445 | + return result; | ||
3446 | } | ||
3447 | EXPORT_SYMBOL(snd_rawmidi_transmit); | ||
3448 | |||
3449 | @@ -1177,8 +1228,9 @@ static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream, | ||
3450 | unsigned long flags; | ||
3451 | long count1, result; | ||
3452 | struct snd_rawmidi_runtime *runtime = substream->runtime; | ||
3453 | + unsigned long appl_ptr; | ||
3454 | |||
3455 | - if (snd_BUG_ON(!kernelbuf && !userbuf)) | ||
3456 | + if (!kernelbuf && !userbuf) | ||
3457 | return -EINVAL; | ||
3458 | if (snd_BUG_ON(!runtime->buffer)) | ||
3459 | return -EINVAL; | ||
3460 | @@ -1197,12 +1249,19 @@ static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream, | ||
3461 | count1 = count; | ||
3462 | if (count1 > (long)runtime->avail) | ||
3463 | count1 = runtime->avail; | ||
3464 | + | ||
3465 | + /* update runtime->appl_ptr before unlocking for userbuf */ | ||
3466 | + appl_ptr = runtime->appl_ptr; | ||
3467 | + runtime->appl_ptr += count1; | ||
3468 | + runtime->appl_ptr %= runtime->buffer_size; | ||
3469 | + runtime->avail -= count1; | ||
3470 | + | ||
3471 | if (kernelbuf) | ||
3472 | - memcpy(runtime->buffer + runtime->appl_ptr, | ||
3473 | + memcpy(runtime->buffer + appl_ptr, | ||
3474 | kernelbuf + result, count1); | ||
3475 | else if (userbuf) { | ||
3476 | spin_unlock_irqrestore(&runtime->lock, flags); | ||
3477 | - if (copy_from_user(runtime->buffer + runtime->appl_ptr, | ||
3478 | + if (copy_from_user(runtime->buffer + appl_ptr, | ||
3479 | userbuf + result, count1)) { | ||
3480 | spin_lock_irqsave(&runtime->lock, flags); | ||
3481 | result = result > 0 ? result : -EFAULT; | ||
3482 | @@ -1210,9 +1269,6 @@ static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream, | ||
3483 | } | ||
3484 | spin_lock_irqsave(&runtime->lock, flags); | ||
3485 | } | ||
3486 | - runtime->appl_ptr += count1; | ||
3487 | - runtime->appl_ptr %= runtime->buffer_size; | ||
3488 | - runtime->avail -= count1; | ||
3489 | result += count1; | ||
3490 | count -= count1; | ||
3491 | } | ||
3492 | diff --git a/sound/core/seq/oss/seq_oss_init.c b/sound/core/seq/oss/seq_oss_init.c | ||
3493 | index b1221b29728e..6779e82b46dd 100644 | ||
3494 | --- a/sound/core/seq/oss/seq_oss_init.c | ||
3495 | +++ b/sound/core/seq/oss/seq_oss_init.c | ||
3496 | @@ -202,7 +202,7 @@ snd_seq_oss_open(struct file *file, int level) | ||
3497 | |||
3498 | dp->index = i; | ||
3499 | if (i >= SNDRV_SEQ_OSS_MAX_CLIENTS) { | ||
3500 | - pr_err("ALSA: seq_oss: too many applications\n"); | ||
3501 | + pr_debug("ALSA: seq_oss: too many applications\n"); | ||
3502 | rc = -ENOMEM; | ||
3503 | goto _error; | ||
3504 | } | ||
3505 | diff --git a/sound/core/seq/oss/seq_oss_synth.c b/sound/core/seq/oss/seq_oss_synth.c | ||
3506 | index 0f3b38184fe5..b16dbef04174 100644 | ||
3507 | --- a/sound/core/seq/oss/seq_oss_synth.c | ||
3508 | +++ b/sound/core/seq/oss/seq_oss_synth.c | ||
3509 | @@ -308,7 +308,7 @@ snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp) | ||
3510 | struct seq_oss_synth *rec; | ||
3511 | struct seq_oss_synthinfo *info; | ||
3512 | |||
3513 | - if (snd_BUG_ON(dp->max_synthdev >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS)) | ||
3514 | + if (snd_BUG_ON(dp->max_synthdev > SNDRV_SEQ_OSS_MAX_SYNTH_DEVS)) | ||
3515 | return; | ||
3516 | for (i = 0; i < dp->max_synthdev; i++) { | ||
3517 | info = &dp->synths[i]; | ||
3518 | diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c | ||
3519 | index 13cfa815732d..58e79e02f217 100644 | ||
3520 | --- a/sound/core/seq/seq_clientmgr.c | ||
3521 | +++ b/sound/core/seq/seq_clientmgr.c | ||
3522 | @@ -678,6 +678,9 @@ static int deliver_to_subscribers(struct snd_seq_client *client, | ||
3523 | else | ||
3524 | down_read(&grp->list_mutex); | ||
3525 | list_for_each_entry(subs, &grp->list_head, src_list) { | ||
3526 | + /* both ports ready? */ | ||
3527 | + if (atomic_read(&subs->ref_count) != 2) | ||
3528 | + continue; | ||
3529 | event->dest = subs->info.dest; | ||
3530 | if (subs->info.flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP) | ||
3531 | /* convert time according to flag with subscription */ | ||
3532 | diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c | ||
3533 | index 55170a20ae72..921fb2bd8fad 100644 | ||
3534 | --- a/sound/core/seq/seq_ports.c | ||
3535 | +++ b/sound/core/seq/seq_ports.c | ||
3536 | @@ -173,10 +173,6 @@ struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client, | ||
3537 | } | ||
3538 | |||
3539 | /* */ | ||
3540 | -enum group_type { | ||
3541 | - SRC_LIST, DEST_LIST | ||
3542 | -}; | ||
3543 | - | ||
3544 | static int subscribe_port(struct snd_seq_client *client, | ||
3545 | struct snd_seq_client_port *port, | ||
3546 | struct snd_seq_port_subs_info *grp, | ||
3547 | @@ -203,6 +199,20 @@ static struct snd_seq_client_port *get_client_port(struct snd_seq_addr *addr, | ||
3548 | return NULL; | ||
3549 | } | ||
3550 | |||
3551 | +static void delete_and_unsubscribe_port(struct snd_seq_client *client, | ||
3552 | + struct snd_seq_client_port *port, | ||
3553 | + struct snd_seq_subscribers *subs, | ||
3554 | + bool is_src, bool ack); | ||
3555 | + | ||
3556 | +static inline struct snd_seq_subscribers * | ||
3557 | +get_subscriber(struct list_head *p, bool is_src) | ||
3558 | +{ | ||
3559 | + if (is_src) | ||
3560 | + return list_entry(p, struct snd_seq_subscribers, src_list); | ||
3561 | + else | ||
3562 | + return list_entry(p, struct snd_seq_subscribers, dest_list); | ||
3563 | +} | ||
3564 | + | ||
3565 | /* | ||
3566 | * remove all subscribers on the list | ||
3567 | * this is called from port_delete, for each src and dest list. | ||
3568 | @@ -210,7 +220,7 @@ static struct snd_seq_client_port *get_client_port(struct snd_seq_addr *addr, | ||
3569 | static void clear_subscriber_list(struct snd_seq_client *client, | ||
3570 | struct snd_seq_client_port *port, | ||
3571 | struct snd_seq_port_subs_info *grp, | ||
3572 | - int grptype) | ||
3573 | + int is_src) | ||
3574 | { | ||
3575 | struct list_head *p, *n; | ||
3576 | |||
3577 | @@ -219,15 +229,13 @@ static void clear_subscriber_list(struct snd_seq_client *client, | ||
3578 | struct snd_seq_client *c; | ||
3579 | struct snd_seq_client_port *aport; | ||
3580 | |||
3581 | - if (grptype == SRC_LIST) { | ||
3582 | - subs = list_entry(p, struct snd_seq_subscribers, src_list); | ||
3583 | + subs = get_subscriber(p, is_src); | ||
3584 | + if (is_src) | ||
3585 | aport = get_client_port(&subs->info.dest, &c); | ||
3586 | - } else { | ||
3587 | - subs = list_entry(p, struct snd_seq_subscribers, dest_list); | ||
3588 | + else | ||
3589 | aport = get_client_port(&subs->info.sender, &c); | ||
3590 | - } | ||
3591 | - list_del(p); | ||
3592 | - unsubscribe_port(client, port, grp, &subs->info, 0); | ||
3593 | + delete_and_unsubscribe_port(client, port, subs, is_src, false); | ||
3594 | + | ||
3595 | if (!aport) { | ||
3596 | /* looks like the connected port is being deleted. | ||
3597 | * we decrease the counter, and when both ports are deleted | ||
3598 | @@ -235,21 +243,14 @@ static void clear_subscriber_list(struct snd_seq_client *client, | ||
3599 | */ | ||
3600 | if (atomic_dec_and_test(&subs->ref_count)) | ||
3601 | kfree(subs); | ||
3602 | - } else { | ||
3603 | - /* ok we got the connected port */ | ||
3604 | - struct snd_seq_port_subs_info *agrp; | ||
3605 | - agrp = (grptype == SRC_LIST) ? &aport->c_dest : &aport->c_src; | ||
3606 | - down_write(&agrp->list_mutex); | ||
3607 | - if (grptype == SRC_LIST) | ||
3608 | - list_del(&subs->dest_list); | ||
3609 | - else | ||
3610 | - list_del(&subs->src_list); | ||
3611 | - up_write(&agrp->list_mutex); | ||
3612 | - unsubscribe_port(c, aport, agrp, &subs->info, 1); | ||
3613 | - kfree(subs); | ||
3614 | - snd_seq_port_unlock(aport); | ||
3615 | - snd_seq_client_unlock(c); | ||
3616 | + continue; | ||
3617 | } | ||
3618 | + | ||
3619 | + /* ok we got the connected port */ | ||
3620 | + delete_and_unsubscribe_port(c, aport, subs, !is_src, true); | ||
3621 | + kfree(subs); | ||
3622 | + snd_seq_port_unlock(aport); | ||
3623 | + snd_seq_client_unlock(c); | ||
3624 | } | ||
3625 | } | ||
3626 | |||
3627 | @@ -262,8 +263,8 @@ static int port_delete(struct snd_seq_client *client, | ||
3628 | snd_use_lock_sync(&port->use_lock); | ||
3629 | |||
3630 | /* clear subscribers info */ | ||
3631 | - clear_subscriber_list(client, port, &port->c_src, SRC_LIST); | ||
3632 | - clear_subscriber_list(client, port, &port->c_dest, DEST_LIST); | ||
3633 | + clear_subscriber_list(client, port, &port->c_src, true); | ||
3634 | + clear_subscriber_list(client, port, &port->c_dest, false); | ||
3635 | |||
3636 | if (port->private_free) | ||
3637 | port->private_free(port->private_data); | ||
3638 | @@ -479,85 +480,120 @@ static int match_subs_info(struct snd_seq_port_subscribe *r, | ||
3639 | return 0; | ||
3640 | } | ||
3641 | |||
3642 | - | ||
3643 | -/* connect two ports */ | ||
3644 | -int snd_seq_port_connect(struct snd_seq_client *connector, | ||
3645 | - struct snd_seq_client *src_client, | ||
3646 | - struct snd_seq_client_port *src_port, | ||
3647 | - struct snd_seq_client *dest_client, | ||
3648 | - struct snd_seq_client_port *dest_port, | ||
3649 | - struct snd_seq_port_subscribe *info) | ||
3650 | +static int check_and_subscribe_port(struct snd_seq_client *client, | ||
3651 | + struct snd_seq_client_port *port, | ||
3652 | + struct snd_seq_subscribers *subs, | ||
3653 | + bool is_src, bool exclusive, bool ack) | ||
3654 | { | ||
3655 | - struct snd_seq_port_subs_info *src = &src_port->c_src; | ||
3656 | - struct snd_seq_port_subs_info *dest = &dest_port->c_dest; | ||
3657 | - struct snd_seq_subscribers *subs, *s; | ||
3658 | - int err, src_called = 0; | ||
3659 | - unsigned long flags; | ||
3660 | - int exclusive; | ||
3661 | + struct snd_seq_port_subs_info *grp; | ||
3662 | + struct list_head *p; | ||
3663 | + struct snd_seq_subscribers *s; | ||
3664 | + int err; | ||
3665 | |||
3666 | - subs = kzalloc(sizeof(*subs), GFP_KERNEL); | ||
3667 | - if (! subs) | ||
3668 | - return -ENOMEM; | ||
3669 | - | ||
3670 | - subs->info = *info; | ||
3671 | - atomic_set(&subs->ref_count, 2); | ||
3672 | - | ||
3673 | - down_write(&src->list_mutex); | ||
3674 | - down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING); | ||
3675 | - | ||
3676 | - exclusive = info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE ? 1 : 0; | ||
3677 | + grp = is_src ? &port->c_src : &port->c_dest; | ||
3678 | err = -EBUSY; | ||
3679 | + down_write(&grp->list_mutex); | ||
3680 | if (exclusive) { | ||
3681 | - if (! list_empty(&src->list_head) || ! list_empty(&dest->list_head)) | ||
3682 | + if (!list_empty(&grp->list_head)) | ||
3683 | goto __error; | ||
3684 | } else { | ||
3685 | - if (src->exclusive || dest->exclusive) | ||
3686 | + if (grp->exclusive) | ||
3687 | goto __error; | ||
3688 | /* check whether already exists */ | ||
3689 | - list_for_each_entry(s, &src->list_head, src_list) { | ||
3690 | - if (match_subs_info(info, &s->info)) | ||
3691 | - goto __error; | ||
3692 | - } | ||
3693 | - list_for_each_entry(s, &dest->list_head, dest_list) { | ||
3694 | - if (match_subs_info(info, &s->info)) | ||
3695 | + list_for_each(p, &grp->list_head) { | ||
3696 | + s = get_subscriber(p, is_src); | ||
3697 | + if (match_subs_info(&subs->info, &s->info)) | ||
3698 | goto __error; | ||
3699 | } | ||
3700 | } | ||
3701 | |||
3702 | - if ((err = subscribe_port(src_client, src_port, src, info, | ||
3703 | - connector->number != src_client->number)) < 0) | ||
3704 | - goto __error; | ||
3705 | - src_called = 1; | ||
3706 | - | ||
3707 | - if ((err = subscribe_port(dest_client, dest_port, dest, info, | ||
3708 | - connector->number != dest_client->number)) < 0) | ||
3709 | + err = subscribe_port(client, port, grp, &subs->info, ack); | ||
3710 | + if (err < 0) { | ||
3711 | + grp->exclusive = 0; | ||
3712 | goto __error; | ||
3713 | + } | ||
3714 | |||
3715 | /* add to list */ | ||
3716 | - write_lock_irqsave(&src->list_lock, flags); | ||
3717 | - // write_lock(&dest->list_lock); // no other lock yet | ||
3718 | - list_add_tail(&subs->src_list, &src->list_head); | ||
3719 | - list_add_tail(&subs->dest_list, &dest->list_head); | ||
3720 | - // write_unlock(&dest->list_lock); // no other lock yet | ||
3721 | - write_unlock_irqrestore(&src->list_lock, flags); | ||
3722 | + write_lock_irq(&grp->list_lock); | ||
3723 | + if (is_src) | ||
3724 | + list_add_tail(&subs->src_list, &grp->list_head); | ||
3725 | + else | ||
3726 | + list_add_tail(&subs->dest_list, &grp->list_head); | ||
3727 | + grp->exclusive = exclusive; | ||
3728 | + atomic_inc(&subs->ref_count); | ||
3729 | + write_unlock_irq(&grp->list_lock); | ||
3730 | + err = 0; | ||
3731 | + | ||
3732 | + __error: | ||
3733 | + up_write(&grp->list_mutex); | ||
3734 | + return err; | ||
3735 | +} | ||
3736 | |||
3737 | - src->exclusive = dest->exclusive = exclusive; | ||
3738 | +static void delete_and_unsubscribe_port(struct snd_seq_client *client, | ||
3739 | + struct snd_seq_client_port *port, | ||
3740 | + struct snd_seq_subscribers *subs, | ||
3741 | + bool is_src, bool ack) | ||
3742 | +{ | ||
3743 | + struct snd_seq_port_subs_info *grp; | ||
3744 | + | ||
3745 | + grp = is_src ? &port->c_src : &port->c_dest; | ||
3746 | + down_write(&grp->list_mutex); | ||
3747 | + write_lock_irq(&grp->list_lock); | ||
3748 | + if (is_src) | ||
3749 | + list_del(&subs->src_list); | ||
3750 | + else | ||
3751 | + list_del(&subs->dest_list); | ||
3752 | + grp->exclusive = 0; | ||
3753 | + write_unlock_irq(&grp->list_lock); | ||
3754 | + up_write(&grp->list_mutex); | ||
3755 | + | ||
3756 | + unsubscribe_port(client, port, grp, &subs->info, ack); | ||
3757 | +} | ||
3758 | + | ||
3759 | +/* connect two ports */ | ||
3760 | +int snd_seq_port_connect(struct snd_seq_client *connector, | ||
3761 | + struct snd_seq_client *src_client, | ||
3762 | + struct snd_seq_client_port *src_port, | ||
3763 | + struct snd_seq_client *dest_client, | ||
3764 | + struct snd_seq_client_port *dest_port, | ||
3765 | + struct snd_seq_port_subscribe *info) | ||
3766 | +{ | ||
3767 | + struct snd_seq_subscribers *subs; | ||
3768 | + bool exclusive; | ||
3769 | + int err; | ||
3770 | + | ||
3771 | + subs = kzalloc(sizeof(*subs), GFP_KERNEL); | ||
3772 | + if (!subs) | ||
3773 | + return -ENOMEM; | ||
3774 | + | ||
3775 | + subs->info = *info; | ||
3776 | + atomic_set(&subs->ref_count, 0); | ||
3777 | + INIT_LIST_HEAD(&subs->src_list); | ||
3778 | + INIT_LIST_HEAD(&subs->dest_list); | ||
3779 | + | ||
3780 | + exclusive = !!(info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE); | ||
3781 | + | ||
3782 | + err = check_and_subscribe_port(src_client, src_port, subs, true, | ||
3783 | + exclusive, | ||
3784 | + connector->number != src_client->number); | ||
3785 | + if (err < 0) | ||
3786 | + goto error; | ||
3787 | + err = check_and_subscribe_port(dest_client, dest_port, subs, false, | ||
3788 | + exclusive, | ||
3789 | + connector->number != dest_client->number); | ||
3790 | + if (err < 0) | ||
3791 | + goto error_dest; | ||
3792 | |||
3793 | - up_write(&dest->list_mutex); | ||
3794 | - up_write(&src->list_mutex); | ||
3795 | return 0; | ||
3796 | |||
3797 | - __error: | ||
3798 | - if (src_called) | ||
3799 | - unsubscribe_port(src_client, src_port, src, info, | ||
3800 | - connector->number != src_client->number); | ||
3801 | + error_dest: | ||
3802 | + delete_and_unsubscribe_port(src_client, src_port, subs, true, | ||
3803 | + connector->number != src_client->number); | ||
3804 | + error: | ||
3805 | kfree(subs); | ||
3806 | - up_write(&dest->list_mutex); | ||
3807 | - up_write(&src->list_mutex); | ||
3808 | return err; | ||
3809 | } | ||
3810 | |||
3811 | - | ||
3812 | /* remove the connection */ | ||
3813 | int snd_seq_port_disconnect(struct snd_seq_client *connector, | ||
3814 | struct snd_seq_client *src_client, | ||
3815 | @@ -567,37 +603,28 @@ int snd_seq_port_disconnect(struct snd_seq_client *connector, | ||
3816 | struct snd_seq_port_subscribe *info) | ||
3817 | { | ||
3818 | struct snd_seq_port_subs_info *src = &src_port->c_src; | ||
3819 | - struct snd_seq_port_subs_info *dest = &dest_port->c_dest; | ||
3820 | struct snd_seq_subscribers *subs; | ||
3821 | int err = -ENOENT; | ||
3822 | - unsigned long flags; | ||
3823 | |||
3824 | down_write(&src->list_mutex); | ||
3825 | - down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING); | ||
3826 | - | ||
3827 | /* look for the connection */ | ||
3828 | list_for_each_entry(subs, &src->list_head, src_list) { | ||
3829 | if (match_subs_info(info, &subs->info)) { | ||
3830 | - write_lock_irqsave(&src->list_lock, flags); | ||
3831 | - // write_lock(&dest->list_lock); // no lock yet | ||
3832 | - list_del(&subs->src_list); | ||
3833 | - list_del(&subs->dest_list); | ||
3834 | - // write_unlock(&dest->list_lock); | ||
3835 | - write_unlock_irqrestore(&src->list_lock, flags); | ||
3836 | - src->exclusive = dest->exclusive = 0; | ||
3837 | - unsubscribe_port(src_client, src_port, src, info, | ||
3838 | - connector->number != src_client->number); | ||
3839 | - unsubscribe_port(dest_client, dest_port, dest, info, | ||
3840 | - connector->number != dest_client->number); | ||
3841 | - kfree(subs); | ||
3842 | + atomic_dec(&subs->ref_count); /* mark as not ready */ | ||
3843 | err = 0; | ||
3844 | break; | ||
3845 | } | ||
3846 | } | ||
3847 | - | ||
3848 | - up_write(&dest->list_mutex); | ||
3849 | up_write(&src->list_mutex); | ||
3850 | - return err; | ||
3851 | + if (err < 0) | ||
3852 | + return err; | ||
3853 | + | ||
3854 | + delete_and_unsubscribe_port(src_client, src_port, subs, true, | ||
3855 | + connector->number != src_client->number); | ||
3856 | + delete_and_unsubscribe_port(dest_client, dest_port, subs, false, | ||
3857 | + connector->number != dest_client->number); | ||
3858 | + kfree(subs); | ||
3859 | + return 0; | ||
3860 | } | ||
3861 | |||
3862 | |||
3863 | diff --git a/sound/core/seq/seq_timer.c b/sound/core/seq/seq_timer.c | ||
3864 | index 82b220c769c1..293104926098 100644 | ||
3865 | --- a/sound/core/seq/seq_timer.c | ||
3866 | +++ b/sound/core/seq/seq_timer.c | ||
3867 | @@ -90,6 +90,9 @@ void snd_seq_timer_delete(struct snd_seq_timer **tmr) | ||
3868 | |||
3869 | void snd_seq_timer_defaults(struct snd_seq_timer * tmr) | ||
3870 | { | ||
3871 | + unsigned long flags; | ||
3872 | + | ||
3873 | + spin_lock_irqsave(&tmr->lock, flags); | ||
3874 | /* setup defaults */ | ||
3875 | tmr->ppq = 96; /* 96 PPQ */ | ||
3876 | tmr->tempo = 500000; /* 120 BPM */ | ||
3877 | @@ -105,21 +108,25 @@ void snd_seq_timer_defaults(struct snd_seq_timer * tmr) | ||
3878 | tmr->preferred_resolution = seq_default_timer_resolution; | ||
3879 | |||
3880 | tmr->skew = tmr->skew_base = SKEW_BASE; | ||
3881 | + spin_unlock_irqrestore(&tmr->lock, flags); | ||
3882 | } | ||
3883 | |||
3884 | -void snd_seq_timer_reset(struct snd_seq_timer * tmr) | ||
3885 | +static void seq_timer_reset(struct snd_seq_timer *tmr) | ||
3886 | { | ||
3887 | - unsigned long flags; | ||
3888 | - | ||
3889 | - spin_lock_irqsave(&tmr->lock, flags); | ||
3890 | - | ||
3891 | /* reset time & songposition */ | ||
3892 | tmr->cur_time.tv_sec = 0; | ||
3893 | tmr->cur_time.tv_nsec = 0; | ||
3894 | |||
3895 | tmr->tick.cur_tick = 0; | ||
3896 | tmr->tick.fraction = 0; | ||
3897 | +} | ||
3898 | + | ||
3899 | +void snd_seq_timer_reset(struct snd_seq_timer *tmr) | ||
3900 | +{ | ||
3901 | + unsigned long flags; | ||
3902 | |||
3903 | + spin_lock_irqsave(&tmr->lock, flags); | ||
3904 | + seq_timer_reset(tmr); | ||
3905 | spin_unlock_irqrestore(&tmr->lock, flags); | ||
3906 | } | ||
3907 | |||
3908 | @@ -138,8 +145,11 @@ static void snd_seq_timer_interrupt(struct snd_timer_instance *timeri, | ||
3909 | tmr = q->timer; | ||
3910 | if (tmr == NULL) | ||
3911 | return; | ||
3912 | - if (!tmr->running) | ||
3913 | + spin_lock_irqsave(&tmr->lock, flags); | ||
3914 | + if (!tmr->running) { | ||
3915 | + spin_unlock_irqrestore(&tmr->lock, flags); | ||
3916 | return; | ||
3917 | + } | ||
3918 | |||
3919 | resolution *= ticks; | ||
3920 | if (tmr->skew != tmr->skew_base) { | ||
3921 | @@ -148,8 +158,6 @@ static void snd_seq_timer_interrupt(struct snd_timer_instance *timeri, | ||
3922 | (((resolution & 0xffff) * tmr->skew) >> 16); | ||
3923 | } | ||
3924 | |||
3925 | - spin_lock_irqsave(&tmr->lock, flags); | ||
3926 | - | ||
3927 | /* update timer */ | ||
3928 | snd_seq_inc_time_nsec(&tmr->cur_time, resolution); | ||
3929 | |||
3930 | @@ -296,26 +304,30 @@ int snd_seq_timer_open(struct snd_seq_queue *q) | ||
3931 | t->callback = snd_seq_timer_interrupt; | ||
3932 | t->callback_data = q; | ||
3933 | t->flags |= SNDRV_TIMER_IFLG_AUTO; | ||
3934 | + spin_lock_irq(&tmr->lock); | ||
3935 | tmr->timeri = t; | ||
3936 | + spin_unlock_irq(&tmr->lock); | ||
3937 | return 0; | ||
3938 | } | ||
3939 | |||
3940 | int snd_seq_timer_close(struct snd_seq_queue *q) | ||
3941 | { | ||
3942 | struct snd_seq_timer *tmr; | ||
3943 | + struct snd_timer_instance *t; | ||
3944 | |||
3945 | tmr = q->timer; | ||
3946 | if (snd_BUG_ON(!tmr)) | ||
3947 | return -EINVAL; | ||
3948 | - if (tmr->timeri) { | ||
3949 | - snd_timer_stop(tmr->timeri); | ||
3950 | - snd_timer_close(tmr->timeri); | ||
3951 | - tmr->timeri = NULL; | ||
3952 | - } | ||
3953 | + spin_lock_irq(&tmr->lock); | ||
3954 | + t = tmr->timeri; | ||
3955 | + tmr->timeri = NULL; | ||
3956 | + spin_unlock_irq(&tmr->lock); | ||
3957 | + if (t) | ||
3958 | + snd_timer_close(t); | ||
3959 | return 0; | ||
3960 | } | ||
3961 | |||
3962 | -int snd_seq_timer_stop(struct snd_seq_timer * tmr) | ||
3963 | +static int seq_timer_stop(struct snd_seq_timer *tmr) | ||
3964 | { | ||
3965 | if (! tmr->timeri) | ||
3966 | return -EINVAL; | ||
3967 | @@ -326,6 +338,17 @@ int snd_seq_timer_stop(struct snd_seq_timer * tmr) | ||
3968 | return 0; | ||
3969 | } | ||
3970 | |||
3971 | +int snd_seq_timer_stop(struct snd_seq_timer *tmr) | ||
3972 | +{ | ||
3973 | + unsigned long flags; | ||
3974 | + int err; | ||
3975 | + | ||
3976 | + spin_lock_irqsave(&tmr->lock, flags); | ||
3977 | + err = seq_timer_stop(tmr); | ||
3978 | + spin_unlock_irqrestore(&tmr->lock, flags); | ||
3979 | + return err; | ||
3980 | +} | ||
3981 | + | ||
3982 | static int initialize_timer(struct snd_seq_timer *tmr) | ||
3983 | { | ||
3984 | struct snd_timer *t; | ||
3985 | @@ -358,13 +381,13 @@ static int initialize_timer(struct snd_seq_timer *tmr) | ||
3986 | return 0; | ||
3987 | } | ||
3988 | |||
3989 | -int snd_seq_timer_start(struct snd_seq_timer * tmr) | ||
3990 | +static int seq_timer_start(struct snd_seq_timer *tmr) | ||
3991 | { | ||
3992 | if (! tmr->timeri) | ||
3993 | return -EINVAL; | ||
3994 | if (tmr->running) | ||
3995 | - snd_seq_timer_stop(tmr); | ||
3996 | - snd_seq_timer_reset(tmr); | ||
3997 | + seq_timer_stop(tmr); | ||
3998 | + seq_timer_reset(tmr); | ||
3999 | if (initialize_timer(tmr) < 0) | ||
4000 | return -EINVAL; | ||
4001 | snd_timer_start(tmr->timeri, tmr->ticks); | ||
4002 | @@ -373,14 +396,25 @@ int snd_seq_timer_start(struct snd_seq_timer * tmr) | ||
4003 | return 0; | ||
4004 | } | ||
4005 | |||
4006 | -int snd_seq_timer_continue(struct snd_seq_timer * tmr) | ||
4007 | +int snd_seq_timer_start(struct snd_seq_timer *tmr) | ||
4008 | +{ | ||
4009 | + unsigned long flags; | ||
4010 | + int err; | ||
4011 | + | ||
4012 | + spin_lock_irqsave(&tmr->lock, flags); | ||
4013 | + err = seq_timer_start(tmr); | ||
4014 | + spin_unlock_irqrestore(&tmr->lock, flags); | ||
4015 | + return err; | ||
4016 | +} | ||
4017 | + | ||
4018 | +static int seq_timer_continue(struct snd_seq_timer *tmr) | ||
4019 | { | ||
4020 | if (! tmr->timeri) | ||
4021 | return -EINVAL; | ||
4022 | if (tmr->running) | ||
4023 | return -EBUSY; | ||
4024 | if (! tmr->initialized) { | ||
4025 | - snd_seq_timer_reset(tmr); | ||
4026 | + seq_timer_reset(tmr); | ||
4027 | if (initialize_timer(tmr) < 0) | ||
4028 | return -EINVAL; | ||
4029 | } | ||
4030 | @@ -390,11 +424,24 @@ int snd_seq_timer_continue(struct snd_seq_timer * tmr) | ||
4031 | return 0; | ||
4032 | } | ||
4033 | |||
4034 | +int snd_seq_timer_continue(struct snd_seq_timer *tmr) | ||
4035 | +{ | ||
4036 | + unsigned long flags; | ||
4037 | + int err; | ||
4038 | + | ||
4039 | + spin_lock_irqsave(&tmr->lock, flags); | ||
4040 | + err = seq_timer_continue(tmr); | ||
4041 | + spin_unlock_irqrestore(&tmr->lock, flags); | ||
4042 | + return err; | ||
4043 | +} | ||
4044 | + | ||
4045 | /* return current 'real' time. use timeofday() to get better granularity. */ | ||
4046 | snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr) | ||
4047 | { | ||
4048 | snd_seq_real_time_t cur_time; | ||
4049 | + unsigned long flags; | ||
4050 | |||
4051 | + spin_lock_irqsave(&tmr->lock, flags); | ||
4052 | cur_time = tmr->cur_time; | ||
4053 | if (tmr->running) { | ||
4054 | struct timeval tm; | ||
4055 | @@ -410,7 +457,7 @@ snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr) | ||
4056 | } | ||
4057 | snd_seq_sanity_real_time(&cur_time); | ||
4058 | } | ||
4059 | - | ||
4060 | + spin_unlock_irqrestore(&tmr->lock, flags); | ||
4061 | return cur_time; | ||
4062 | } | ||
4063 | |||
4064 | diff --git a/sound/core/seq/seq_virmidi.c b/sound/core/seq/seq_virmidi.c | ||
4065 | index 56e0f4cd3f82..81134e067184 100644 | ||
4066 | --- a/sound/core/seq/seq_virmidi.c | ||
4067 | +++ b/sound/core/seq/seq_virmidi.c | ||
4068 | @@ -155,21 +155,26 @@ static void snd_virmidi_output_trigger(struct snd_rawmidi_substream *substream, | ||
4069 | struct snd_virmidi *vmidi = substream->runtime->private_data; | ||
4070 | int count, res; | ||
4071 | unsigned char buf[32], *pbuf; | ||
4072 | + unsigned long flags; | ||
4073 | |||
4074 | if (up) { | ||
4075 | vmidi->trigger = 1; | ||
4076 | if (vmidi->seq_mode == SNDRV_VIRMIDI_SEQ_DISPATCH && | ||
4077 | !(vmidi->rdev->flags & SNDRV_VIRMIDI_SUBSCRIBE)) { | ||
4078 | - snd_rawmidi_transmit_ack(substream, substream->runtime->buffer_size - substream->runtime->avail); | ||
4079 | - return; /* ignored */ | ||
4080 | + while (snd_rawmidi_transmit(substream, buf, | ||
4081 | + sizeof(buf)) > 0) { | ||
4082 | + /* ignored */ | ||
4083 | + } | ||
4084 | + return; | ||
4085 | } | ||
4086 | if (vmidi->event.type != SNDRV_SEQ_EVENT_NONE) { | ||
4087 | if (snd_seq_kernel_client_dispatch(vmidi->client, &vmidi->event, in_atomic(), 0) < 0) | ||
4088 | return; | ||
4089 | vmidi->event.type = SNDRV_SEQ_EVENT_NONE; | ||
4090 | } | ||
4091 | + spin_lock_irqsave(&substream->runtime->lock, flags); | ||
4092 | while (1) { | ||
4093 | - count = snd_rawmidi_transmit_peek(substream, buf, sizeof(buf)); | ||
4094 | + count = __snd_rawmidi_transmit_peek(substream, buf, sizeof(buf)); | ||
4095 | if (count <= 0) | ||
4096 | break; | ||
4097 | pbuf = buf; | ||
4098 | @@ -179,16 +184,18 @@ static void snd_virmidi_output_trigger(struct snd_rawmidi_substream *substream, | ||
4099 | snd_midi_event_reset_encode(vmidi->parser); | ||
4100 | continue; | ||
4101 | } | ||
4102 | - snd_rawmidi_transmit_ack(substream, res); | ||
4103 | + __snd_rawmidi_transmit_ack(substream, res); | ||
4104 | pbuf += res; | ||
4105 | count -= res; | ||
4106 | if (vmidi->event.type != SNDRV_SEQ_EVENT_NONE) { | ||
4107 | if (snd_seq_kernel_client_dispatch(vmidi->client, &vmidi->event, in_atomic(), 0) < 0) | ||
4108 | - return; | ||
4109 | + goto out; | ||
4110 | vmidi->event.type = SNDRV_SEQ_EVENT_NONE; | ||
4111 | } | ||
4112 | } | ||
4113 | } | ||
4114 | + out: | ||
4115 | + spin_unlock_irqrestore(&substream->runtime->lock, flags); | ||
4116 | } else { | ||
4117 | vmidi->trigger = 0; | ||
4118 | } | ||
4119 | @@ -254,9 +261,13 @@ static int snd_virmidi_output_open(struct snd_rawmidi_substream *substream) | ||
4120 | */ | ||
4121 | static int snd_virmidi_input_close(struct snd_rawmidi_substream *substream) | ||
4122 | { | ||
4123 | + struct snd_virmidi_dev *rdev = substream->rmidi->private_data; | ||
4124 | struct snd_virmidi *vmidi = substream->runtime->private_data; | ||
4125 | - snd_midi_event_free(vmidi->parser); | ||
4126 | + | ||
4127 | + write_lock_irq(&rdev->filelist_lock); | ||
4128 | list_del(&vmidi->list); | ||
4129 | + write_unlock_irq(&rdev->filelist_lock); | ||
4130 | + snd_midi_event_free(vmidi->parser); | ||
4131 | substream->runtime->private_data = NULL; | ||
4132 | kfree(vmidi); | ||
4133 | return 0; | ||
4134 | diff --git a/sound/core/timer.c b/sound/core/timer.c | ||
4135 | index 0a049c4578f1..f24c9fccf008 100644 | ||
4136 | --- a/sound/core/timer.c | ||
4137 | +++ b/sound/core/timer.c | ||
4138 | @@ -305,8 +305,7 @@ int snd_timer_open(struct snd_timer_instance **ti, | ||
4139 | return 0; | ||
4140 | } | ||
4141 | |||
4142 | -static int _snd_timer_stop(struct snd_timer_instance *timeri, | ||
4143 | - int keep_flag, int event); | ||
4144 | +static int _snd_timer_stop(struct snd_timer_instance *timeri, int event); | ||
4145 | |||
4146 | /* | ||
4147 | * close a timer instance | ||
4148 | @@ -348,7 +347,7 @@ int snd_timer_close(struct snd_timer_instance *timeri) | ||
4149 | spin_unlock_irq(&timer->lock); | ||
4150 | mutex_lock(®ister_mutex); | ||
4151 | list_del(&timeri->open_list); | ||
4152 | - if (timer && list_empty(&timer->open_list_head) && | ||
4153 | + if (list_empty(&timer->open_list_head) && | ||
4154 | timer->hw.close) | ||
4155 | timer->hw.close(timer); | ||
4156 | /* remove slave links */ | ||
4157 | @@ -423,7 +422,7 @@ static void snd_timer_notify1(struct snd_timer_instance *ti, int event) | ||
4158 | spin_lock_irqsave(&timer->lock, flags); | ||
4159 | list_for_each_entry(ts, &ti->slave_active_head, active_list) | ||
4160 | if (ts->ccallback) | ||
4161 | - ts->ccallback(ti, event + 100, &tstamp, resolution); | ||
4162 | + ts->ccallback(ts, event + 100, &tstamp, resolution); | ||
4163 | spin_unlock_irqrestore(&timer->lock, flags); | ||
4164 | } | ||
4165 | |||
4166 | @@ -452,6 +451,10 @@ static int snd_timer_start_slave(struct snd_timer_instance *timeri) | ||
4167 | unsigned long flags; | ||
4168 | |||
4169 | spin_lock_irqsave(&slave_active_lock, flags); | ||
4170 | + if (timeri->flags & SNDRV_TIMER_IFLG_RUNNING) { | ||
4171 | + spin_unlock_irqrestore(&slave_active_lock, flags); | ||
4172 | + return -EBUSY; | ||
4173 | + } | ||
4174 | timeri->flags |= SNDRV_TIMER_IFLG_RUNNING; | ||
4175 | if (timeri->master && timeri->timer) { | ||
4176 | spin_lock(&timeri->timer->lock); | ||
4177 | @@ -476,7 +479,8 @@ int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks) | ||
4178 | return -EINVAL; | ||
4179 | if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) { | ||
4180 | result = snd_timer_start_slave(timeri); | ||
4181 | - snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_START); | ||
4182 | + if (result >= 0) | ||
4183 | + snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_START); | ||
4184 | return result; | ||
4185 | } | ||
4186 | timer = timeri->timer; | ||
4187 | @@ -485,16 +489,22 @@ int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks) | ||
4188 | if (timer->card && timer->card->shutdown) | ||
4189 | return -ENODEV; | ||
4190 | spin_lock_irqsave(&timer->lock, flags); | ||
4191 | + if (timeri->flags & (SNDRV_TIMER_IFLG_RUNNING | | ||
4192 | + SNDRV_TIMER_IFLG_START)) { | ||
4193 | + result = -EBUSY; | ||
4194 | + goto unlock; | ||
4195 | + } | ||
4196 | timeri->ticks = timeri->cticks = ticks; | ||
4197 | timeri->pticks = 0; | ||
4198 | result = snd_timer_start1(timer, timeri, ticks); | ||
4199 | + unlock: | ||
4200 | spin_unlock_irqrestore(&timer->lock, flags); | ||
4201 | - snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_START); | ||
4202 | + if (result >= 0) | ||
4203 | + snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_START); | ||
4204 | return result; | ||
4205 | } | ||
4206 | |||
4207 | -static int _snd_timer_stop(struct snd_timer_instance * timeri, | ||
4208 | - int keep_flag, int event) | ||
4209 | +static int _snd_timer_stop(struct snd_timer_instance *timeri, int event) | ||
4210 | { | ||
4211 | struct snd_timer *timer; | ||
4212 | unsigned long flags; | ||
4213 | @@ -503,19 +513,30 @@ static int _snd_timer_stop(struct snd_timer_instance * timeri, | ||
4214 | return -ENXIO; | ||
4215 | |||
4216 | if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) { | ||
4217 | - if (!keep_flag) { | ||
4218 | - spin_lock_irqsave(&slave_active_lock, flags); | ||
4219 | - timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING; | ||
4220 | - list_del_init(&timeri->ack_list); | ||
4221 | - list_del_init(&timeri->active_list); | ||
4222 | + spin_lock_irqsave(&slave_active_lock, flags); | ||
4223 | + if (!(timeri->flags & SNDRV_TIMER_IFLG_RUNNING)) { | ||
4224 | spin_unlock_irqrestore(&slave_active_lock, flags); | ||
4225 | + return -EBUSY; | ||
4226 | } | ||
4227 | + if (timeri->timer) | ||
4228 | + spin_lock(&timeri->timer->lock); | ||
4229 | + timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING; | ||
4230 | + list_del_init(&timeri->ack_list); | ||
4231 | + list_del_init(&timeri->active_list); | ||
4232 | + if (timeri->timer) | ||
4233 | + spin_unlock(&timeri->timer->lock); | ||
4234 | + spin_unlock_irqrestore(&slave_active_lock, flags); | ||
4235 | goto __end; | ||
4236 | } | ||
4237 | timer = timeri->timer; | ||
4238 | if (!timer) | ||
4239 | return -EINVAL; | ||
4240 | spin_lock_irqsave(&timer->lock, flags); | ||
4241 | + if (!(timeri->flags & (SNDRV_TIMER_IFLG_RUNNING | | ||
4242 | + SNDRV_TIMER_IFLG_START))) { | ||
4243 | + spin_unlock_irqrestore(&timer->lock, flags); | ||
4244 | + return -EBUSY; | ||
4245 | + } | ||
4246 | list_del_init(&timeri->ack_list); | ||
4247 | list_del_init(&timeri->active_list); | ||
4248 | if (timer->card && timer->card->shutdown) { | ||
4249 | @@ -534,9 +555,7 @@ static int _snd_timer_stop(struct snd_timer_instance * timeri, | ||
4250 | } | ||
4251 | } | ||
4252 | } | ||
4253 | - if (!keep_flag) | ||
4254 | - timeri->flags &= | ||
4255 | - ~(SNDRV_TIMER_IFLG_RUNNING | SNDRV_TIMER_IFLG_START); | ||
4256 | + timeri->flags &= ~(SNDRV_TIMER_IFLG_RUNNING | SNDRV_TIMER_IFLG_START); | ||
4257 | spin_unlock_irqrestore(&timer->lock, flags); | ||
4258 | __end: | ||
4259 | if (event != SNDRV_TIMER_EVENT_RESOLUTION) | ||
4260 | @@ -555,7 +574,7 @@ int snd_timer_stop(struct snd_timer_instance *timeri) | ||
4261 | unsigned long flags; | ||
4262 | int err; | ||
4263 | |||
4264 | - err = _snd_timer_stop(timeri, 0, SNDRV_TIMER_EVENT_STOP); | ||
4265 | + err = _snd_timer_stop(timeri, SNDRV_TIMER_EVENT_STOP); | ||
4266 | if (err < 0) | ||
4267 | return err; | ||
4268 | timer = timeri->timer; | ||
4269 | @@ -587,10 +606,15 @@ int snd_timer_continue(struct snd_timer_instance *timeri) | ||
4270 | if (timer->card && timer->card->shutdown) | ||
4271 | return -ENODEV; | ||
4272 | spin_lock_irqsave(&timer->lock, flags); | ||
4273 | + if (timeri->flags & SNDRV_TIMER_IFLG_RUNNING) { | ||
4274 | + result = -EBUSY; | ||
4275 | + goto unlock; | ||
4276 | + } | ||
4277 | if (!timeri->cticks) | ||
4278 | timeri->cticks = 1; | ||
4279 | timeri->pticks = 0; | ||
4280 | result = snd_timer_start1(timer, timeri, timer->sticks); | ||
4281 | + unlock: | ||
4282 | spin_unlock_irqrestore(&timer->lock, flags); | ||
4283 | snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_CONTINUE); | ||
4284 | return result; | ||
4285 | @@ -601,7 +625,7 @@ int snd_timer_continue(struct snd_timer_instance *timeri) | ||
4286 | */ | ||
4287 | int snd_timer_pause(struct snd_timer_instance * timeri) | ||
4288 | { | ||
4289 | - return _snd_timer_stop(timeri, 0, SNDRV_TIMER_EVENT_PAUSE); | ||
4290 | + return _snd_timer_stop(timeri, SNDRV_TIMER_EVENT_PAUSE); | ||
4291 | } | ||
4292 | |||
4293 | /* | ||
4294 | @@ -724,8 +748,8 @@ void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left) | ||
4295 | ti->cticks = ti->ticks; | ||
4296 | } else { | ||
4297 | ti->flags &= ~SNDRV_TIMER_IFLG_RUNNING; | ||
4298 | - if (--timer->running) | ||
4299 | - list_del_init(&ti->active_list); | ||
4300 | + --timer->running; | ||
4301 | + list_del_init(&ti->active_list); | ||
4302 | } | ||
4303 | if ((timer->hw.flags & SNDRV_TIMER_HW_TASKLET) || | ||
4304 | (ti->flags & SNDRV_TIMER_IFLG_FAST)) | ||
4305 | @@ -1900,6 +1924,7 @@ static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, | ||
4306 | { | ||
4307 | struct snd_timer_user *tu; | ||
4308 | long result = 0, unit; | ||
4309 | + int qhead; | ||
4310 | int err = 0; | ||
4311 | |||
4312 | tu = file->private_data; | ||
4313 | @@ -1911,7 +1936,7 @@ static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, | ||
4314 | |||
4315 | if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { | ||
4316 | err = -EAGAIN; | ||
4317 | - break; | ||
4318 | + goto _error; | ||
4319 | } | ||
4320 | |||
4321 | set_current_state(TASK_INTERRUPTIBLE); | ||
4322 | @@ -1926,42 +1951,37 @@ static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, | ||
4323 | |||
4324 | if (tu->disconnected) { | ||
4325 | err = -ENODEV; | ||
4326 | - break; | ||
4327 | + goto _error; | ||
4328 | } | ||
4329 | if (signal_pending(current)) { | ||
4330 | err = -ERESTARTSYS; | ||
4331 | - break; | ||
4332 | + goto _error; | ||
4333 | } | ||
4334 | } | ||
4335 | |||
4336 | + qhead = tu->qhead++; | ||
4337 | + tu->qhead %= tu->queue_size; | ||
4338 | spin_unlock_irq(&tu->qlock); | ||
4339 | - if (err < 0) | ||
4340 | - goto _error; | ||
4341 | |||
4342 | if (tu->tread) { | ||
4343 | - if (copy_to_user(buffer, &tu->tqueue[tu->qhead++], | ||
4344 | - sizeof(struct snd_timer_tread))) { | ||
4345 | + if (copy_to_user(buffer, &tu->tqueue[qhead], | ||
4346 | + sizeof(struct snd_timer_tread))) | ||
4347 | err = -EFAULT; | ||
4348 | - goto _error; | ||
4349 | - } | ||
4350 | } else { | ||
4351 | - if (copy_to_user(buffer, &tu->queue[tu->qhead++], | ||
4352 | - sizeof(struct snd_timer_read))) { | ||
4353 | + if (copy_to_user(buffer, &tu->queue[qhead], | ||
4354 | + sizeof(struct snd_timer_read))) | ||
4355 | err = -EFAULT; | ||
4356 | - goto _error; | ||
4357 | - } | ||
4358 | } | ||
4359 | |||
4360 | - tu->qhead %= tu->queue_size; | ||
4361 | - | ||
4362 | - result += unit; | ||
4363 | - buffer += unit; | ||
4364 | - | ||
4365 | spin_lock_irq(&tu->qlock); | ||
4366 | tu->qused--; | ||
4367 | + if (err < 0) | ||
4368 | + goto _error; | ||
4369 | + result += unit; | ||
4370 | + buffer += unit; | ||
4371 | } | ||
4372 | - spin_unlock_irq(&tu->qlock); | ||
4373 | _error: | ||
4374 | + spin_unlock_irq(&tu->qlock); | ||
4375 | return result > 0 ? result : err; | ||
4376 | } | ||
4377 | |||
4378 | diff --git a/sound/drivers/dummy.c b/sound/drivers/dummy.c | ||
4379 | index 016e451ed506..a9f7a75702d2 100644 | ||
4380 | --- a/sound/drivers/dummy.c | ||
4381 | +++ b/sound/drivers/dummy.c | ||
4382 | @@ -109,6 +109,9 @@ struct dummy_timer_ops { | ||
4383 | snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *); | ||
4384 | }; | ||
4385 | |||
4386 | +#define get_dummy_ops(substream) \ | ||
4387 | + (*(const struct dummy_timer_ops **)(substream)->runtime->private_data) | ||
4388 | + | ||
4389 | struct dummy_model { | ||
4390 | const char *name; | ||
4391 | int (*playback_constraints)(struct snd_pcm_runtime *runtime); | ||
4392 | @@ -137,7 +140,6 @@ struct snd_dummy { | ||
4393 | int iobox; | ||
4394 | struct snd_kcontrol *cd_volume_ctl; | ||
4395 | struct snd_kcontrol *cd_switch_ctl; | ||
4396 | - const struct dummy_timer_ops *timer_ops; | ||
4397 | }; | ||
4398 | |||
4399 | /* | ||
4400 | @@ -231,6 +233,8 @@ static struct dummy_model *dummy_models[] = { | ||
4401 | */ | ||
4402 | |||
4403 | struct dummy_systimer_pcm { | ||
4404 | + /* ops must be the first item */ | ||
4405 | + const struct dummy_timer_ops *timer_ops; | ||
4406 | spinlock_t lock; | ||
4407 | struct timer_list timer; | ||
4408 | unsigned long base_time; | ||
4409 | @@ -366,6 +370,8 @@ static struct dummy_timer_ops dummy_systimer_ops = { | ||
4410 | */ | ||
4411 | |||
4412 | struct dummy_hrtimer_pcm { | ||
4413 | + /* ops must be the first item */ | ||
4414 | + const struct dummy_timer_ops *timer_ops; | ||
4415 | ktime_t base_time; | ||
4416 | ktime_t period_time; | ||
4417 | atomic_t running; | ||
4418 | @@ -492,31 +498,25 @@ static struct dummy_timer_ops dummy_hrtimer_ops = { | ||
4419 | |||
4420 | static int dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd) | ||
4421 | { | ||
4422 | - struct snd_dummy *dummy = snd_pcm_substream_chip(substream); | ||
4423 | - | ||
4424 | switch (cmd) { | ||
4425 | case SNDRV_PCM_TRIGGER_START: | ||
4426 | case SNDRV_PCM_TRIGGER_RESUME: | ||
4427 | - return dummy->timer_ops->start(substream); | ||
4428 | + return get_dummy_ops(substream)->start(substream); | ||
4429 | case SNDRV_PCM_TRIGGER_STOP: | ||
4430 | case SNDRV_PCM_TRIGGER_SUSPEND: | ||
4431 | - return dummy->timer_ops->stop(substream); | ||
4432 | + return get_dummy_ops(substream)->stop(substream); | ||
4433 | } | ||
4434 | return -EINVAL; | ||
4435 | } | ||
4436 | |||
4437 | static int dummy_pcm_prepare(struct snd_pcm_substream *substream) | ||
4438 | { | ||
4439 | - struct snd_dummy *dummy = snd_pcm_substream_chip(substream); | ||
4440 | - | ||
4441 | - return dummy->timer_ops->prepare(substream); | ||
4442 | + return get_dummy_ops(substream)->prepare(substream); | ||
4443 | } | ||
4444 | |||
4445 | static snd_pcm_uframes_t dummy_pcm_pointer(struct snd_pcm_substream *substream) | ||
4446 | { | ||
4447 | - struct snd_dummy *dummy = snd_pcm_substream_chip(substream); | ||
4448 | - | ||
4449 | - return dummy->timer_ops->pointer(substream); | ||
4450 | + return get_dummy_ops(substream)->pointer(substream); | ||
4451 | } | ||
4452 | |||
4453 | static struct snd_pcm_hardware dummy_pcm_hardware = { | ||
4454 | @@ -562,17 +562,19 @@ static int dummy_pcm_open(struct snd_pcm_substream *substream) | ||
4455 | struct snd_dummy *dummy = snd_pcm_substream_chip(substream); | ||
4456 | struct dummy_model *model = dummy->model; | ||
4457 | struct snd_pcm_runtime *runtime = substream->runtime; | ||
4458 | + const struct dummy_timer_ops *ops; | ||
4459 | int err; | ||
4460 | |||
4461 | - dummy->timer_ops = &dummy_systimer_ops; | ||
4462 | + ops = &dummy_systimer_ops; | ||
4463 | #ifdef CONFIG_HIGH_RES_TIMERS | ||
4464 | if (hrtimer) | ||
4465 | - dummy->timer_ops = &dummy_hrtimer_ops; | ||
4466 | + ops = &dummy_hrtimer_ops; | ||
4467 | #endif | ||
4468 | |||
4469 | - err = dummy->timer_ops->create(substream); | ||
4470 | + err = ops->create(substream); | ||
4471 | if (err < 0) | ||
4472 | return err; | ||
4473 | + get_dummy_ops(substream) = ops; | ||
4474 | |||
4475 | runtime->hw = dummy->pcm_hw; | ||
4476 | if (substream->pcm->device & 1) { | ||
4477 | @@ -594,7 +596,7 @@ static int dummy_pcm_open(struct snd_pcm_substream *substream) | ||
4478 | err = model->capture_constraints(substream->runtime); | ||
4479 | } | ||
4480 | if (err < 0) { | ||
4481 | - dummy->timer_ops->free(substream); | ||
4482 | + get_dummy_ops(substream)->free(substream); | ||
4483 | return err; | ||
4484 | } | ||
4485 | return 0; | ||
4486 | @@ -602,8 +604,7 @@ static int dummy_pcm_open(struct snd_pcm_substream *substream) | ||
4487 | |||
4488 | static int dummy_pcm_close(struct snd_pcm_substream *substream) | ||
4489 | { | ||
4490 | - struct snd_dummy *dummy = snd_pcm_substream_chip(substream); | ||
4491 | - dummy->timer_ops->free(substream); | ||
4492 | + get_dummy_ops(substream)->free(substream); | ||
4493 | return 0; | ||
4494 | } | ||
4495 | |||
4496 | diff --git a/sound/firewire/bebob/bebob_stream.c b/sound/firewire/bebob/bebob_stream.c | ||
4497 | index 926e5dcbb66a..5022c9b97ddf 100644 | ||
4498 | --- a/sound/firewire/bebob/bebob_stream.c | ||
4499 | +++ b/sound/firewire/bebob/bebob_stream.c | ||
4500 | @@ -47,14 +47,16 @@ static const unsigned int bridgeco_freq_table[] = { | ||
4501 | [6] = 0x07, | ||
4502 | }; | ||
4503 | |||
4504 | -static unsigned int | ||
4505 | -get_formation_index(unsigned int rate) | ||
4506 | +static int | ||
4507 | +get_formation_index(unsigned int rate, unsigned int *index) | ||
4508 | { | ||
4509 | unsigned int i; | ||
4510 | |||
4511 | for (i = 0; i < ARRAY_SIZE(snd_bebob_rate_table); i++) { | ||
4512 | - if (snd_bebob_rate_table[i] == rate) | ||
4513 | - return i; | ||
4514 | + if (snd_bebob_rate_table[i] == rate) { | ||
4515 | + *index = i; | ||
4516 | + return 0; | ||
4517 | + } | ||
4518 | } | ||
4519 | return -EINVAL; | ||
4520 | } | ||
4521 | @@ -425,7 +427,9 @@ make_both_connections(struct snd_bebob *bebob, unsigned int rate) | ||
4522 | goto end; | ||
4523 | |||
4524 | /* confirm params for both streams */ | ||
4525 | - index = get_formation_index(rate); | ||
4526 | + err = get_formation_index(rate, &index); | ||
4527 | + if (err < 0) | ||
4528 | + goto end; | ||
4529 | pcm_channels = bebob->tx_stream_formations[index].pcm; | ||
4530 | midi_channels = bebob->tx_stream_formations[index].midi; | ||
4531 | err = amdtp_am824_set_parameters(&bebob->tx_stream, rate, | ||
4532 | diff --git a/sound/isa/Kconfig b/sound/isa/Kconfig | ||
4533 | index 0216475fc759..37adcc6cbe6b 100644 | ||
4534 | --- a/sound/isa/Kconfig | ||
4535 | +++ b/sound/isa/Kconfig | ||
4536 | @@ -3,6 +3,7 @@ | ||
4537 | config SND_WSS_LIB | ||
4538 | tristate | ||
4539 | select SND_PCM | ||
4540 | + select SND_TIMER | ||
4541 | |||
4542 | config SND_SB_COMMON | ||
4543 | tristate | ||
4544 | @@ -42,6 +43,7 @@ config SND_AD1816A | ||
4545 | select SND_OPL3_LIB | ||
4546 | select SND_MPU401_UART | ||
4547 | select SND_PCM | ||
4548 | + select SND_TIMER | ||
4549 | help | ||
4550 | Say Y here to include support for Analog Devices SoundPort | ||
4551 | AD1816A or compatible sound chips. | ||
4552 | @@ -209,6 +211,7 @@ config SND_GUSCLASSIC | ||
4553 | tristate "Gravis UltraSound Classic" | ||
4554 | select SND_RAWMIDI | ||
4555 | select SND_PCM | ||
4556 | + select SND_TIMER | ||
4557 | help | ||
4558 | Say Y here to include support for Gravis UltraSound Classic | ||
4559 | soundcards. | ||
4560 | @@ -221,6 +224,7 @@ config SND_GUSEXTREME | ||
4561 | select SND_OPL3_LIB | ||
4562 | select SND_MPU401_UART | ||
4563 | select SND_PCM | ||
4564 | + select SND_TIMER | ||
4565 | help | ||
4566 | Say Y here to include support for Gravis UltraSound Extreme | ||
4567 | soundcards. | ||
4568 | diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig | ||
4569 | index 656ce39bddbc..8f6594a7d37f 100644 | ||
4570 | --- a/sound/pci/Kconfig | ||
4571 | +++ b/sound/pci/Kconfig | ||
4572 | @@ -155,6 +155,7 @@ config SND_AZT3328 | ||
4573 | select SND_PCM | ||
4574 | select SND_RAWMIDI | ||
4575 | select SND_AC97_CODEC | ||
4576 | + select SND_TIMER | ||
4577 | depends on ZONE_DMA | ||
4578 | help | ||
4579 | Say Y here to include support for Aztech AZF3328 (PCI168) | ||
4580 | @@ -463,6 +464,7 @@ config SND_EMU10K1 | ||
4581 | select SND_HWDEP | ||
4582 | select SND_RAWMIDI | ||
4583 | select SND_AC97_CODEC | ||
4584 | + select SND_TIMER | ||
4585 | depends on ZONE_DMA | ||
4586 | help | ||
4587 | Say Y to include support for Sound Blaster PCI 512, Live!, | ||
4588 | @@ -889,6 +891,7 @@ config SND_YMFPCI | ||
4589 | select SND_OPL3_LIB | ||
4590 | select SND_MPU401_UART | ||
4591 | select SND_AC97_CODEC | ||
4592 | + select SND_TIMER | ||
4593 | help | ||
4594 | Say Y here to include support for Yamaha PCI audio chips - | ||
4595 | YMF724, YMF724F, YMF740, YMF740C, YMF744, YMF754. | ||
4596 | diff --git a/sound/pci/hda/hda_generic.c b/sound/pci/hda/hda_generic.c | ||
4597 | index c6e8a651cea1..5c4fa8eba1d0 100644 | ||
4598 | --- a/sound/pci/hda/hda_generic.c | ||
4599 | +++ b/sound/pci/hda/hda_generic.c | ||
4600 | @@ -771,9 +771,6 @@ static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir, | ||
4601 | unsigned int caps; | ||
4602 | unsigned int mask, val; | ||
4603 | |||
4604 | - if (!enable && is_active_nid(codec, nid, dir, idx_to_check)) | ||
4605 | - return; | ||
4606 | - | ||
4607 | caps = query_amp_caps(codec, nid, dir); | ||
4608 | val = get_amp_val_to_activate(codec, nid, dir, caps, enable); | ||
4609 | mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps); | ||
4610 | @@ -784,12 +781,22 @@ static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir, | ||
4611 | update_amp(codec, nid, dir, idx, mask, val); | ||
4612 | } | ||
4613 | |||
4614 | +static void check_and_activate_amp(struct hda_codec *codec, hda_nid_t nid, | ||
4615 | + int dir, int idx, int idx_to_check, | ||
4616 | + bool enable) | ||
4617 | +{ | ||
4618 | + /* check whether the given amp is still used by others */ | ||
4619 | + if (!enable && is_active_nid(codec, nid, dir, idx_to_check)) | ||
4620 | + return; | ||
4621 | + activate_amp(codec, nid, dir, idx, idx_to_check, enable); | ||
4622 | +} | ||
4623 | + | ||
4624 | static void activate_amp_out(struct hda_codec *codec, struct nid_path *path, | ||
4625 | int i, bool enable) | ||
4626 | { | ||
4627 | hda_nid_t nid = path->path[i]; | ||
4628 | init_amp(codec, nid, HDA_OUTPUT, 0); | ||
4629 | - activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable); | ||
4630 | + check_and_activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable); | ||
4631 | } | ||
4632 | |||
4633 | static void activate_amp_in(struct hda_codec *codec, struct nid_path *path, | ||
4634 | @@ -817,9 +824,16 @@ static void activate_amp_in(struct hda_codec *codec, struct nid_path *path, | ||
4635 | * when aa-mixer is available, we need to enable the path as well | ||
4636 | */ | ||
4637 | for (n = 0; n < nums; n++) { | ||
4638 | - if (n != idx && (!add_aamix || conn[n] != spec->mixer_merge_nid)) | ||
4639 | - continue; | ||
4640 | - activate_amp(codec, nid, HDA_INPUT, n, idx, enable); | ||
4641 | + if (n != idx) { | ||
4642 | + if (conn[n] != spec->mixer_merge_nid) | ||
4643 | + continue; | ||
4644 | + /* when aamix is disabled, force to off */ | ||
4645 | + if (!add_aamix) { | ||
4646 | + activate_amp(codec, nid, HDA_INPUT, n, n, false); | ||
4647 | + continue; | ||
4648 | + } | ||
4649 | + } | ||
4650 | + check_and_activate_amp(codec, nid, HDA_INPUT, n, idx, enable); | ||
4651 | } | ||
4652 | } | ||
4653 | |||
4654 | @@ -1580,6 +1594,12 @@ static bool map_singles(struct hda_codec *codec, int outs, | ||
4655 | return found; | ||
4656 | } | ||
4657 | |||
4658 | +static inline bool has_aamix_out_paths(struct hda_gen_spec *spec) | ||
4659 | +{ | ||
4660 | + return spec->aamix_out_paths[0] || spec->aamix_out_paths[1] || | ||
4661 | + spec->aamix_out_paths[2]; | ||
4662 | +} | ||
4663 | + | ||
4664 | /* create a new path including aamix if available, and return its index */ | ||
4665 | static int check_aamix_out_path(struct hda_codec *codec, int path_idx) | ||
4666 | { | ||
4667 | @@ -2422,25 +2442,51 @@ static void update_aamix_paths(struct hda_codec *codec, bool do_mix, | ||
4668 | } | ||
4669 | } | ||
4670 | |||
4671 | +/* re-initialize the output paths; only called from loopback_mixing_put() */ | ||
4672 | +static void update_output_paths(struct hda_codec *codec, int num_outs, | ||
4673 | + const int *paths) | ||
4674 | +{ | ||
4675 | + struct hda_gen_spec *spec = codec->spec; | ||
4676 | + struct nid_path *path; | ||
4677 | + int i; | ||
4678 | + | ||
4679 | + for (i = 0; i < num_outs; i++) { | ||
4680 | + path = snd_hda_get_path_from_idx(codec, paths[i]); | ||
4681 | + if (path) | ||
4682 | + snd_hda_activate_path(codec, path, path->active, | ||
4683 | + spec->aamix_mode); | ||
4684 | + } | ||
4685 | +} | ||
4686 | + | ||
4687 | static int loopback_mixing_put(struct snd_kcontrol *kcontrol, | ||
4688 | struct snd_ctl_elem_value *ucontrol) | ||
4689 | { | ||
4690 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
4691 | struct hda_gen_spec *spec = codec->spec; | ||
4692 | + const struct auto_pin_cfg *cfg = &spec->autocfg; | ||
4693 | unsigned int val = ucontrol->value.enumerated.item[0]; | ||
4694 | |||
4695 | if (val == spec->aamix_mode) | ||
4696 | return 0; | ||
4697 | spec->aamix_mode = val; | ||
4698 | - update_aamix_paths(codec, val, spec->out_paths[0], | ||
4699 | - spec->aamix_out_paths[0], | ||
4700 | - spec->autocfg.line_out_type); | ||
4701 | - update_aamix_paths(codec, val, spec->hp_paths[0], | ||
4702 | - spec->aamix_out_paths[1], | ||
4703 | - AUTO_PIN_HP_OUT); | ||
4704 | - update_aamix_paths(codec, val, spec->speaker_paths[0], | ||
4705 | - spec->aamix_out_paths[2], | ||
4706 | - AUTO_PIN_SPEAKER_OUT); | ||
4707 | + if (has_aamix_out_paths(spec)) { | ||
4708 | + update_aamix_paths(codec, val, spec->out_paths[0], | ||
4709 | + spec->aamix_out_paths[0], | ||
4710 | + cfg->line_out_type); | ||
4711 | + update_aamix_paths(codec, val, spec->hp_paths[0], | ||
4712 | + spec->aamix_out_paths[1], | ||
4713 | + AUTO_PIN_HP_OUT); | ||
4714 | + update_aamix_paths(codec, val, spec->speaker_paths[0], | ||
4715 | + spec->aamix_out_paths[2], | ||
4716 | + AUTO_PIN_SPEAKER_OUT); | ||
4717 | + } else { | ||
4718 | + update_output_paths(codec, cfg->line_outs, spec->out_paths); | ||
4719 | + if (cfg->line_out_type != AUTO_PIN_HP_OUT) | ||
4720 | + update_output_paths(codec, cfg->hp_outs, spec->hp_paths); | ||
4721 | + if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) | ||
4722 | + update_output_paths(codec, cfg->speaker_outs, | ||
4723 | + spec->speaker_paths); | ||
4724 | + } | ||
4725 | return 1; | ||
4726 | } | ||
4727 | |||
4728 | @@ -2458,12 +2504,13 @@ static int create_loopback_mixing_ctl(struct hda_codec *codec) | ||
4729 | |||
4730 | if (!spec->mixer_nid) | ||
4731 | return 0; | ||
4732 | - if (!(spec->aamix_out_paths[0] || spec->aamix_out_paths[1] || | ||
4733 | - spec->aamix_out_paths[2])) | ||
4734 | - return 0; | ||
4735 | if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum)) | ||
4736 | return -ENOMEM; | ||
4737 | spec->have_aamix_ctl = 1; | ||
4738 | + /* if no explicit aamix path is present (e.g. for Realtek codecs), | ||
4739 | + * enable aamix as default -- just for compatibility | ||
4740 | + */ | ||
4741 | + spec->aamix_mode = !has_aamix_out_paths(spec); | ||
4742 | return 0; | ||
4743 | } | ||
4744 | |||
4745 | @@ -3998,9 +4045,9 @@ static void pin_power_callback(struct hda_codec *codec, | ||
4746 | struct hda_jack_callback *jack, | ||
4747 | bool on) | ||
4748 | { | ||
4749 | - if (jack && jack->tbl->nid) | ||
4750 | + if (jack && jack->nid) | ||
4751 | sync_power_state_change(codec, | ||
4752 | - set_pin_power_jack(codec, jack->tbl->nid, on)); | ||
4753 | + set_pin_power_jack(codec, jack->nid, on)); | ||
4754 | } | ||
4755 | |||
4756 | /* callback only doing power up -- called at first */ | ||
4757 | @@ -5664,6 +5711,8 @@ static void init_aamix_paths(struct hda_codec *codec) | ||
4758 | |||
4759 | if (!spec->have_aamix_ctl) | ||
4760 | return; | ||
4761 | + if (!has_aamix_out_paths(spec)) | ||
4762 | + return; | ||
4763 | update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0], | ||
4764 | spec->aamix_out_paths[0], | ||
4765 | spec->autocfg.line_out_type); | ||
4766 | diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c | ||
4767 | index 614baff1f5d7..02a86ba5ba22 100644 | ||
4768 | --- a/sound/pci/hda/hda_intel.c | ||
4769 | +++ b/sound/pci/hda/hda_intel.c | ||
4770 | @@ -90,6 +90,8 @@ enum { | ||
4771 | #define NVIDIA_HDA_ENABLE_COHBIT 0x01 | ||
4772 | |||
4773 | /* Defines for Intel SCH HDA snoop control */ | ||
4774 | +#define INTEL_HDA_CGCTL 0x48 | ||
4775 | +#define INTEL_HDA_CGCTL_MISCBDCGE (0x1 << 6) | ||
4776 | #define INTEL_SCH_HDA_DEVC 0x78 | ||
4777 | #define INTEL_SCH_HDA_DEVC_NOSNOOP (0x1<<11) | ||
4778 | |||
4779 | @@ -528,10 +530,21 @@ static void hda_intel_init_chip(struct azx *chip, bool full_reset) | ||
4780 | { | ||
4781 | struct hdac_bus *bus = azx_bus(chip); | ||
4782 | struct pci_dev *pci = chip->pci; | ||
4783 | + u32 val; | ||
4784 | |||
4785 | if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) | ||
4786 | snd_hdac_set_codec_wakeup(bus, true); | ||
4787 | + if (IS_BROXTON(pci)) { | ||
4788 | + pci_read_config_dword(pci, INTEL_HDA_CGCTL, &val); | ||
4789 | + val = val & ~INTEL_HDA_CGCTL_MISCBDCGE; | ||
4790 | + pci_write_config_dword(pci, INTEL_HDA_CGCTL, val); | ||
4791 | + } | ||
4792 | azx_init_chip(chip, full_reset); | ||
4793 | + if (IS_BROXTON(pci)) { | ||
4794 | + pci_read_config_dword(pci, INTEL_HDA_CGCTL, &val); | ||
4795 | + val = val | INTEL_HDA_CGCTL_MISCBDCGE; | ||
4796 | + pci_write_config_dword(pci, INTEL_HDA_CGCTL, val); | ||
4797 | + } | ||
4798 | if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) | ||
4799 | snd_hdac_set_codec_wakeup(bus, false); | ||
4800 | |||
4801 | diff --git a/sound/pci/hda/hda_jack.c b/sound/pci/hda/hda_jack.c | ||
4802 | index c945e257d368..a33234e04d4f 100644 | ||
4803 | --- a/sound/pci/hda/hda_jack.c | ||
4804 | +++ b/sound/pci/hda/hda_jack.c | ||
4805 | @@ -259,7 +259,7 @@ snd_hda_jack_detect_enable_callback(struct hda_codec *codec, hda_nid_t nid, | ||
4806 | if (!callback) | ||
4807 | return ERR_PTR(-ENOMEM); | ||
4808 | callback->func = func; | ||
4809 | - callback->tbl = jack; | ||
4810 | + callback->nid = jack->nid; | ||
4811 | callback->next = jack->callback; | ||
4812 | jack->callback = callback; | ||
4813 | } | ||
4814 | diff --git a/sound/pci/hda/hda_jack.h b/sound/pci/hda/hda_jack.h | ||
4815 | index 858708a044f5..e9814c0168ea 100644 | ||
4816 | --- a/sound/pci/hda/hda_jack.h | ||
4817 | +++ b/sound/pci/hda/hda_jack.h | ||
4818 | @@ -21,7 +21,7 @@ struct hda_jack_callback; | ||
4819 | typedef void (*hda_jack_callback_fn) (struct hda_codec *, struct hda_jack_callback *); | ||
4820 | |||
4821 | struct hda_jack_callback { | ||
4822 | - struct hda_jack_tbl *tbl; | ||
4823 | + hda_nid_t nid; | ||
4824 | hda_jack_callback_fn func; | ||
4825 | unsigned int private_data; /* arbitrary data */ | ||
4826 | struct hda_jack_callback *next; | ||
4827 | diff --git a/sound/pci/hda/patch_ca0132.c b/sound/pci/hda/patch_ca0132.c | ||
4828 | index 4ef2259f88ca..9ceb2bc36e68 100644 | ||
4829 | --- a/sound/pci/hda/patch_ca0132.c | ||
4830 | +++ b/sound/pci/hda/patch_ca0132.c | ||
4831 | @@ -4427,13 +4427,16 @@ static void ca0132_process_dsp_response(struct hda_codec *codec, | ||
4832 | static void hp_callback(struct hda_codec *codec, struct hda_jack_callback *cb) | ||
4833 | { | ||
4834 | struct ca0132_spec *spec = codec->spec; | ||
4835 | + struct hda_jack_tbl *tbl; | ||
4836 | |||
4837 | /* Delay enabling the HP amp, to let the mic-detection | ||
4838 | * state machine run. | ||
4839 | */ | ||
4840 | cancel_delayed_work_sync(&spec->unsol_hp_work); | ||
4841 | schedule_delayed_work(&spec->unsol_hp_work, msecs_to_jiffies(500)); | ||
4842 | - cb->tbl->block_report = 1; | ||
4843 | + tbl = snd_hda_jack_tbl_get(codec, cb->nid); | ||
4844 | + if (tbl) | ||
4845 | + tbl->block_report = 1; | ||
4846 | } | ||
4847 | |||
4848 | static void amic_callback(struct hda_codec *codec, struct hda_jack_callback *cb) | ||
4849 | diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c | ||
4850 | index a12ae8ac0914..c1c855a6c0af 100644 | ||
4851 | --- a/sound/pci/hda/patch_cirrus.c | ||
4852 | +++ b/sound/pci/hda/patch_cirrus.c | ||
4853 | @@ -614,6 +614,7 @@ enum { | ||
4854 | CS4208_MAC_AUTO, | ||
4855 | CS4208_MBA6, | ||
4856 | CS4208_MBP11, | ||
4857 | + CS4208_MACMINI, | ||
4858 | CS4208_GPIO0, | ||
4859 | }; | ||
4860 | |||
4861 | @@ -621,6 +622,7 @@ static const struct hda_model_fixup cs4208_models[] = { | ||
4862 | { .id = CS4208_GPIO0, .name = "gpio0" }, | ||
4863 | { .id = CS4208_MBA6, .name = "mba6" }, | ||
4864 | { .id = CS4208_MBP11, .name = "mbp11" }, | ||
4865 | + { .id = CS4208_MACMINI, .name = "macmini" }, | ||
4866 | {} | ||
4867 | }; | ||
4868 | |||
4869 | @@ -632,6 +634,7 @@ static const struct snd_pci_quirk cs4208_fixup_tbl[] = { | ||
4870 | /* codec SSID matching */ | ||
4871 | static const struct snd_pci_quirk cs4208_mac_fixup_tbl[] = { | ||
4872 | SND_PCI_QUIRK(0x106b, 0x5e00, "MacBookPro 11,2", CS4208_MBP11), | ||
4873 | + SND_PCI_QUIRK(0x106b, 0x6c00, "MacMini 7,1", CS4208_MACMINI), | ||
4874 | SND_PCI_QUIRK(0x106b, 0x7100, "MacBookAir 6,1", CS4208_MBA6), | ||
4875 | SND_PCI_QUIRK(0x106b, 0x7200, "MacBookAir 6,2", CS4208_MBA6), | ||
4876 | SND_PCI_QUIRK(0x106b, 0x7b00, "MacBookPro 12,1", CS4208_MBP11), | ||
4877 | @@ -666,6 +669,24 @@ static void cs4208_fixup_mac(struct hda_codec *codec, | ||
4878 | snd_hda_apply_fixup(codec, action); | ||
4879 | } | ||
4880 | |||
4881 | +/* MacMini 7,1 has the inverted jack detection */ | ||
4882 | +static void cs4208_fixup_macmini(struct hda_codec *codec, | ||
4883 | + const struct hda_fixup *fix, int action) | ||
4884 | +{ | ||
4885 | + static const struct hda_pintbl pincfgs[] = { | ||
4886 | + { 0x18, 0x00ab9150 }, /* mic (audio-in) jack: disable detect */ | ||
4887 | + { 0x21, 0x004be140 }, /* SPDIF: disable detect */ | ||
4888 | + { } | ||
4889 | + }; | ||
4890 | + | ||
4891 | + if (action == HDA_FIXUP_ACT_PRE_PROBE) { | ||
4892 | + /* HP pin (0x10) has an inverted detection */ | ||
4893 | + codec->inv_jack_detect = 1; | ||
4894 | + /* disable the bogus Mic and SPDIF jack detections */ | ||
4895 | + snd_hda_apply_pincfgs(codec, pincfgs); | ||
4896 | + } | ||
4897 | +} | ||
4898 | + | ||
4899 | static int cs4208_spdif_sw_put(struct snd_kcontrol *kcontrol, | ||
4900 | struct snd_ctl_elem_value *ucontrol) | ||
4901 | { | ||
4902 | @@ -709,6 +730,12 @@ static const struct hda_fixup cs4208_fixups[] = { | ||
4903 | .chained = true, | ||
4904 | .chain_id = CS4208_GPIO0, | ||
4905 | }, | ||
4906 | + [CS4208_MACMINI] = { | ||
4907 | + .type = HDA_FIXUP_FUNC, | ||
4908 | + .v.func = cs4208_fixup_macmini, | ||
4909 | + .chained = true, | ||
4910 | + .chain_id = CS4208_GPIO0, | ||
4911 | + }, | ||
4912 | [CS4208_GPIO0] = { | ||
4913 | .type = HDA_FIXUP_FUNC, | ||
4914 | .v.func = cs4208_fixup_gpio0, | ||
4915 | diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c | ||
4916 | index 4b6fb668c91c..70c945603379 100644 | ||
4917 | --- a/sound/pci/hda/patch_hdmi.c | ||
4918 | +++ b/sound/pci/hda/patch_hdmi.c | ||
4919 | @@ -438,7 +438,8 @@ static int hdmi_eld_ctl_get(struct snd_kcontrol *kcontrol, | ||
4920 | eld = &per_pin->sink_eld; | ||
4921 | |||
4922 | mutex_lock(&per_pin->lock); | ||
4923 | - if (eld->eld_size > ARRAY_SIZE(ucontrol->value.bytes.data)) { | ||
4924 | + if (eld->eld_size > ARRAY_SIZE(ucontrol->value.bytes.data) || | ||
4925 | + eld->eld_size > ELD_MAX_SIZE) { | ||
4926 | mutex_unlock(&per_pin->lock); | ||
4927 | snd_BUG(); | ||
4928 | return -EINVAL; | ||
4929 | @@ -1183,7 +1184,7 @@ static void check_presence_and_report(struct hda_codec *codec, hda_nid_t nid) | ||
4930 | static void jack_callback(struct hda_codec *codec, | ||
4931 | struct hda_jack_callback *jack) | ||
4932 | { | ||
4933 | - check_presence_and_report(codec, jack->tbl->nid); | ||
4934 | + check_presence_and_report(codec, jack->nid); | ||
4935 | } | ||
4936 | |||
4937 | static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res) | ||
4938 | diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c | ||
4939 | index 33753244f48f..efd4980cffb8 100644 | ||
4940 | --- a/sound/pci/hda/patch_realtek.c | ||
4941 | +++ b/sound/pci/hda/patch_realtek.c | ||
4942 | @@ -282,7 +282,7 @@ static void alc_update_knob_master(struct hda_codec *codec, | ||
4943 | uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); | ||
4944 | if (!uctl) | ||
4945 | return; | ||
4946 | - val = snd_hda_codec_read(codec, jack->tbl->nid, 0, | ||
4947 | + val = snd_hda_codec_read(codec, jack->nid, 0, | ||
4948 | AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); | ||
4949 | val &= HDA_AMP_VOLMASK; | ||
4950 | uctl->value.integer.value[0] = val; | ||
4951 | @@ -327,6 +327,7 @@ static void alc_fill_eapd_coef(struct hda_codec *codec) | ||
4952 | case 0x10ec0292: | ||
4953 | alc_update_coef_idx(codec, 0x4, 1<<15, 0); | ||
4954 | break; | ||
4955 | + case 0x10ec0225: | ||
4956 | case 0x10ec0233: | ||
4957 | case 0x10ec0255: | ||
4958 | case 0x10ec0256: | ||
4959 | @@ -900,6 +901,7 @@ static struct alc_codec_rename_pci_table rename_pci_tbl[] = { | ||
4960 | { 0x10ec0899, 0x1028, 0, "ALC3861" }, | ||
4961 | { 0x10ec0298, 0x1028, 0, "ALC3266" }, | ||
4962 | { 0x10ec0256, 0x1028, 0, "ALC3246" }, | ||
4963 | + { 0x10ec0225, 0x1028, 0, "ALC3253" }, | ||
4964 | { 0x10ec0670, 0x1025, 0, "ALC669X" }, | ||
4965 | { 0x10ec0676, 0x1025, 0, "ALC679X" }, | ||
4966 | { 0x10ec0282, 0x1043, 0, "ALC3229" }, | ||
4967 | @@ -1785,7 +1787,6 @@ enum { | ||
4968 | ALC882_FIXUP_NO_PRIMARY_HP, | ||
4969 | ALC887_FIXUP_ASUS_BASS, | ||
4970 | ALC887_FIXUP_BASS_CHMAP, | ||
4971 | - ALC882_FIXUP_DISABLE_AAMIX, | ||
4972 | }; | ||
4973 | |||
4974 | static void alc889_fixup_coef(struct hda_codec *codec, | ||
4975 | @@ -1947,8 +1948,6 @@ static void alc882_fixup_no_primary_hp(struct hda_codec *codec, | ||
4976 | |||
4977 | static void alc_fixup_bass_chmap(struct hda_codec *codec, | ||
4978 | const struct hda_fixup *fix, int action); | ||
4979 | -static void alc_fixup_disable_aamix(struct hda_codec *codec, | ||
4980 | - const struct hda_fixup *fix, int action); | ||
4981 | |||
4982 | static const struct hda_fixup alc882_fixups[] = { | ||
4983 | [ALC882_FIXUP_ABIT_AW9D_MAX] = { | ||
4984 | @@ -2186,10 +2185,6 @@ static const struct hda_fixup alc882_fixups[] = { | ||
4985 | .type = HDA_FIXUP_FUNC, | ||
4986 | .v.func = alc_fixup_bass_chmap, | ||
4987 | }, | ||
4988 | - [ALC882_FIXUP_DISABLE_AAMIX] = { | ||
4989 | - .type = HDA_FIXUP_FUNC, | ||
4990 | - .v.func = alc_fixup_disable_aamix, | ||
4991 | - }, | ||
4992 | }; | ||
4993 | |||
4994 | static const struct snd_pci_quirk alc882_fixup_tbl[] = { | ||
4995 | @@ -2228,6 +2223,7 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { | ||
4996 | SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT), | ||
4997 | SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP), | ||
4998 | SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP), | ||
4999 | + SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP), | ||
5000 | |||
5001 | /* All Apple entries are in codec SSIDs */ | ||
5002 | SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF), | ||
5003 | @@ -2257,7 +2253,6 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { | ||
5004 | SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD), | ||
5005 | SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3), | ||
5006 | SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE), | ||
5007 | - SND_PCI_QUIRK(0x1458, 0xa182, "Gigabyte Z170X-UD3", ALC882_FIXUP_DISABLE_AAMIX), | ||
5008 | SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX), | ||
5009 | SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD), | ||
5010 | SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD), | ||
5011 | @@ -2651,6 +2646,7 @@ enum { | ||
5012 | ALC269_TYPE_ALC298, | ||
5013 | ALC269_TYPE_ALC255, | ||
5014 | ALC269_TYPE_ALC256, | ||
5015 | + ALC269_TYPE_ALC225, | ||
5016 | }; | ||
5017 | |||
5018 | /* | ||
5019 | @@ -2680,6 +2676,7 @@ static int alc269_parse_auto_config(struct hda_codec *codec) | ||
5020 | case ALC269_TYPE_ALC298: | ||
5021 | case ALC269_TYPE_ALC255: | ||
5022 | case ALC269_TYPE_ALC256: | ||
5023 | + case ALC269_TYPE_ALC225: | ||
5024 | ssids = alc269_ssids; | ||
5025 | break; | ||
5026 | default: | ||
5027 | @@ -3658,6 +3655,16 @@ static void alc_headset_mode_unplugged(struct hda_codec *codec) | ||
5028 | WRITE_COEF(0xb7, 0x802b), | ||
5029 | {} | ||
5030 | }; | ||
5031 | + static struct coef_fw coef0225[] = { | ||
5032 | + UPDATE_COEF(0x4a, 1<<8, 0), | ||
5033 | + UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), | ||
5034 | + UPDATE_COEF(0x63, 3<<14, 3<<14), | ||
5035 | + UPDATE_COEF(0x4a, 3<<4, 2<<4), | ||
5036 | + UPDATE_COEF(0x4a, 3<<10, 3<<10), | ||
5037 | + UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10), | ||
5038 | + UPDATE_COEF(0x4a, 3<<10, 0), | ||
5039 | + {} | ||
5040 | + }; | ||
5041 | |||
5042 | switch (codec->core.vendor_id) { | ||
5043 | case 0x10ec0255: | ||
5044 | @@ -3682,6 +3689,9 @@ static void alc_headset_mode_unplugged(struct hda_codec *codec) | ||
5045 | case 0x10ec0668: | ||
5046 | alc_process_coef_fw(codec, coef0668); | ||
5047 | break; | ||
5048 | + case 0x10ec0225: | ||
5049 | + alc_process_coef_fw(codec, coef0225); | ||
5050 | + break; | ||
5051 | } | ||
5052 | codec_dbg(codec, "Headset jack set to unplugged mode.\n"); | ||
5053 | } | ||
5054 | @@ -3727,6 +3737,13 @@ static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin, | ||
5055 | UPDATE_COEF(0xc3, 0, 1<<12), | ||
5056 | {} | ||
5057 | }; | ||
5058 | + static struct coef_fw coef0225[] = { | ||
5059 | + UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), | ||
5060 | + UPDATE_COEF(0x4a, 3<<4, 2<<4), | ||
5061 | + UPDATE_COEF(0x63, 3<<14, 0), | ||
5062 | + {} | ||
5063 | + }; | ||
5064 | + | ||
5065 | |||
5066 | switch (codec->core.vendor_id) { | ||
5067 | case 0x10ec0255: | ||
5068 | @@ -3772,6 +3789,12 @@ static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin, | ||
5069 | alc_process_coef_fw(codec, coef0688); | ||
5070 | snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); | ||
5071 | break; | ||
5072 | + case 0x10ec0225: | ||
5073 | + alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10); | ||
5074 | + snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); | ||
5075 | + alc_process_coef_fw(codec, coef0225); | ||
5076 | + snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); | ||
5077 | + break; | ||
5078 | } | ||
5079 | codec_dbg(codec, "Headset jack set to mic-in mode.\n"); | ||
5080 | } | ||
5081 | @@ -3884,6 +3907,13 @@ static void alc_headset_mode_ctia(struct hda_codec *codec) | ||
5082 | WRITE_COEF(0xc3, 0x0000), | ||
5083 | {} | ||
5084 | }; | ||
5085 | + static struct coef_fw coef0225[] = { | ||
5086 | + UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10), | ||
5087 | + UPDATE_COEF(0x49, 1<<8, 1<<8), | ||
5088 | + UPDATE_COEF(0x4a, 7<<6, 7<<6), | ||
5089 | + UPDATE_COEF(0x4a, 3<<4, 3<<4), | ||
5090 | + {} | ||
5091 | + }; | ||
5092 | |||
5093 | switch (codec->core.vendor_id) { | ||
5094 | case 0x10ec0255: | ||
5095 | @@ -3912,6 +3942,9 @@ static void alc_headset_mode_ctia(struct hda_codec *codec) | ||
5096 | case 0x10ec0668: | ||
5097 | alc_process_coef_fw(codec, coef0688); | ||
5098 | break; | ||
5099 | + case 0x10ec0225: | ||
5100 | + alc_process_coef_fw(codec, coef0225); | ||
5101 | + break; | ||
5102 | } | ||
5103 | codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n"); | ||
5104 | } | ||
5105 | @@ -3955,6 +3988,13 @@ static void alc_headset_mode_omtp(struct hda_codec *codec) | ||
5106 | WRITE_COEF(0xc3, 0x0000), | ||
5107 | {} | ||
5108 | }; | ||
5109 | + static struct coef_fw coef0225[] = { | ||
5110 | + UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10), | ||
5111 | + UPDATE_COEF(0x49, 1<<8, 1<<8), | ||
5112 | + UPDATE_COEF(0x4a, 7<<6, 7<<6), | ||
5113 | + UPDATE_COEF(0x4a, 3<<4, 3<<4), | ||
5114 | + {} | ||
5115 | + }; | ||
5116 | |||
5117 | switch (codec->core.vendor_id) { | ||
5118 | case 0x10ec0255: | ||
5119 | @@ -3983,6 +4023,9 @@ static void alc_headset_mode_omtp(struct hda_codec *codec) | ||
5120 | case 0x10ec0668: | ||
5121 | alc_process_coef_fw(codec, coef0688); | ||
5122 | break; | ||
5123 | + case 0x10ec0225: | ||
5124 | + alc_process_coef_fw(codec, coef0225); | ||
5125 | + break; | ||
5126 | } | ||
5127 | codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n"); | ||
5128 | } | ||
5129 | @@ -4014,6 +4057,11 @@ static void alc_determine_headset_type(struct hda_codec *codec) | ||
5130 | WRITE_COEF(0xc3, 0x0c00), | ||
5131 | {} | ||
5132 | }; | ||
5133 | + static struct coef_fw coef0225[] = { | ||
5134 | + UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10), | ||
5135 | + UPDATE_COEF(0x49, 1<<8, 1<<8), | ||
5136 | + {} | ||
5137 | + }; | ||
5138 | |||
5139 | switch (codec->core.vendor_id) { | ||
5140 | case 0x10ec0255: | ||
5141 | @@ -4058,6 +4106,12 @@ static void alc_determine_headset_type(struct hda_codec *codec) | ||
5142 | val = alc_read_coef_idx(codec, 0xbe); | ||
5143 | is_ctia = (val & 0x1c02) == 0x1c02; | ||
5144 | break; | ||
5145 | + case 0x10ec0225: | ||
5146 | + alc_process_coef_fw(codec, coef0225); | ||
5147 | + msleep(800); | ||
5148 | + val = alc_read_coef_idx(codec, 0x46); | ||
5149 | + is_ctia = (val & 0x00f0) == 0x00f0; | ||
5150 | + break; | ||
5151 | } | ||
5152 | |||
5153 | codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n", | ||
5154 | @@ -5560,6 +5614,9 @@ static const struct hda_model_fixup alc269_fixup_models[] = { | ||
5155 | {.id = ALC292_FIXUP_TPT440, .name = "tpt440"}, | ||
5156 | {} | ||
5157 | }; | ||
5158 | +#define ALC225_STANDARD_PINS \ | ||
5159 | + {0x12, 0xb7a60130}, \ | ||
5160 | + {0x21, 0x04211020} | ||
5161 | |||
5162 | #define ALC256_STANDARD_PINS \ | ||
5163 | {0x12, 0x90a60140}, \ | ||
5164 | @@ -5581,6 +5638,12 @@ static const struct hda_model_fixup alc269_fixup_models[] = { | ||
5165 | {0x21, 0x03211020} | ||
5166 | |||
5167 | static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { | ||
5168 | + SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, | ||
5169 | + ALC225_STANDARD_PINS, | ||
5170 | + {0x14, 0x901701a0}), | ||
5171 | + SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, | ||
5172 | + ALC225_STANDARD_PINS, | ||
5173 | + {0x14, 0x901701b0}), | ||
5174 | SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, | ||
5175 | {0x14, 0x90170110}, | ||
5176 | {0x21, 0x02211020}), | ||
5177 | @@ -5906,6 +5969,9 @@ static int patch_alc269(struct hda_codec *codec) | ||
5178 | spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */ | ||
5179 | alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/ | ||
5180 | break; | ||
5181 | + case 0x10ec0225: | ||
5182 | + spec->codec_variant = ALC269_TYPE_ALC225; | ||
5183 | + break; | ||
5184 | } | ||
5185 | |||
5186 | if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) { | ||
5187 | @@ -6796,6 +6862,7 @@ static int patch_alc680(struct hda_codec *codec) | ||
5188 | */ | ||
5189 | static const struct hda_device_id snd_hda_id_realtek[] = { | ||
5190 | HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269), | ||
5191 | + HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269), | ||
5192 | HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269), | ||
5193 | HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269), | ||
5194 | HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269), | ||
5195 | diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c | ||
5196 | index 2c7c5eb8b1e9..37b70f8e878f 100644 | ||
5197 | --- a/sound/pci/hda/patch_sigmatel.c | ||
5198 | +++ b/sound/pci/hda/patch_sigmatel.c | ||
5199 | @@ -493,9 +493,9 @@ static void jack_update_power(struct hda_codec *codec, | ||
5200 | if (!spec->num_pwrs) | ||
5201 | return; | ||
5202 | |||
5203 | - if (jack && jack->tbl->nid) { | ||
5204 | - stac_toggle_power_map(codec, jack->tbl->nid, | ||
5205 | - snd_hda_jack_detect(codec, jack->tbl->nid), | ||
5206 | + if (jack && jack->nid) { | ||
5207 | + stac_toggle_power_map(codec, jack->nid, | ||
5208 | + snd_hda_jack_detect(codec, jack->nid), | ||
5209 | true); | ||
5210 | return; | ||
5211 | } | ||
5212 | diff --git a/sound/soc/codecs/rt5645.c b/sound/soc/codecs/rt5645.c | ||
5213 | index 3e3c7f6be29d..b74840b5becf 100644 | ||
5214 | --- a/sound/soc/codecs/rt5645.c | ||
5215 | +++ b/sound/soc/codecs/rt5645.c | ||
5216 | @@ -621,7 +621,7 @@ static const struct snd_kcontrol_new rt5645_snd_controls[] = { | ||
5217 | |||
5218 | /* IN1/IN2 Control */ | ||
5219 | SOC_SINGLE_TLV("IN1 Boost", RT5645_IN1_CTRL1, | ||
5220 | - RT5645_BST_SFT1, 8, 0, bst_tlv), | ||
5221 | + RT5645_BST_SFT1, 12, 0, bst_tlv), | ||
5222 | SOC_SINGLE_TLV("IN2 Boost", RT5645_IN2_CTRL, | ||
5223 | RT5645_BST_SFT2, 8, 0, bst_tlv), | ||
5224 | |||
5225 | diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c | ||
5226 | index c86dc96e8986..65b936e251ea 100644 | ||
5227 | --- a/sound/soc/soc-pcm.c | ||
5228 | +++ b/sound/soc/soc-pcm.c | ||
5229 | @@ -1743,7 +1743,8 @@ int dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream) | ||
5230 | (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) && | ||
5231 | (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) && | ||
5232 | (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED) && | ||
5233 | - (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP)) | ||
5234 | + (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) && | ||
5235 | + (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND)) | ||
5236 | continue; | ||
5237 | |||
5238 | dev_dbg(be->dev, "ASoC: hw_free BE %s\n", | ||
5239 | diff --git a/sound/sparc/Kconfig b/sound/sparc/Kconfig | ||
5240 | index d75deba5617d..dfcd38647606 100644 | ||
5241 | --- a/sound/sparc/Kconfig | ||
5242 | +++ b/sound/sparc/Kconfig | ||
5243 | @@ -22,6 +22,7 @@ config SND_SUN_AMD7930 | ||
5244 | config SND_SUN_CS4231 | ||
5245 | tristate "Sun CS4231" | ||
5246 | select SND_PCM | ||
5247 | + select SND_TIMER | ||
5248 | help | ||
5249 | Say Y here to include support for CS4231 sound device on Sun. | ||
5250 | |||
5251 | diff --git a/sound/usb/midi.c b/sound/usb/midi.c | ||
5252 | index 5b4c58c3e2c5..b21b76690b31 100644 | ||
5253 | --- a/sound/usb/midi.c | ||
5254 | +++ b/sound/usb/midi.c | ||
5255 | @@ -2454,7 +2454,6 @@ int snd_usbmidi_create(struct snd_card *card, | ||
5256 | else | ||
5257 | err = snd_usbmidi_create_endpoints(umidi, endpoints); | ||
5258 | if (err < 0) { | ||
5259 | - snd_usbmidi_free(umidi); | ||
5260 | return err; | ||
5261 | } | ||
5262 | |||
5263 | diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c | ||
5264 | index 23ea6d800c4c..4f6ce1cac8e2 100644 | ||
5265 | --- a/sound/usb/quirks.c | ||
5266 | +++ b/sound/usb/quirks.c | ||
5267 | @@ -1121,6 +1121,7 @@ bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip) | ||
5268 | switch (chip->usb_id) { | ||
5269 | case USB_ID(0x045E, 0x075D): /* MS Lifecam Cinema */ | ||
5270 | case USB_ID(0x045E, 0x076D): /* MS Lifecam HD-5000 */ | ||
5271 | + case USB_ID(0x045E, 0x076F): /* MS Lifecam HD-6000 */ | ||
5272 | case USB_ID(0x045E, 0x0772): /* MS Lifecam Studio */ | ||
5273 | case USB_ID(0x045E, 0x0779): /* MS Lifecam HD-3000 */ | ||
5274 | case USB_ID(0x04D8, 0xFEEA): /* Benchmark DAC1 Pre */ | ||
5275 | @@ -1205,8 +1206,12 @@ void snd_usb_set_interface_quirk(struct usb_device *dev) | ||
5276 | * "Playback Design" products need a 50ms delay after setting the | ||
5277 | * USB interface. | ||
5278 | */ | ||
5279 | - if (le16_to_cpu(dev->descriptor.idVendor) == 0x23ba) | ||
5280 | + switch (le16_to_cpu(dev->descriptor.idVendor)) { | ||
5281 | + case 0x23ba: /* Playback Design */ | ||
5282 | + case 0x0644: /* TEAC Corp. */ | ||
5283 | mdelay(50); | ||
5284 | + break; | ||
5285 | + } | ||
5286 | } | ||
5287 | |||
5288 | void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe, | ||
5289 | @@ -1221,6 +1226,14 @@ void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe, | ||
5290 | (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS) | ||
5291 | mdelay(20); | ||
5292 | |||
5293 | + /* | ||
5294 | + * "TEAC Corp." products need a 20ms delay after each | ||
5295 | + * class compliant request | ||
5296 | + */ | ||
5297 | + if ((le16_to_cpu(dev->descriptor.idVendor) == 0x0644) && | ||
5298 | + (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS) | ||
5299 | + mdelay(20); | ||
5300 | + | ||
5301 | /* Marantz/Denon devices with USB DAC functionality need a delay | ||
5302 | * after each class compliant request | ||
5303 | */ | ||
5304 | @@ -1269,7 +1282,7 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, | ||
5305 | case USB_ID(0x20b1, 0x3008): /* iFi Audio micro/nano iDSD */ | ||
5306 | case USB_ID(0x20b1, 0x2008): /* Matrix Audio X-Sabre */ | ||
5307 | case USB_ID(0x20b1, 0x300a): /* Matrix Audio Mini-i Pro */ | ||
5308 | - case USB_ID(0x22d8, 0x0416): /* OPPO HA-1*/ | ||
5309 | + case USB_ID(0x22d9, 0x0416): /* OPPO HA-1 */ | ||
5310 | if (fp->altsetting == 2) | ||
5311 | return SNDRV_PCM_FMTBIT_DSD_U32_BE; | ||
5312 | break; | ||
5313 | @@ -1278,6 +1291,7 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, | ||
5314 | case USB_ID(0x20b1, 0x2009): /* DIYINHK DSD DXD 384kHz USB to I2S/DSD */ | ||
5315 | case USB_ID(0x20b1, 0x2023): /* JLsounds I2SoverUSB */ | ||
5316 | case USB_ID(0x20b1, 0x3023): /* Aune X1S 32BIT/384 DSD DAC */ | ||
5317 | + case USB_ID(0x2616, 0x0106): /* PS Audio NuWave DAC */ | ||
5318 | if (fp->altsetting == 3) | ||
5319 | return SNDRV_PCM_FMTBIT_DSD_U32_BE; | ||
5320 | break; |