Annotation of /trunk/kernel26-alx/patches-2.6.37/0104-2.6.37.5-all-fixes.patch
Parent Directory | Revision Log
Revision 1311 -
(hide annotations)
(download)
Tue Apr 12 14:29:09 2011 UTC (13 years, 5 months ago) by niro
Original Path: trunk/kernel26-alx/patches-2.6.37-r1/0104-2.6.37.5-all-fixes.patch
File size: 107755 byte(s)
Tue Apr 12 14:29:09 2011 UTC (13 years, 5 months ago) by niro
Original Path: trunk/kernel26-alx/patches-2.6.37-r1/0104-2.6.37.5-all-fixes.patch
File size: 107755 byte(s)
kernel 2.6.37-alx-r1
1 | niro | 1311 | diff --git a/Documentation/i2c/instantiating-devices b/Documentation/i2c/instantiating-devices |
2 | index 87da405..9edb75d 100644 | ||
3 | --- a/Documentation/i2c/instantiating-devices | ||
4 | +++ b/Documentation/i2c/instantiating-devices | ||
5 | @@ -100,7 +100,7 @@ static int __devinit usb_hcd_pnx4008_probe(struct platform_device *pdev) | ||
6 | (...) | ||
7 | i2c_adap = i2c_get_adapter(2); | ||
8 | memset(&i2c_info, 0, sizeof(struct i2c_board_info)); | ||
9 | - strlcpy(i2c_info.name, "isp1301_pnx", I2C_NAME_SIZE); | ||
10 | + strlcpy(i2c_info.type, "isp1301_pnx", I2C_NAME_SIZE); | ||
11 | isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info, | ||
12 | normal_i2c, NULL); | ||
13 | i2c_put_adapter(i2c_adap); | ||
14 | diff --git a/arch/microblaze/include/asm/uaccess.h b/arch/microblaze/include/asm/uaccess.h | ||
15 | index d840f4a..5bb95a1 100644 | ||
16 | --- a/arch/microblaze/include/asm/uaccess.h | ||
17 | +++ b/arch/microblaze/include/asm/uaccess.h | ||
18 | @@ -120,16 +120,16 @@ static inline unsigned long __must_check __clear_user(void __user *to, | ||
19 | { | ||
20 | /* normal memset with two words to __ex_table */ | ||
21 | __asm__ __volatile__ ( \ | ||
22 | - "1: sb r0, %2, r0;" \ | ||
23 | + "1: sb r0, %1, r0;" \ | ||
24 | " addik %0, %0, -1;" \ | ||
25 | " bneid %0, 1b;" \ | ||
26 | - " addik %2, %2, 1;" \ | ||
27 | + " addik %1, %1, 1;" \ | ||
28 | "2: " \ | ||
29 | __EX_TABLE_SECTION \ | ||
30 | ".word 1b,2b;" \ | ||
31 | ".previous;" \ | ||
32 | - : "=r"(n) \ | ||
33 | - : "0"(n), "r"(to) | ||
34 | + : "=r"(n), "=r"(to) \ | ||
35 | + : "0"(n), "1"(to) | ||
36 | ); | ||
37 | return n; | ||
38 | } | ||
39 | diff --git a/arch/mips/alchemy/mtx-1/platform.c b/arch/mips/alchemy/mtx-1/platform.c | ||
40 | index e30e42a..956f946 100644 | ||
41 | --- a/arch/mips/alchemy/mtx-1/platform.c | ||
42 | +++ b/arch/mips/alchemy/mtx-1/platform.c | ||
43 | @@ -28,6 +28,8 @@ | ||
44 | #include <linux/mtd/physmap.h> | ||
45 | #include <mtd/mtd-abi.h> | ||
46 | |||
47 | +#include <asm/mach-au1x00/au1xxx_eth.h> | ||
48 | + | ||
49 | static struct gpio_keys_button mtx1_gpio_button[] = { | ||
50 | { | ||
51 | .gpio = 207, | ||
52 | @@ -140,10 +142,17 @@ static struct __initdata platform_device * mtx1_devs[] = { | ||
53 | &mtx1_mtd, | ||
54 | }; | ||
55 | |||
56 | +static struct au1000_eth_platform_data mtx1_au1000_eth0_pdata = { | ||
57 | + .phy_search_highest_addr = 1, | ||
58 | + .phy1_search_mac0 = 1, | ||
59 | +}; | ||
60 | + | ||
61 | static int __init mtx1_register_devices(void) | ||
62 | { | ||
63 | int rc; | ||
64 | |||
65 | + au1xxx_override_eth_cfg(0, &mtx1_au1000_eth0_pdata); | ||
66 | + | ||
67 | rc = gpio_request(mtx1_gpio_button[0].gpio, | ||
68 | mtx1_gpio_button[0].desc); | ||
69 | if (rc < 0) { | ||
70 | diff --git a/arch/parisc/kernel/irq.c b/arch/parisc/kernel/irq.c | ||
71 | index d7d94b8..3948f1d 100644 | ||
72 | --- a/arch/parisc/kernel/irq.c | ||
73 | +++ b/arch/parisc/kernel/irq.c | ||
74 | @@ -108,7 +108,7 @@ int cpu_check_affinity(unsigned int irq, const struct cpumask *dest) | ||
75 | int cpu_dest; | ||
76 | |||
77 | /* timer and ipi have to always be received on all CPUs */ | ||
78 | - if (CHECK_IRQ_PER_CPU(irq)) { | ||
79 | + if (CHECK_IRQ_PER_CPU(irq_to_desc(irq)->status)) { | ||
80 | /* Bad linux design decision. The mask has already | ||
81 | * been set; we must reset it */ | ||
82 | cpumask_setall(irq_desc[irq].affinity); | ||
83 | diff --git a/arch/powerpc/include/asm/reg.h b/arch/powerpc/include/asm/reg.h | ||
84 | index ff0005eec..bf92cc2 100644 | ||
85 | --- a/arch/powerpc/include/asm/reg.h | ||
86 | +++ b/arch/powerpc/include/asm/reg.h | ||
87 | @@ -878,6 +878,7 @@ | ||
88 | #define PV_970 0x0039 | ||
89 | #define PV_POWER5 0x003A | ||
90 | #define PV_POWER5p 0x003B | ||
91 | +#define PV_POWER7 0x003F | ||
92 | #define PV_970FX 0x003C | ||
93 | #define PV_630 0x0040 | ||
94 | #define PV_630p 0x0041 | ||
95 | diff --git a/arch/powerpc/kernel/perf_event.c b/arch/powerpc/kernel/perf_event.c | ||
96 | index 3129c85..130712a 100644 | ||
97 | --- a/arch/powerpc/kernel/perf_event.c | ||
98 | +++ b/arch/powerpc/kernel/perf_event.c | ||
99 | @@ -1268,6 +1268,28 @@ unsigned long perf_instruction_pointer(struct pt_regs *regs) | ||
100 | return ip; | ||
101 | } | ||
102 | |||
103 | +static bool pmc_overflow(unsigned long val) | ||
104 | +{ | ||
105 | + if ((int)val < 0) | ||
106 | + return true; | ||
107 | + | ||
108 | + /* | ||
109 | + * Events on POWER7 can roll back if a speculative event doesn't | ||
110 | + * eventually complete. Unfortunately in some rare cases they will | ||
111 | + * raise a performance monitor exception. We need to catch this to | ||
112 | + * ensure we reset the PMC. In all cases the PMC will be 256 or less | ||
113 | + * cycles from overflow. | ||
114 | + * | ||
115 | + * We only do this if the first pass fails to find any overflowing | ||
116 | + * PMCs because a user might set a period of less than 256 and we | ||
117 | + * don't want to mistakenly reset them. | ||
118 | + */ | ||
119 | + if (__is_processor(PV_POWER7) && ((0x80000000 - val) <= 256)) | ||
120 | + return true; | ||
121 | + | ||
122 | + return false; | ||
123 | +} | ||
124 | + | ||
125 | /* | ||
126 | * Performance monitor interrupt stuff | ||
127 | */ | ||
128 | @@ -1315,7 +1337,7 @@ static void perf_event_interrupt(struct pt_regs *regs) | ||
129 | if (is_limited_pmc(i + 1)) | ||
130 | continue; | ||
131 | val = read_pmc(i + 1); | ||
132 | - if ((int)val < 0) | ||
133 | + if (pmc_overflow(val)) | ||
134 | write_pmc(i + 1, 0); | ||
135 | } | ||
136 | } | ||
137 | diff --git a/arch/x86/include/asm/pgtable-3level.h b/arch/x86/include/asm/pgtable-3level.h | ||
138 | index 177b016..33927d2 100644 | ||
139 | --- a/arch/x86/include/asm/pgtable-3level.h | ||
140 | +++ b/arch/x86/include/asm/pgtable-3level.h | ||
141 | @@ -69,8 +69,6 @@ static inline void native_pmd_clear(pmd_t *pmd) | ||
142 | |||
143 | static inline void pud_clear(pud_t *pudp) | ||
144 | { | ||
145 | - unsigned long pgd; | ||
146 | - | ||
147 | set_pud(pudp, __pud(0)); | ||
148 | |||
149 | /* | ||
150 | @@ -79,13 +77,10 @@ static inline void pud_clear(pud_t *pudp) | ||
151 | * section 8.1: in PAE mode we explicitly have to flush the | ||
152 | * TLB via cr3 if the top-level pgd is changed... | ||
153 | * | ||
154 | - * Make sure the pud entry we're updating is within the | ||
155 | - * current pgd to avoid unnecessary TLB flushes. | ||
156 | + * Currently all places where pud_clear() is called either have | ||
157 | + * flush_tlb_mm() followed or don't need TLB flush (x86_64 code or | ||
158 | + * pud_clear_bad()), so we don't need TLB flush here. | ||
159 | */ | ||
160 | - pgd = read_cr3(); | ||
161 | - if (__pa(pudp) >= pgd && __pa(pudp) < | ||
162 | - (pgd + sizeof(pgd_t)*PTRS_PER_PGD)) | ||
163 | - write_cr3(pgd); | ||
164 | } | ||
165 | |||
166 | #ifdef CONFIG_SMP | ||
167 | diff --git a/arch/x86/kernel/alternative.c b/arch/x86/kernel/alternative.c | ||
168 | index 5079f24..9495ac1 100644 | ||
169 | --- a/arch/x86/kernel/alternative.c | ||
170 | +++ b/arch/x86/kernel/alternative.c | ||
171 | @@ -417,7 +417,12 @@ int alternatives_text_reserved(void *start, void *end) | ||
172 | return 1; | ||
173 | } | ||
174 | } | ||
175 | - | ||
176 | + /* | ||
177 | + * Intel Archiecture Software Developer's Manual section 7.1.3 specifies | ||
178 | + * that a core serializing instruction such as "cpuid" should be | ||
179 | + * executed on _each_ core before the new instruction is made visible. | ||
180 | + */ | ||
181 | + sync_core(); | ||
182 | return 0; | ||
183 | } | ||
184 | #endif | ||
185 | diff --git a/arch/x86/kernel/check.c b/arch/x86/kernel/check.c | ||
186 | index 13a3891..452932d 100644 | ||
187 | --- a/arch/x86/kernel/check.c | ||
188 | +++ b/arch/x86/kernel/check.c | ||
189 | @@ -106,8 +106,8 @@ void __init setup_bios_corruption_check(void) | ||
190 | addr += size; | ||
191 | } | ||
192 | |||
193 | - printk(KERN_INFO "Scanning %d areas for low memory corruption\n", | ||
194 | - num_scan_areas); | ||
195 | + if (num_scan_areas) | ||
196 | + printk(KERN_INFO "Scanning %d areas for low memory corruption\n", num_scan_areas); | ||
197 | } | ||
198 | |||
199 | |||
200 | @@ -143,12 +143,12 @@ static void check_corruption(struct work_struct *dummy) | ||
201 | { | ||
202 | check_for_bios_corruption(); | ||
203 | schedule_delayed_work(&bios_check_work, | ||
204 | - round_jiffies_relative(corruption_check_period*HZ)); | ||
205 | + round_jiffies_relative(corruption_check_period*HZ)); | ||
206 | } | ||
207 | |||
208 | static int start_periodic_check_for_corruption(void) | ||
209 | { | ||
210 | - if (!memory_corruption_check || corruption_check_period == 0) | ||
211 | + if (!num_scan_areas || !memory_corruption_check || corruption_check_period == 0) | ||
212 | return 0; | ||
213 | |||
214 | printk(KERN_INFO "Scanning for low memory corruption every %d seconds\n", | ||
215 | diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c | ||
216 | index 0c2b7ef..d54f0a4 100644 | ||
217 | --- a/arch/x86/kernel/e820.c | ||
218 | +++ b/arch/x86/kernel/e820.c | ||
219 | @@ -846,15 +846,21 @@ static int __init parse_memopt(char *p) | ||
220 | if (!p) | ||
221 | return -EINVAL; | ||
222 | |||
223 | -#ifdef CONFIG_X86_32 | ||
224 | if (!strcmp(p, "nopentium")) { | ||
225 | +#ifdef CONFIG_X86_32 | ||
226 | setup_clear_cpu_cap(X86_FEATURE_PSE); | ||
227 | return 0; | ||
228 | - } | ||
229 | +#else | ||
230 | + printk(KERN_WARNING "mem=nopentium ignored! (only supported on x86_32)\n"); | ||
231 | + return -EINVAL; | ||
232 | #endif | ||
233 | + } | ||
234 | |||
235 | userdef = 1; | ||
236 | mem_size = memparse(p, &p); | ||
237 | + /* don't remove all of memory when handling "mem={invalid}" param */ | ||
238 | + if (mem_size == 0) | ||
239 | + return -EINVAL; | ||
240 | e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1); | ||
241 | |||
242 | return 0; | ||
243 | diff --git a/arch/x86/kernel/early-quirks.c b/arch/x86/kernel/early-quirks.c | ||
244 | index 9efbdcc..3755ef4 100644 | ||
245 | --- a/arch/x86/kernel/early-quirks.c | ||
246 | +++ b/arch/x86/kernel/early-quirks.c | ||
247 | @@ -159,7 +159,12 @@ static void __init ati_bugs_contd(int num, int slot, int func) | ||
248 | if (rev >= 0x40) | ||
249 | acpi_fix_pin2_polarity = 1; | ||
250 | |||
251 | - if (rev > 0x13) | ||
252 | + /* | ||
253 | + * SB600: revisions 0x11, 0x12, 0x13, 0x14, ... | ||
254 | + * SB700: revisions 0x39, 0x3a, ... | ||
255 | + * SB800: revisions 0x40, 0x41, ... | ||
256 | + */ | ||
257 | + if (rev >= 0x39) | ||
258 | return; | ||
259 | |||
260 | if (acpi_use_timer_override) | ||
261 | diff --git a/arch/x86/kernel/entry_64.S b/arch/x86/kernel/entry_64.S | ||
262 | index e3ba417..b235db9 100644 | ||
263 | --- a/arch/x86/kernel/entry_64.S | ||
264 | +++ b/arch/x86/kernel/entry_64.S | ||
265 | @@ -1238,7 +1238,7 @@ ENTRY(xen_do_hypervisor_callback) # do_hypervisor_callback(struct *pt_regs) | ||
266 | decl PER_CPU_VAR(irq_count) | ||
267 | jmp error_exit | ||
268 | CFI_ENDPROC | ||
269 | -END(do_hypervisor_callback) | ||
270 | +END(xen_do_hypervisor_callback) | ||
271 | |||
272 | /* | ||
273 | * Hypervisor uses this for application faults while it executes. | ||
274 | diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c | ||
275 | index 7d90ceb..20e3f87 100644 | ||
276 | --- a/arch/x86/mm/fault.c | ||
277 | +++ b/arch/x86/mm/fault.c | ||
278 | @@ -229,15 +229,14 @@ void vmalloc_sync_all(void) | ||
279 | for (address = VMALLOC_START & PMD_MASK; | ||
280 | address >= TASK_SIZE && address < FIXADDR_TOP; | ||
281 | address += PMD_SIZE) { | ||
282 | - | ||
283 | - unsigned long flags; | ||
284 | struct page *page; | ||
285 | |||
286 | - spin_lock_irqsave(&pgd_lock, flags); | ||
287 | + spin_lock(&pgd_lock); | ||
288 | list_for_each_entry(page, &pgd_list, lru) { | ||
289 | spinlock_t *pgt_lock; | ||
290 | pmd_t *ret; | ||
291 | |||
292 | + /* the pgt_lock only for Xen */ | ||
293 | pgt_lock = &pgd_page_get_mm(page)->page_table_lock; | ||
294 | |||
295 | spin_lock(pgt_lock); | ||
296 | @@ -247,7 +246,7 @@ void vmalloc_sync_all(void) | ||
297 | if (!ret) | ||
298 | break; | ||
299 | } | ||
300 | - spin_unlock_irqrestore(&pgd_lock, flags); | ||
301 | + spin_unlock(&pgd_lock); | ||
302 | } | ||
303 | } | ||
304 | |||
305 | @@ -828,6 +827,13 @@ mm_fault_error(struct pt_regs *regs, unsigned long error_code, | ||
306 | unsigned long address, unsigned int fault) | ||
307 | { | ||
308 | if (fault & VM_FAULT_OOM) { | ||
309 | + /* Kernel mode? Handle exceptions or die: */ | ||
310 | + if (!(error_code & PF_USER)) { | ||
311 | + up_read(¤t->mm->mmap_sem); | ||
312 | + no_context(regs, error_code, address); | ||
313 | + return; | ||
314 | + } | ||
315 | + | ||
316 | out_of_memory(regs, error_code, address); | ||
317 | } else { | ||
318 | if (fault & (VM_FAULT_SIGBUS|VM_FAULT_HWPOISON| | ||
319 | diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c | ||
320 | index 71a5929..c14a542 100644 | ||
321 | --- a/arch/x86/mm/init_64.c | ||
322 | +++ b/arch/x86/mm/init_64.c | ||
323 | @@ -105,18 +105,18 @@ void sync_global_pgds(unsigned long start, unsigned long end) | ||
324 | |||
325 | for (address = start; address <= end; address += PGDIR_SIZE) { | ||
326 | const pgd_t *pgd_ref = pgd_offset_k(address); | ||
327 | - unsigned long flags; | ||
328 | struct page *page; | ||
329 | |||
330 | if (pgd_none(*pgd_ref)) | ||
331 | continue; | ||
332 | |||
333 | - spin_lock_irqsave(&pgd_lock, flags); | ||
334 | + spin_lock(&pgd_lock); | ||
335 | list_for_each_entry(page, &pgd_list, lru) { | ||
336 | pgd_t *pgd; | ||
337 | spinlock_t *pgt_lock; | ||
338 | |||
339 | pgd = (pgd_t *)page_address(page) + pgd_index(address); | ||
340 | + /* the pgt_lock only for Xen */ | ||
341 | pgt_lock = &pgd_page_get_mm(page)->page_table_lock; | ||
342 | spin_lock(pgt_lock); | ||
343 | |||
344 | @@ -128,7 +128,7 @@ void sync_global_pgds(unsigned long start, unsigned long end) | ||
345 | |||
346 | spin_unlock(pgt_lock); | ||
347 | } | ||
348 | - spin_unlock_irqrestore(&pgd_lock, flags); | ||
349 | + spin_unlock(&pgd_lock); | ||
350 | } | ||
351 | } | ||
352 | |||
353 | diff --git a/arch/x86/mm/pageattr.c b/arch/x86/mm/pageattr.c | ||
354 | index 532e793..89d66f4 100644 | ||
355 | --- a/arch/x86/mm/pageattr.c | ||
356 | +++ b/arch/x86/mm/pageattr.c | ||
357 | @@ -56,12 +56,10 @@ static unsigned long direct_pages_count[PG_LEVEL_NUM]; | ||
358 | |||
359 | void update_page_count(int level, unsigned long pages) | ||
360 | { | ||
361 | - unsigned long flags; | ||
362 | - | ||
363 | /* Protect against CPA */ | ||
364 | - spin_lock_irqsave(&pgd_lock, flags); | ||
365 | + spin_lock(&pgd_lock); | ||
366 | direct_pages_count[level] += pages; | ||
367 | - spin_unlock_irqrestore(&pgd_lock, flags); | ||
368 | + spin_unlock(&pgd_lock); | ||
369 | } | ||
370 | |||
371 | static void split_page_count(int level) | ||
372 | @@ -391,7 +389,7 @@ static int | ||
373 | try_preserve_large_page(pte_t *kpte, unsigned long address, | ||
374 | struct cpa_data *cpa) | ||
375 | { | ||
376 | - unsigned long nextpage_addr, numpages, pmask, psize, flags, addr, pfn; | ||
377 | + unsigned long nextpage_addr, numpages, pmask, psize, addr, pfn; | ||
378 | pte_t new_pte, old_pte, *tmp; | ||
379 | pgprot_t old_prot, new_prot; | ||
380 | int i, do_split = 1; | ||
381 | @@ -400,7 +398,7 @@ try_preserve_large_page(pte_t *kpte, unsigned long address, | ||
382 | if (cpa->force_split) | ||
383 | return 1; | ||
384 | |||
385 | - spin_lock_irqsave(&pgd_lock, flags); | ||
386 | + spin_lock(&pgd_lock); | ||
387 | /* | ||
388 | * Check for races, another CPU might have split this page | ||
389 | * up already: | ||
390 | @@ -495,14 +493,14 @@ try_preserve_large_page(pte_t *kpte, unsigned long address, | ||
391 | } | ||
392 | |||
393 | out_unlock: | ||
394 | - spin_unlock_irqrestore(&pgd_lock, flags); | ||
395 | + spin_unlock(&pgd_lock); | ||
396 | |||
397 | return do_split; | ||
398 | } | ||
399 | |||
400 | static int split_large_page(pte_t *kpte, unsigned long address) | ||
401 | { | ||
402 | - unsigned long flags, pfn, pfninc = 1; | ||
403 | + unsigned long pfn, pfninc = 1; | ||
404 | unsigned int i, level; | ||
405 | pte_t *pbase, *tmp; | ||
406 | pgprot_t ref_prot; | ||
407 | @@ -516,7 +514,7 @@ static int split_large_page(pte_t *kpte, unsigned long address) | ||
408 | if (!base) | ||
409 | return -ENOMEM; | ||
410 | |||
411 | - spin_lock_irqsave(&pgd_lock, flags); | ||
412 | + spin_lock(&pgd_lock); | ||
413 | /* | ||
414 | * Check for races, another CPU might have split this page | ||
415 | * up for us already: | ||
416 | @@ -588,7 +586,7 @@ out_unlock: | ||
417 | */ | ||
418 | if (base) | ||
419 | __free_page(base); | ||
420 | - spin_unlock_irqrestore(&pgd_lock, flags); | ||
421 | + spin_unlock(&pgd_lock); | ||
422 | |||
423 | return 0; | ||
424 | } | ||
425 | diff --git a/arch/x86/mm/pgtable.c b/arch/x86/mm/pgtable.c | ||
426 | index 8be8c7d..7dd4719 100644 | ||
427 | --- a/arch/x86/mm/pgtable.c | ||
428 | +++ b/arch/x86/mm/pgtable.c | ||
429 | @@ -121,14 +121,12 @@ static void pgd_ctor(struct mm_struct *mm, pgd_t *pgd) | ||
430 | |||
431 | static void pgd_dtor(pgd_t *pgd) | ||
432 | { | ||
433 | - unsigned long flags; /* can be called from interrupt context */ | ||
434 | - | ||
435 | if (SHARED_KERNEL_PMD) | ||
436 | return; | ||
437 | |||
438 | - spin_lock_irqsave(&pgd_lock, flags); | ||
439 | + spin_lock(&pgd_lock); | ||
440 | pgd_list_del(pgd); | ||
441 | - spin_unlock_irqrestore(&pgd_lock, flags); | ||
442 | + spin_unlock(&pgd_lock); | ||
443 | } | ||
444 | |||
445 | /* | ||
446 | @@ -170,8 +168,7 @@ void pud_populate(struct mm_struct *mm, pud_t *pudp, pmd_t *pmd) | ||
447 | * section 8.1: in PAE mode we explicitly have to flush the | ||
448 | * TLB via cr3 if the top-level pgd is changed... | ||
449 | */ | ||
450 | - if (mm == current->active_mm) | ||
451 | - write_cr3(read_cr3()); | ||
452 | + flush_tlb_mm(mm); | ||
453 | } | ||
454 | #else /* !CONFIG_X86_PAE */ | ||
455 | |||
456 | @@ -260,7 +257,6 @@ pgd_t *pgd_alloc(struct mm_struct *mm) | ||
457 | { | ||
458 | pgd_t *pgd; | ||
459 | pmd_t *pmds[PREALLOCATED_PMDS]; | ||
460 | - unsigned long flags; | ||
461 | |||
462 | pgd = (pgd_t *)__get_free_page(PGALLOC_GFP); | ||
463 | |||
464 | @@ -280,12 +276,12 @@ pgd_t *pgd_alloc(struct mm_struct *mm) | ||
465 | * respect to anything walking the pgd_list, so that they | ||
466 | * never see a partially populated pgd. | ||
467 | */ | ||
468 | - spin_lock_irqsave(&pgd_lock, flags); | ||
469 | + spin_lock(&pgd_lock); | ||
470 | |||
471 | pgd_ctor(mm, pgd); | ||
472 | pgd_prepopulate_pmd(mm, pgd, pmds); | ||
473 | |||
474 | - spin_unlock_irqrestore(&pgd_lock, flags); | ||
475 | + spin_unlock(&pgd_lock); | ||
476 | |||
477 | return pgd; | ||
478 | |||
479 | diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c | ||
480 | index 198df8d..9ea0dc6 100644 | ||
481 | --- a/arch/x86/xen/mmu.c | ||
482 | +++ b/arch/x86/xen/mmu.c | ||
483 | @@ -1362,10 +1362,9 @@ static void xen_pgd_pin(struct mm_struct *mm) | ||
484 | */ | ||
485 | void xen_mm_pin_all(void) | ||
486 | { | ||
487 | - unsigned long flags; | ||
488 | struct page *page; | ||
489 | |||
490 | - spin_lock_irqsave(&pgd_lock, flags); | ||
491 | + spin_lock(&pgd_lock); | ||
492 | |||
493 | list_for_each_entry(page, &pgd_list, lru) { | ||
494 | if (!PagePinned(page)) { | ||
495 | @@ -1374,7 +1373,7 @@ void xen_mm_pin_all(void) | ||
496 | } | ||
497 | } | ||
498 | |||
499 | - spin_unlock_irqrestore(&pgd_lock, flags); | ||
500 | + spin_unlock(&pgd_lock); | ||
501 | } | ||
502 | |||
503 | /* | ||
504 | @@ -1475,10 +1474,9 @@ static void xen_pgd_unpin(struct mm_struct *mm) | ||
505 | */ | ||
506 | void xen_mm_unpin_all(void) | ||
507 | { | ||
508 | - unsigned long flags; | ||
509 | struct page *page; | ||
510 | |||
511 | - spin_lock_irqsave(&pgd_lock, flags); | ||
512 | + spin_lock(&pgd_lock); | ||
513 | |||
514 | list_for_each_entry(page, &pgd_list, lru) { | ||
515 | if (PageSavePinned(page)) { | ||
516 | @@ -1488,7 +1486,7 @@ void xen_mm_unpin_all(void) | ||
517 | } | ||
518 | } | ||
519 | |||
520 | - spin_unlock_irqrestore(&pgd_lock, flags); | ||
521 | + spin_unlock(&pgd_lock); | ||
522 | } | ||
523 | |||
524 | void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next) | ||
525 | diff --git a/block/blk-lib.c b/block/blk-lib.c | ||
526 | index 1a320d2..ccf5a40 100644 | ||
527 | --- a/block/blk-lib.c | ||
528 | +++ b/block/blk-lib.c | ||
529 | @@ -109,7 +109,6 @@ struct bio_batch | ||
530 | atomic_t done; | ||
531 | unsigned long flags; | ||
532 | struct completion *wait; | ||
533 | - bio_end_io_t *end_io; | ||
534 | }; | ||
535 | |||
536 | static void bio_batch_end_io(struct bio *bio, int err) | ||
537 | @@ -122,12 +121,9 @@ static void bio_batch_end_io(struct bio *bio, int err) | ||
538 | else | ||
539 | clear_bit(BIO_UPTODATE, &bb->flags); | ||
540 | } | ||
541 | - if (bb) { | ||
542 | - if (bb->end_io) | ||
543 | - bb->end_io(bio, err); | ||
544 | - atomic_inc(&bb->done); | ||
545 | - complete(bb->wait); | ||
546 | - } | ||
547 | + if (bb) | ||
548 | + if (atomic_dec_and_test(&bb->done)) | ||
549 | + complete(bb->wait); | ||
550 | bio_put(bio); | ||
551 | } | ||
552 | |||
553 | @@ -150,13 +146,12 @@ int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, | ||
554 | int ret; | ||
555 | struct bio *bio; | ||
556 | struct bio_batch bb; | ||
557 | - unsigned int sz, issued = 0; | ||
558 | + unsigned int sz; | ||
559 | DECLARE_COMPLETION_ONSTACK(wait); | ||
560 | |||
561 | - atomic_set(&bb.done, 0); | ||
562 | + atomic_set(&bb.done, 1); | ||
563 | bb.flags = 1 << BIO_UPTODATE; | ||
564 | bb.wait = &wait; | ||
565 | - bb.end_io = NULL; | ||
566 | |||
567 | submit: | ||
568 | ret = 0; | ||
569 | @@ -185,12 +180,12 @@ submit: | ||
570 | break; | ||
571 | } | ||
572 | ret = 0; | ||
573 | - issued++; | ||
574 | + atomic_inc(&bb.done); | ||
575 | submit_bio(WRITE, bio); | ||
576 | } | ||
577 | |||
578 | /* Wait for bios in-flight */ | ||
579 | - while (issued != atomic_read(&bb.done)) | ||
580 | + if (!atomic_dec_and_test(&bb.done)) | ||
581 | wait_for_completion(&wait); | ||
582 | |||
583 | if (!test_bit(BIO_UPTODATE, &bb.flags)) | ||
584 | diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c | ||
585 | index 3288263..95c0be0 100644 | ||
586 | --- a/drivers/ata/ahci.c | ||
587 | +++ b/drivers/ata/ahci.c | ||
588 | @@ -260,6 +260,8 @@ static const struct pci_device_id ahci_pci_tbl[] = { | ||
589 | { PCI_VDEVICE(INTEL, 0x1d02), board_ahci }, /* PBG AHCI */ | ||
590 | { PCI_VDEVICE(INTEL, 0x1d04), board_ahci }, /* PBG RAID */ | ||
591 | { PCI_VDEVICE(INTEL, 0x1d06), board_ahci }, /* PBG RAID */ | ||
592 | + { PCI_VDEVICE(INTEL, 0x2826), board_ahci }, /* PBG RAID */ | ||
593 | + { PCI_VDEVICE(INTEL, 0x2323), board_ahci }, /* DH89xxCC AHCI */ | ||
594 | |||
595 | /* JMicron 360/1/3/5/6, match class to avoid IDE function */ | ||
596 | { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, | ||
597 | @@ -380,6 +382,8 @@ static const struct pci_device_id ahci_pci_tbl[] = { | ||
598 | { PCI_VDEVICE(MARVELL, 0x6121), board_ahci_mv }, /* 6121 */ | ||
599 | { PCI_DEVICE(0x1b4b, 0x9123), | ||
600 | .driver_data = board_ahci_yes_fbs }, /* 88se9128 */ | ||
601 | + { PCI_DEVICE(0x1b4b, 0x9125), | ||
602 | + .driver_data = board_ahci_yes_fbs }, /* 88se9125 */ | ||
603 | |||
604 | /* Promise */ | ||
605 | { PCI_VDEVICE(PROMISE, 0x3f20), board_ahci }, /* PDC42819 */ | ||
606 | diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c | ||
607 | index 17a6378..e16850e 100644 | ||
608 | --- a/drivers/ata/libata-eh.c | ||
609 | +++ b/drivers/ata/libata-eh.c | ||
610 | @@ -1618,7 +1618,7 @@ static void ata_eh_analyze_serror(struct ata_link *link) | ||
611 | * host links. For disabled PMP links, only N bit is | ||
612 | * considered as X bit is left at 1 for link plugging. | ||
613 | */ | ||
614 | - if (link->lpm_policy != ATA_LPM_MAX_POWER) | ||
615 | + if (link->lpm_policy > ATA_LPM_MAX_POWER) | ||
616 | hotplug_mask = 0; /* hotplug doesn't work w/ LPM */ | ||
617 | else if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link)) | ||
618 | hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG; | ||
619 | diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c | ||
620 | index 85da4c4..2eee8e0 100644 | ||
621 | --- a/drivers/gpu/drm/drm_sysfs.c | ||
622 | +++ b/drivers/gpu/drm/drm_sysfs.c | ||
623 | @@ -158,8 +158,15 @@ static ssize_t status_show(struct device *device, | ||
624 | { | ||
625 | struct drm_connector *connector = to_drm_connector(device); | ||
626 | enum drm_connector_status status; | ||
627 | + int ret; | ||
628 | + | ||
629 | + ret = mutex_lock_interruptible(&connector->dev->mode_config.mutex); | ||
630 | + if (ret) | ||
631 | + return ret; | ||
632 | |||
633 | status = connector->funcs->detect(connector, true); | ||
634 | + mutex_unlock(&connector->dev->mode_config.mutex); | ||
635 | + | ||
636 | return snprintf(buf, PAGE_SIZE, "%s\n", | ||
637 | drm_get_connector_status_name(status)); | ||
638 | } | ||
639 | diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c | ||
640 | index 0df86b5..c87e5d9 100644 | ||
641 | --- a/drivers/gpu/drm/i915/intel_panel.c | ||
642 | +++ b/drivers/gpu/drm/i915/intel_panel.c | ||
643 | @@ -176,7 +176,6 @@ u32 intel_panel_get_backlight(struct drm_device *dev) | ||
644 | val &= ~1; | ||
645 | pci_read_config_byte(dev->pdev, PCI_LBPC, &lbpc); | ||
646 | val *= lbpc; | ||
647 | - val >>= 1; | ||
648 | } | ||
649 | } | ||
650 | |||
651 | diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig | ||
652 | index 3052e29..3e01479 100644 | ||
653 | --- a/drivers/hid/Kconfig | ||
654 | +++ b/drivers/hid/Kconfig | ||
655 | @@ -291,10 +291,10 @@ config HID_NTRIG | ||
656 | Support for N-Trig touch screen. | ||
657 | |||
658 | config HID_ORTEK | ||
659 | - tristate "Ortek WKB-2000 wireless keyboard and mouse trackpad" | ||
660 | + tristate "Ortek PKB-1700/WKB-2000 wireless keyboard and mouse trackpad" | ||
661 | depends on USB_HID | ||
662 | ---help--- | ||
663 | - Support for Ortek WKB-2000 wireless keyboard + mouse trackpad. | ||
664 | + Support for Ortek PKB-1700/WKB-2000 wireless keyboard + mouse trackpad. | ||
665 | |||
666 | config HID_PANTHERLORD | ||
667 | tristate "Pantherlord/GreenAsia game controller" | ||
668 | diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c | ||
669 | index 52cf7ca..cdfa368 100644 | ||
670 | --- a/drivers/hid/hid-core.c | ||
671 | +++ b/drivers/hid/hid-core.c | ||
672 | @@ -1365,6 +1365,7 @@ static const struct hid_device_id hid_blacklist[] = { | ||
673 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) }, | ||
674 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) }, | ||
675 | { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) }, | ||
676 | + { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) }, | ||
677 | { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) }, | ||
678 | { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) }, | ||
679 | { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) }, | ||
680 | diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h | ||
681 | index f04789d..b4df785 100644 | ||
682 | --- a/drivers/hid/hid-ids.h | ||
683 | +++ b/drivers/hid/hid-ids.h | ||
684 | @@ -445,6 +445,7 @@ | ||
685 | #define USB_DEVICE_ID_ONTRAK_ADU100 0x0064 | ||
686 | |||
687 | #define USB_VENDOR_ID_ORTEK 0x05a4 | ||
688 | +#define USB_DEVICE_ID_ORTEK_PKB1700 0x1700 | ||
689 | #define USB_DEVICE_ID_ORTEK_WKB2000 0x2000 | ||
690 | |||
691 | #define USB_VENDOR_ID_PANJIT 0x134c | ||
692 | diff --git a/drivers/hid/hid-magicmouse.c b/drivers/hid/hid-magicmouse.c | ||
693 | index ed732b7..d383a44 100644 | ||
694 | --- a/drivers/hid/hid-magicmouse.c | ||
695 | +++ b/drivers/hid/hid-magicmouse.c | ||
696 | @@ -256,7 +256,7 @@ static void magicmouse_emit_touch(struct magicmouse_sc *msc, int raw_id, u8 *tda | ||
697 | input_report_abs(input, ABS_MT_TRACKING_ID, id); | ||
698 | input_report_abs(input, ABS_MT_TOUCH_MAJOR, touch_major << 2); | ||
699 | input_report_abs(input, ABS_MT_TOUCH_MINOR, touch_minor << 2); | ||
700 | - input_report_abs(input, ABS_MT_ORIENTATION, orientation); | ||
701 | + input_report_abs(input, ABS_MT_ORIENTATION, -orientation); | ||
702 | input_report_abs(input, ABS_MT_POSITION_X, x); | ||
703 | input_report_abs(input, ABS_MT_POSITION_Y, y); | ||
704 | |||
705 | @@ -395,7 +395,7 @@ static void magicmouse_setup_input(struct input_dev *input, struct hid_device *h | ||
706 | input_set_abs_params(input, ABS_MT_TRACKING_ID, 0, 15, 0, 0); | ||
707 | input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 4, 0); | ||
708 | input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255, 4, 0); | ||
709 | - input_set_abs_params(input, ABS_MT_ORIENTATION, -32, 31, 1, 0); | ||
710 | + input_set_abs_params(input, ABS_MT_ORIENTATION, -31, 32, 1, 0); | ||
711 | |||
712 | /* Note: Touch Y position from the device is inverted relative | ||
713 | * to how pointer motion is reported (and relative to how USB | ||
714 | diff --git a/drivers/hid/hid-ortek.c b/drivers/hid/hid-ortek.c | ||
715 | index 2e79716..d021461 100644 | ||
716 | --- a/drivers/hid/hid-ortek.c | ||
717 | +++ b/drivers/hid/hid-ortek.c | ||
718 | @@ -1,5 +1,5 @@ | ||
719 | /* | ||
720 | - * HID driver for Ortek WKB-2000 (wireless keyboard + mouse trackpad). | ||
721 | + * HID driver for Ortek PKB-1700/WKB-2000 (wireless keyboard + mouse trackpad). | ||
722 | * Fixes LogicalMaximum error in USB report description, see | ||
723 | * http://bugzilla.kernel.org/show_bug.cgi?id=14787 | ||
724 | * | ||
725 | @@ -31,6 +31,7 @@ static __u8 *ortek_report_fixup(struct hid_device *hdev, __u8 *rdesc, | ||
726 | } | ||
727 | |||
728 | static const struct hid_device_id ortek_devices[] = { | ||
729 | + { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) }, | ||
730 | { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) }, | ||
731 | { } | ||
732 | }; | ||
733 | diff --git a/drivers/hwmon/f71882fg.c b/drivers/hwmon/f71882fg.c | ||
734 | index 75afb3b..2855ef9 100644 | ||
735 | --- a/drivers/hwmon/f71882fg.c | ||
736 | +++ b/drivers/hwmon/f71882fg.c | ||
737 | @@ -2110,7 +2110,6 @@ static int f71882fg_remove(struct platform_device *pdev) | ||
738 | int nr_fans = (data->type == f71882fg) ? 4 : 3; | ||
739 | u8 start_reg = f71882fg_read8(data, F71882FG_REG_START); | ||
740 | |||
741 | - platform_set_drvdata(pdev, NULL); | ||
742 | if (data->hwmon_dev) | ||
743 | hwmon_device_unregister(data->hwmon_dev); | ||
744 | |||
745 | @@ -2177,6 +2176,7 @@ static int f71882fg_remove(struct platform_device *pdev) | ||
746 | } | ||
747 | } | ||
748 | |||
749 | + platform_set_drvdata(pdev, NULL); | ||
750 | kfree(data); | ||
751 | |||
752 | return 0; | ||
753 | diff --git a/drivers/hwmon/sht15.c b/drivers/hwmon/sht15.c | ||
754 | index a610e78..38a41d2 100644 | ||
755 | --- a/drivers/hwmon/sht15.c | ||
756 | +++ b/drivers/hwmon/sht15.c | ||
757 | @@ -333,11 +333,11 @@ static inline int sht15_calc_humid(struct sht15_data *data) | ||
758 | |||
759 | const int c1 = -4; | ||
760 | const int c2 = 40500; /* x 10 ^ -6 */ | ||
761 | - const int c3 = -2800; /* x10 ^ -9 */ | ||
762 | + const int c3 = -28; /* x 10 ^ -7 */ | ||
763 | |||
764 | RHlinear = c1*1000 | ||
765 | + c2 * data->val_humid/1000 | ||
766 | - + (data->val_humid * data->val_humid * c3)/1000000; | ||
767 | + + (data->val_humid * data->val_humid * c3) / 10000; | ||
768 | return (temp - 25000) * (10000 + 80 * data->val_humid) | ||
769 | / 1000000 + RHlinear; | ||
770 | } | ||
771 | diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c | ||
772 | index 64e0903..1d9616b 100644 | ||
773 | --- a/drivers/infiniband/core/cm.c | ||
774 | +++ b/drivers/infiniband/core/cm.c | ||
775 | @@ -2989,6 +2989,7 @@ static int cm_sidr_req_handler(struct cm_work *work) | ||
776 | goto out; /* No match. */ | ||
777 | } | ||
778 | atomic_inc(&cur_cm_id_priv->refcount); | ||
779 | + atomic_inc(&cm_id_priv->refcount); | ||
780 | spin_unlock_irq(&cm.lock); | ||
781 | |||
782 | cm_id_priv->id.cm_handler = cur_cm_id_priv->id.cm_handler; | ||
783 | diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c | ||
784 | index 6884da2..e450c5a 100644 | ||
785 | --- a/drivers/infiniband/core/cma.c | ||
786 | +++ b/drivers/infiniband/core/cma.c | ||
787 | @@ -1210,6 +1210,11 @@ static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event) | ||
788 | cm_id->context = conn_id; | ||
789 | cm_id->cm_handler = cma_ib_handler; | ||
790 | |||
791 | + /* | ||
792 | + * Protect against the user destroying conn_id from another thread | ||
793 | + * until we're done accessing it. | ||
794 | + */ | ||
795 | + atomic_inc(&conn_id->refcount); | ||
796 | ret = conn_id->id.event_handler(&conn_id->id, &event); | ||
797 | if (!ret) { | ||
798 | /* | ||
799 | @@ -1222,8 +1227,10 @@ static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event) | ||
800 | ib_send_cm_mra(cm_id, CMA_CM_MRA_SETTING, NULL, 0); | ||
801 | mutex_unlock(&lock); | ||
802 | mutex_unlock(&conn_id->handler_mutex); | ||
803 | + cma_deref_id(conn_id); | ||
804 | goto out; | ||
805 | } | ||
806 | + cma_deref_id(conn_id); | ||
807 | |||
808 | /* Destroy the CM ID by returning a non-zero value. */ | ||
809 | conn_id->cm_id.ib = NULL; | ||
810 | @@ -1425,17 +1432,25 @@ static int iw_conn_req_handler(struct iw_cm_id *cm_id, | ||
811 | event.param.conn.private_data_len = iw_event->private_data_len; | ||
812 | event.param.conn.initiator_depth = attr.max_qp_init_rd_atom; | ||
813 | event.param.conn.responder_resources = attr.max_qp_rd_atom; | ||
814 | + | ||
815 | + /* | ||
816 | + * Protect against the user destroying conn_id from another thread | ||
817 | + * until we're done accessing it. | ||
818 | + */ | ||
819 | + atomic_inc(&conn_id->refcount); | ||
820 | ret = conn_id->id.event_handler(&conn_id->id, &event); | ||
821 | if (ret) { | ||
822 | /* User wants to destroy the CM ID */ | ||
823 | conn_id->cm_id.iw = NULL; | ||
824 | cma_exch(conn_id, CMA_DESTROYING); | ||
825 | mutex_unlock(&conn_id->handler_mutex); | ||
826 | + cma_deref_id(conn_id); | ||
827 | rdma_destroy_id(&conn_id->id); | ||
828 | goto out; | ||
829 | } | ||
830 | |||
831 | mutex_unlock(&conn_id->handler_mutex); | ||
832 | + cma_deref_id(conn_id); | ||
833 | |||
834 | out: | ||
835 | if (dev) | ||
836 | diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c | ||
837 | index efef5f9..47c7461 100644 | ||
838 | --- a/drivers/mmc/core/sdio.c | ||
839 | +++ b/drivers/mmc/core/sdio.c | ||
840 | @@ -395,6 +395,14 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr, | ||
841 | if (err) | ||
842 | goto remove; | ||
843 | |||
844 | + /* | ||
845 | + * Update oldcard with the new RCA received from the SDIO | ||
846 | + * device -- we're doing this so that it's updated in the | ||
847 | + * "card" struct when oldcard overwrites that later. | ||
848 | + */ | ||
849 | + if (oldcard) | ||
850 | + oldcard->rca = card->rca; | ||
851 | + | ||
852 | mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); | ||
853 | } | ||
854 | |||
855 | diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c | ||
856 | index 3d9c246..bfd631a 100644 | ||
857 | --- a/drivers/mmc/host/sdhci-pci.c | ||
858 | +++ b/drivers/mmc/host/sdhci-pci.c | ||
859 | @@ -454,6 +454,14 @@ static const struct pci_device_id pci_ids[] __devinitdata = { | ||
860 | }, | ||
861 | |||
862 | { | ||
863 | + .vendor = PCI_VENDOR_ID_RICOH, | ||
864 | + .device = 0xe823, | ||
865 | + .subvendor = PCI_ANY_ID, | ||
866 | + .subdevice = PCI_ANY_ID, | ||
867 | + .driver_data = (kernel_ulong_t)&sdhci_ricoh_mmc, | ||
868 | + }, | ||
869 | + | ||
870 | + { | ||
871 | .vendor = PCI_VENDOR_ID_ENE, | ||
872 | .device = PCI_DEVICE_ID_ENE_CB712_SD, | ||
873 | .subvendor = PCI_ANY_ID, | ||
874 | diff --git a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c | ||
875 | index ad9268b..56802cd 100644 | ||
876 | --- a/drivers/mtd/chips/cfi_cmdset_0001.c | ||
877 | +++ b/drivers/mtd/chips/cfi_cmdset_0001.c | ||
878 | @@ -1229,10 +1229,32 @@ static int inval_cache_and_wait_for_operation( | ||
879 | sleep_time = chip_op_time / 2; | ||
880 | |||
881 | for (;;) { | ||
882 | + if (chip->state != chip_state) { | ||
883 | + /* Someone's suspended the operation: sleep */ | ||
884 | + DECLARE_WAITQUEUE(wait, current); | ||
885 | + set_current_state(TASK_UNINTERRUPTIBLE); | ||
886 | + add_wait_queue(&chip->wq, &wait); | ||
887 | + mutex_unlock(&chip->mutex); | ||
888 | + schedule(); | ||
889 | + remove_wait_queue(&chip->wq, &wait); | ||
890 | + mutex_lock(&chip->mutex); | ||
891 | + continue; | ||
892 | + } | ||
893 | + | ||
894 | status = map_read(map, cmd_adr); | ||
895 | if (map_word_andequal(map, status, status_OK, status_OK)) | ||
896 | break; | ||
897 | |||
898 | + if (chip->erase_suspended && chip_state == FL_ERASING) { | ||
899 | + /* Erase suspend occured while sleep: reset timeout */ | ||
900 | + timeo = reset_timeo; | ||
901 | + chip->erase_suspended = 0; | ||
902 | + } | ||
903 | + if (chip->write_suspended && chip_state == FL_WRITING) { | ||
904 | + /* Write suspend occured while sleep: reset timeout */ | ||
905 | + timeo = reset_timeo; | ||
906 | + chip->write_suspended = 0; | ||
907 | + } | ||
908 | if (!timeo) { | ||
909 | map_write(map, CMD(0x70), cmd_adr); | ||
910 | chip->state = FL_STATUS; | ||
911 | @@ -1256,27 +1278,6 @@ static int inval_cache_and_wait_for_operation( | ||
912 | timeo--; | ||
913 | } | ||
914 | mutex_lock(&chip->mutex); | ||
915 | - | ||
916 | - while (chip->state != chip_state) { | ||
917 | - /* Someone's suspended the operation: sleep */ | ||
918 | - DECLARE_WAITQUEUE(wait, current); | ||
919 | - set_current_state(TASK_UNINTERRUPTIBLE); | ||
920 | - add_wait_queue(&chip->wq, &wait); | ||
921 | - mutex_unlock(&chip->mutex); | ||
922 | - schedule(); | ||
923 | - remove_wait_queue(&chip->wq, &wait); | ||
924 | - mutex_lock(&chip->mutex); | ||
925 | - } | ||
926 | - if (chip->erase_suspended && chip_state == FL_ERASING) { | ||
927 | - /* Erase suspend occured while sleep: reset timeout */ | ||
928 | - timeo = reset_timeo; | ||
929 | - chip->erase_suspended = 0; | ||
930 | - } | ||
931 | - if (chip->write_suspended && chip_state == FL_WRITING) { | ||
932 | - /* Write suspend occured while sleep: reset timeout */ | ||
933 | - timeo = reset_timeo; | ||
934 | - chip->write_suspended = 0; | ||
935 | - } | ||
936 | } | ||
937 | |||
938 | /* Done and happy. */ | ||
939 | diff --git a/drivers/mtd/chips/jedec_probe.c b/drivers/mtd/chips/jedec_probe.c | ||
940 | index d72a5fb..4e1be51 100644 | ||
941 | --- a/drivers/mtd/chips/jedec_probe.c | ||
942 | +++ b/drivers/mtd/chips/jedec_probe.c | ||
943 | @@ -1935,14 +1935,14 @@ static void jedec_reset(u32 base, struct map_info *map, struct cfi_private *cfi) | ||
944 | } | ||
945 | |||
946 | |||
947 | -static int cfi_jedec_setup(struct cfi_private *p_cfi, int index) | ||
948 | +static int cfi_jedec_setup(struct map_info *map, struct cfi_private *cfi, int index) | ||
949 | { | ||
950 | int i,num_erase_regions; | ||
951 | uint8_t uaddr; | ||
952 | |||
953 | - if (! (jedec_table[index].devtypes & p_cfi->device_type)) { | ||
954 | + if (!(jedec_table[index].devtypes & cfi->device_type)) { | ||
955 | DEBUG(MTD_DEBUG_LEVEL1, "Rejecting potential %s with incompatible %d-bit device type\n", | ||
956 | - jedec_table[index].name, 4 * (1<<p_cfi->device_type)); | ||
957 | + jedec_table[index].name, 4 * (1<<cfi->device_type)); | ||
958 | return 0; | ||
959 | } | ||
960 | |||
961 | @@ -1950,27 +1950,28 @@ static int cfi_jedec_setup(struct cfi_private *p_cfi, int index) | ||
962 | |||
963 | num_erase_regions = jedec_table[index].nr_regions; | ||
964 | |||
965 | - p_cfi->cfiq = kmalloc(sizeof(struct cfi_ident) + num_erase_regions * 4, GFP_KERNEL); | ||
966 | - if (!p_cfi->cfiq) { | ||
967 | + cfi->cfiq = kmalloc(sizeof(struct cfi_ident) + num_erase_regions * 4, GFP_KERNEL); | ||
968 | + if (!cfi->cfiq) { | ||
969 | //xx printk(KERN_WARNING "%s: kmalloc failed for CFI ident structure\n", map->name); | ||
970 | return 0; | ||
971 | } | ||
972 | |||
973 | - memset(p_cfi->cfiq,0,sizeof(struct cfi_ident)); | ||
974 | + memset(cfi->cfiq, 0, sizeof(struct cfi_ident)); | ||
975 | |||
976 | - p_cfi->cfiq->P_ID = jedec_table[index].cmd_set; | ||
977 | - p_cfi->cfiq->NumEraseRegions = jedec_table[index].nr_regions; | ||
978 | - p_cfi->cfiq->DevSize = jedec_table[index].dev_size; | ||
979 | - p_cfi->cfi_mode = CFI_MODE_JEDEC; | ||
980 | + cfi->cfiq->P_ID = jedec_table[index].cmd_set; | ||
981 | + cfi->cfiq->NumEraseRegions = jedec_table[index].nr_regions; | ||
982 | + cfi->cfiq->DevSize = jedec_table[index].dev_size; | ||
983 | + cfi->cfi_mode = CFI_MODE_JEDEC; | ||
984 | + cfi->sector_erase_cmd = CMD(0x30); | ||
985 | |||
986 | for (i=0; i<num_erase_regions; i++){ | ||
987 | - p_cfi->cfiq->EraseRegionInfo[i] = jedec_table[index].regions[i]; | ||
988 | + cfi->cfiq->EraseRegionInfo[i] = jedec_table[index].regions[i]; | ||
989 | } | ||
990 | - p_cfi->cmdset_priv = NULL; | ||
991 | + cfi->cmdset_priv = NULL; | ||
992 | |||
993 | /* This may be redundant for some cases, but it doesn't hurt */ | ||
994 | - p_cfi->mfr = jedec_table[index].mfr_id; | ||
995 | - p_cfi->id = jedec_table[index].dev_id; | ||
996 | + cfi->mfr = jedec_table[index].mfr_id; | ||
997 | + cfi->id = jedec_table[index].dev_id; | ||
998 | |||
999 | uaddr = jedec_table[index].uaddr; | ||
1000 | |||
1001 | @@ -1978,8 +1979,8 @@ static int cfi_jedec_setup(struct cfi_private *p_cfi, int index) | ||
1002 | our brains explode when we see the datasheets talking about address | ||
1003 | lines numbered from A-1 to A18. The CFI table has unlock addresses | ||
1004 | in device-words according to the mode the device is connected in */ | ||
1005 | - p_cfi->addr_unlock1 = unlock_addrs[uaddr].addr1 / p_cfi->device_type; | ||
1006 | - p_cfi->addr_unlock2 = unlock_addrs[uaddr].addr2 / p_cfi->device_type; | ||
1007 | + cfi->addr_unlock1 = unlock_addrs[uaddr].addr1 / cfi->device_type; | ||
1008 | + cfi->addr_unlock2 = unlock_addrs[uaddr].addr2 / cfi->device_type; | ||
1009 | |||
1010 | return 1; /* ok */ | ||
1011 | } | ||
1012 | @@ -2175,7 +2176,7 @@ static int jedec_probe_chip(struct map_info *map, __u32 base, | ||
1013 | "MTD %s(): matched device 0x%x,0x%x unlock_addrs: 0x%.4x 0x%.4x\n", | ||
1014 | __func__, cfi->mfr, cfi->id, | ||
1015 | cfi->addr_unlock1, cfi->addr_unlock2 ); | ||
1016 | - if (!cfi_jedec_setup(cfi, i)) | ||
1017 | + if (!cfi_jedec_setup(map, cfi, i)) | ||
1018 | return 0; | ||
1019 | goto ok_out; | ||
1020 | } | ||
1021 | diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c | ||
1022 | index cb20c67..e0a2373 100644 | ||
1023 | --- a/drivers/mtd/mtd_blkdevs.c | ||
1024 | +++ b/drivers/mtd/mtd_blkdevs.c | ||
1025 | @@ -413,7 +413,6 @@ error3: | ||
1026 | error2: | ||
1027 | list_del(&new->list); | ||
1028 | error1: | ||
1029 | - kfree(new); | ||
1030 | return ret; | ||
1031 | } | ||
1032 | |||
1033 | diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c | ||
1034 | index 15682ec..28af71c 100644 | ||
1035 | --- a/drivers/mtd/nand/omap2.c | ||
1036 | +++ b/drivers/mtd/nand/omap2.c | ||
1037 | @@ -968,6 +968,6 @@ static void __exit omap_nand_exit(void) | ||
1038 | module_init(omap_nand_init); | ||
1039 | module_exit(omap_nand_exit); | ||
1040 | |||
1041 | -MODULE_ALIAS(DRIVER_NAME); | ||
1042 | +MODULE_ALIAS("platform:" DRIVER_NAME); | ||
1043 | MODULE_LICENSE("GPL"); | ||
1044 | MODULE_DESCRIPTION("Glue layer for NAND flash on TI OMAP boards"); | ||
1045 | diff --git a/drivers/mtd/onenand/generic.c b/drivers/mtd/onenand/generic.c | ||
1046 | index e789149..ac08750 100644 | ||
1047 | --- a/drivers/mtd/onenand/generic.c | ||
1048 | +++ b/drivers/mtd/onenand/generic.c | ||
1049 | @@ -131,7 +131,7 @@ static struct platform_driver generic_onenand_driver = { | ||
1050 | .remove = __devexit_p(generic_onenand_remove), | ||
1051 | }; | ||
1052 | |||
1053 | -MODULE_ALIAS(DRIVER_NAME); | ||
1054 | +MODULE_ALIAS("platform:" DRIVER_NAME); | ||
1055 | |||
1056 | static int __init generic_onenand_init(void) | ||
1057 | { | ||
1058 | diff --git a/drivers/mtd/onenand/omap2.c b/drivers/mtd/onenand/omap2.c | ||
1059 | index 9f322f1..348ce71 100644 | ||
1060 | --- a/drivers/mtd/onenand/omap2.c | ||
1061 | +++ b/drivers/mtd/onenand/omap2.c | ||
1062 | @@ -815,7 +815,7 @@ static void __exit omap2_onenand_exit(void) | ||
1063 | module_init(omap2_onenand_init); | ||
1064 | module_exit(omap2_onenand_exit); | ||
1065 | |||
1066 | -MODULE_ALIAS(DRIVER_NAME); | ||
1067 | +MODULE_ALIAS("platform:" DRIVER_NAME); | ||
1068 | MODULE_LICENSE("GPL"); | ||
1069 | MODULE_AUTHOR("Jarkko Lavinen <jarkko.lavinen@nokia.com>"); | ||
1070 | MODULE_DESCRIPTION("Glue layer for OneNAND flash on OMAP2 / OMAP3"); | ||
1071 | diff --git a/drivers/net/ixgbe/ixgbe_common.c b/drivers/net/ixgbe/ixgbe_common.c | ||
1072 | index e3eca13..c7fee09 100644 | ||
1073 | --- a/drivers/net/ixgbe/ixgbe_common.c | ||
1074 | +++ b/drivers/net/ixgbe/ixgbe_common.c | ||
1075 | @@ -1292,6 +1292,9 @@ s32 ixgbe_init_rx_addrs_generic(struct ixgbe_hw *hw) | ||
1076 | hw_dbg(hw, " New MAC Addr =%pM\n", hw->mac.addr); | ||
1077 | |||
1078 | hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); | ||
1079 | + | ||
1080 | + /* clear VMDq pool/queue selection for RAR 0 */ | ||
1081 | + hw->mac.ops.clear_vmdq(hw, 0, IXGBE_CLEAR_VMDQ_ALL); | ||
1082 | } | ||
1083 | hw->addr_ctrl.overflow_promisc = 0; | ||
1084 | |||
1085 | diff --git a/drivers/net/ixgbe/ixgbe_fcoe.c b/drivers/net/ixgbe/ixgbe_fcoe.c | ||
1086 | index 05efa6a..d506434 100644 | ||
1087 | --- a/drivers/net/ixgbe/ixgbe_fcoe.c | ||
1088 | +++ b/drivers/net/ixgbe/ixgbe_fcoe.c | ||
1089 | @@ -151,7 +151,7 @@ int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid, | ||
1090 | struct scatterlist *sg; | ||
1091 | unsigned int i, j, dmacount; | ||
1092 | unsigned int len; | ||
1093 | - static const unsigned int bufflen = 4096; | ||
1094 | + static const unsigned int bufflen = IXGBE_FCBUFF_MIN; | ||
1095 | unsigned int firstoff = 0; | ||
1096 | unsigned int lastsize; | ||
1097 | unsigned int thisoff = 0; | ||
1098 | @@ -241,6 +241,24 @@ int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid, | ||
1099 | /* only the last buffer may have non-full bufflen */ | ||
1100 | lastsize = thisoff + thislen; | ||
1101 | |||
1102 | + /* | ||
1103 | + * lastsize can not be buffer len. | ||
1104 | + * If it is then adding another buffer with lastsize = 1. | ||
1105 | + */ | ||
1106 | + if (lastsize == bufflen) { | ||
1107 | + if (j >= IXGBE_BUFFCNT_MAX) { | ||
1108 | + e_err(drv, "xid=%x:%d,%d,%d:addr=%llx " | ||
1109 | + "not enough user buffers. We need an extra " | ||
1110 | + "buffer because lastsize is bufflen.\n", | ||
1111 | + xid, i, j, dmacount, (u64)addr); | ||
1112 | + goto out_noddp_free; | ||
1113 | + } | ||
1114 | + | ||
1115 | + ddp->udl[j] = (u64)(fcoe->extra_ddp_buffer_dma); | ||
1116 | + j++; | ||
1117 | + lastsize = 1; | ||
1118 | + } | ||
1119 | + | ||
1120 | fcbuff = (IXGBE_FCBUFF_4KB << IXGBE_FCBUFF_BUFFSIZE_SHIFT); | ||
1121 | fcbuff |= ((j & 0xff) << IXGBE_FCBUFF_BUFFCNT_SHIFT); | ||
1122 | fcbuff |= (firstoff << IXGBE_FCBUFF_OFFSET_SHIFT); | ||
1123 | @@ -519,6 +537,24 @@ void ixgbe_configure_fcoe(struct ixgbe_adapter *adapter) | ||
1124 | e_err(drv, "failed to allocated FCoE DDP pool\n"); | ||
1125 | |||
1126 | spin_lock_init(&fcoe->lock); | ||
1127 | + | ||
1128 | + /* Extra buffer to be shared by all DDPs for HW work around */ | ||
1129 | + fcoe->extra_ddp_buffer = kmalloc(IXGBE_FCBUFF_MIN, GFP_ATOMIC); | ||
1130 | + if (fcoe->extra_ddp_buffer == NULL) { | ||
1131 | + e_err(drv, "failed to allocated extra DDP buffer\n"); | ||
1132 | + goto out_extra_ddp_buffer_alloc; | ||
1133 | + } | ||
1134 | + | ||
1135 | + fcoe->extra_ddp_buffer_dma = | ||
1136 | + dma_map_single(&adapter->pdev->dev, | ||
1137 | + fcoe->extra_ddp_buffer, | ||
1138 | + IXGBE_FCBUFF_MIN, | ||
1139 | + DMA_FROM_DEVICE); | ||
1140 | + if (dma_mapping_error(&adapter->pdev->dev, | ||
1141 | + fcoe->extra_ddp_buffer_dma)) { | ||
1142 | + e_err(drv, "failed to map extra DDP buffer\n"); | ||
1143 | + goto out_extra_ddp_buffer_dma; | ||
1144 | + } | ||
1145 | } | ||
1146 | |||
1147 | /* Enable L2 eth type filter for FCoE */ | ||
1148 | @@ -568,6 +604,14 @@ void ixgbe_configure_fcoe(struct ixgbe_adapter *adapter) | ||
1149 | } | ||
1150 | } | ||
1151 | #endif | ||
1152 | + | ||
1153 | + return; | ||
1154 | + | ||
1155 | +out_extra_ddp_buffer_dma: | ||
1156 | + kfree(fcoe->extra_ddp_buffer); | ||
1157 | +out_extra_ddp_buffer_alloc: | ||
1158 | + pci_pool_destroy(fcoe->pool); | ||
1159 | + fcoe->pool = NULL; | ||
1160 | } | ||
1161 | |||
1162 | /** | ||
1163 | @@ -587,6 +631,11 @@ void ixgbe_cleanup_fcoe(struct ixgbe_adapter *adapter) | ||
1164 | if (fcoe->pool) { | ||
1165 | for (i = 0; i < IXGBE_FCOE_DDP_MAX; i++) | ||
1166 | ixgbe_fcoe_ddp_put(adapter->netdev, i); | ||
1167 | + dma_unmap_single(&adapter->pdev->dev, | ||
1168 | + fcoe->extra_ddp_buffer_dma, | ||
1169 | + IXGBE_FCBUFF_MIN, | ||
1170 | + DMA_FROM_DEVICE); | ||
1171 | + kfree(fcoe->extra_ddp_buffer); | ||
1172 | pci_pool_destroy(fcoe->pool); | ||
1173 | fcoe->pool = NULL; | ||
1174 | } | ||
1175 | diff --git a/drivers/net/ixgbe/ixgbe_fcoe.h b/drivers/net/ixgbe/ixgbe_fcoe.h | ||
1176 | index 4bc2c55..65cc8fb 100644 | ||
1177 | --- a/drivers/net/ixgbe/ixgbe_fcoe.h | ||
1178 | +++ b/drivers/net/ixgbe/ixgbe_fcoe.h | ||
1179 | @@ -70,6 +70,8 @@ struct ixgbe_fcoe { | ||
1180 | spinlock_t lock; | ||
1181 | struct pci_pool *pool; | ||
1182 | struct ixgbe_fcoe_ddp ddp[IXGBE_FCOE_DDP_MAX]; | ||
1183 | + unsigned char *extra_ddp_buffer; | ||
1184 | + dma_addr_t extra_ddp_buffer_dma; | ||
1185 | }; | ||
1186 | |||
1187 | #endif /* _IXGBE_FCOE_H */ | ||
1188 | diff --git a/drivers/net/ixgbe/ixgbe_sriov.c b/drivers/net/ixgbe/ixgbe_sriov.c | ||
1189 | index 5428153..960a2d6 100644 | ||
1190 | --- a/drivers/net/ixgbe/ixgbe_sriov.c | ||
1191 | +++ b/drivers/net/ixgbe/ixgbe_sriov.c | ||
1192 | @@ -110,12 +110,10 @@ static int ixgbe_set_vf_vlan(struct ixgbe_adapter *adapter, int add, int vid, | ||
1193 | return adapter->hw.mac.ops.set_vfta(&adapter->hw, vid, vf, (bool)add); | ||
1194 | } | ||
1195 | |||
1196 | - | ||
1197 | static void ixgbe_set_vmolr(struct ixgbe_hw *hw, u32 vf, bool aupe) | ||
1198 | { | ||
1199 | u32 vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf)); | ||
1200 | vmolr |= (IXGBE_VMOLR_ROMPE | | ||
1201 | - IXGBE_VMOLR_ROPE | | ||
1202 | IXGBE_VMOLR_BAM); | ||
1203 | if (aupe) | ||
1204 | vmolr |= IXGBE_VMOLR_AUPE; | ||
1205 | diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c | ||
1206 | index 5dcf140..0466f74 100644 | ||
1207 | --- a/drivers/net/wireless/ath/ath9k/hw.c | ||
1208 | +++ b/drivers/net/wireless/ath/ath9k/hw.c | ||
1209 | @@ -516,6 +516,17 @@ static int __ath9k_hw_init(struct ath_hw *ah) | ||
1210 | if (ah->hw_version.devid == AR5416_AR9100_DEVID) | ||
1211 | ah->hw_version.macVersion = AR_SREV_VERSION_9100; | ||
1212 | |||
1213 | + /* | ||
1214 | + * Read back AR_WA into a permanent copy and set bits 14 and 17. | ||
1215 | + * We need to do this to avoid RMW of this register. We cannot | ||
1216 | + * read the reg when chip is asleep. | ||
1217 | + */ | ||
1218 | + ah->WARegVal = REG_READ(ah, AR_WA); | ||
1219 | + ah->WARegVal |= (AR_WA_D3_L1_DISABLE | | ||
1220 | + AR_WA_ASPM_TIMER_BASED_DISABLE); | ||
1221 | + | ||
1222 | + ath9k_hw_read_revisions(ah); | ||
1223 | + | ||
1224 | if (!ath9k_hw_set_reset_reg(ah, ATH9K_RESET_POWER_ON)) { | ||
1225 | ath_print(common, ATH_DBG_FATAL, | ||
1226 | "Couldn't reset chip\n"); | ||
1227 | @@ -574,14 +585,6 @@ static int __ath9k_hw_init(struct ath_hw *ah) | ||
1228 | |||
1229 | ath9k_hw_init_mode_regs(ah); | ||
1230 | |||
1231 | - /* | ||
1232 | - * Read back AR_WA into a permanent copy and set bits 14 and 17. | ||
1233 | - * We need to do this to avoid RMW of this register. We cannot | ||
1234 | - * read the reg when chip is asleep. | ||
1235 | - */ | ||
1236 | - ah->WARegVal = REG_READ(ah, AR_WA); | ||
1237 | - ah->WARegVal |= (AR_WA_D3_L1_DISABLE | | ||
1238 | - AR_WA_ASPM_TIMER_BASED_DISABLE); | ||
1239 | |||
1240 | if (ah->is_pciexpress) | ||
1241 | ath9k_hw_configpcipowersave(ah, 0, 0); | ||
1242 | @@ -1089,8 +1092,6 @@ static bool ath9k_hw_set_reset_power_on(struct ath_hw *ah) | ||
1243 | return false; | ||
1244 | } | ||
1245 | |||
1246 | - ath9k_hw_read_revisions(ah); | ||
1247 | - | ||
1248 | return ath9k_hw_set_reset(ah, ATH9K_RESET_WARM); | ||
1249 | } | ||
1250 | |||
1251 | diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c | ||
1252 | index fdc2ec5..d6bbb57 100644 | ||
1253 | --- a/drivers/net/wireless/ath/ath9k/recv.c | ||
1254 | +++ b/drivers/net/wireless/ath/ath9k/recv.c | ||
1255 | @@ -439,9 +439,7 @@ u32 ath_calcrxfilter(struct ath_softc *sc) | ||
1256 | * mode interface or when in monitor mode. AP mode does not need this | ||
1257 | * since it receives all in-BSS frames anyway. | ||
1258 | */ | ||
1259 | - if (((sc->sc_ah->opmode != NL80211_IFTYPE_AP) && | ||
1260 | - (sc->rx.rxfilter & FIF_PROMISC_IN_BSS)) || | ||
1261 | - (sc->sc_ah->is_monitoring)) | ||
1262 | + if (sc->sc_ah->is_monitoring) | ||
1263 | rfilt |= ATH9K_RX_FILTER_PROM; | ||
1264 | |||
1265 | if (sc->rx.rxfilter & FIF_CONTROL) | ||
1266 | diff --git a/drivers/net/wireless/rt2x00/rt2x00dev.c b/drivers/net/wireless/rt2x00/rt2x00dev.c | ||
1267 | index d019830..06995b2 100644 | ||
1268 | --- a/drivers/net/wireless/rt2x00/rt2x00dev.c | ||
1269 | +++ b/drivers/net/wireless/rt2x00/rt2x00dev.c | ||
1270 | @@ -486,6 +486,10 @@ void rt2x00lib_rxdone(struct queue_entry *entry) | ||
1271 | unsigned int header_length; | ||
1272 | int rate_idx; | ||
1273 | |||
1274 | + if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) || | ||
1275 | + !test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) | ||
1276 | + goto submit_entry; | ||
1277 | + | ||
1278 | if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags)) | ||
1279 | goto submit_entry; | ||
1280 | |||
1281 | @@ -570,9 +574,13 @@ void rt2x00lib_rxdone(struct queue_entry *entry) | ||
1282 | entry->skb = skb; | ||
1283 | |||
1284 | submit_entry: | ||
1285 | - rt2x00dev->ops->lib->clear_entry(entry); | ||
1286 | - rt2x00queue_index_inc(entry->queue, Q_INDEX); | ||
1287 | + entry->flags = 0; | ||
1288 | rt2x00queue_index_inc(entry->queue, Q_INDEX_DONE); | ||
1289 | + if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) && | ||
1290 | + test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) { | ||
1291 | + rt2x00dev->ops->lib->clear_entry(entry); | ||
1292 | + rt2x00queue_index_inc(entry->queue, Q_INDEX); | ||
1293 | + } | ||
1294 | } | ||
1295 | EXPORT_SYMBOL_GPL(rt2x00lib_rxdone); | ||
1296 | |||
1297 | diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c | ||
1298 | index b3317df..051758f 100644 | ||
1299 | --- a/drivers/net/wireless/rt2x00/rt2x00usb.c | ||
1300 | +++ b/drivers/net/wireless/rt2x00/rt2x00usb.c | ||
1301 | @@ -226,9 +226,7 @@ static void rt2x00usb_interrupt_txdone(struct urb *urb) | ||
1302 | * Schedule the delayed work for reading the TX status | ||
1303 | * from the device. | ||
1304 | */ | ||
1305 | - if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) && | ||
1306 | - test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) | ||
1307 | - ieee80211_queue_work(rt2x00dev->hw, &rt2x00dev->txdone_work); | ||
1308 | + ieee80211_queue_work(rt2x00dev->hw, &rt2x00dev->txdone_work); | ||
1309 | } | ||
1310 | |||
1311 | static void rt2x00usb_kick_tx_entry(struct queue_entry *entry) | ||
1312 | @@ -237,6 +235,7 @@ static void rt2x00usb_kick_tx_entry(struct queue_entry *entry) | ||
1313 | struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev); | ||
1314 | struct queue_entry_priv_usb *entry_priv = entry->priv_data; | ||
1315 | u32 length; | ||
1316 | + int status; | ||
1317 | |||
1318 | if (!test_and_clear_bit(ENTRY_DATA_PENDING, &entry->flags)) | ||
1319 | return; | ||
1320 | @@ -253,7 +252,10 @@ static void rt2x00usb_kick_tx_entry(struct queue_entry *entry) | ||
1321 | entry->skb->data, length, | ||
1322 | rt2x00usb_interrupt_txdone, entry); | ||
1323 | |||
1324 | - if (usb_submit_urb(entry_priv->urb, GFP_ATOMIC)) { | ||
1325 | + status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC); | ||
1326 | + if (status) { | ||
1327 | + if (status == -ENODEV) | ||
1328 | + clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags); | ||
1329 | set_bit(ENTRY_DATA_IO_FAILED, &entry->flags); | ||
1330 | rt2x00lib_dmadone(entry); | ||
1331 | } | ||
1332 | @@ -424,9 +426,7 @@ static void rt2x00usb_interrupt_rxdone(struct urb *urb) | ||
1333 | * Schedule the delayed work for reading the RX status | ||
1334 | * from the device. | ||
1335 | */ | ||
1336 | - if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) && | ||
1337 | - test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) | ||
1338 | - ieee80211_queue_work(rt2x00dev->hw, &rt2x00dev->rxdone_work); | ||
1339 | + ieee80211_queue_work(rt2x00dev->hw, &rt2x00dev->rxdone_work); | ||
1340 | } | ||
1341 | |||
1342 | /* | ||
1343 | @@ -454,6 +454,7 @@ void rt2x00usb_clear_entry(struct queue_entry *entry) | ||
1344 | to_usb_device_intf(entry->queue->rt2x00dev->dev); | ||
1345 | struct queue_entry_priv_usb *entry_priv = entry->priv_data; | ||
1346 | int pipe; | ||
1347 | + int status; | ||
1348 | |||
1349 | entry->flags = 0; | ||
1350 | |||
1351 | @@ -464,7 +465,12 @@ void rt2x00usb_clear_entry(struct queue_entry *entry) | ||
1352 | rt2x00usb_interrupt_rxdone, entry); | ||
1353 | |||
1354 | set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags); | ||
1355 | - if (usb_submit_urb(entry_priv->urb, GFP_ATOMIC)) { | ||
1356 | + | ||
1357 | + status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC); | ||
1358 | + if (status) { | ||
1359 | + if (status == -ENODEV) | ||
1360 | + clear_bit(DEVICE_STATE_PRESENT, | ||
1361 | + &entry->queue->rt2x00dev->flags); | ||
1362 | set_bit(ENTRY_DATA_IO_FAILED, &entry->flags); | ||
1363 | rt2x00lib_dmadone(entry); | ||
1364 | } | ||
1365 | diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c | ||
1366 | index 1539d2c..6020580 100644 | ||
1367 | --- a/drivers/pci/pci-sysfs.c | ||
1368 | +++ b/drivers/pci/pci-sysfs.c | ||
1369 | @@ -1088,7 +1088,7 @@ static int pci_create_capabilities_sysfs(struct pci_dev *dev) | ||
1370 | attr->write = write_vpd_attr; | ||
1371 | retval = sysfs_create_bin_file(&dev->dev.kobj, attr); | ||
1372 | if (retval) { | ||
1373 | - kfree(dev->vpd->attr); | ||
1374 | + kfree(attr); | ||
1375 | return retval; | ||
1376 | } | ||
1377 | dev->vpd->attr = attr; | ||
1378 | diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c | ||
1379 | index 53a786f..bd80f63 100644 | ||
1380 | --- a/drivers/pci/quirks.c | ||
1381 | +++ b/drivers/pci/quirks.c | ||
1382 | @@ -533,6 +533,17 @@ static void __devinit quirk_piix4_acpi(struct pci_dev *dev) | ||
1383 | DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, quirk_piix4_acpi); | ||
1384 | DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443MX_3, quirk_piix4_acpi); | ||
1385 | |||
1386 | +#define ICH_PMBASE 0x40 | ||
1387 | +#define ICH_ACPI_CNTL 0x44 | ||
1388 | +#define ICH4_ACPI_EN 0x10 | ||
1389 | +#define ICH6_ACPI_EN 0x80 | ||
1390 | +#define ICH4_GPIOBASE 0x58 | ||
1391 | +#define ICH4_GPIO_CNTL 0x5c | ||
1392 | +#define ICH4_GPIO_EN 0x10 | ||
1393 | +#define ICH6_GPIOBASE 0x48 | ||
1394 | +#define ICH6_GPIO_CNTL 0x4c | ||
1395 | +#define ICH6_GPIO_EN 0x10 | ||
1396 | + | ||
1397 | /* | ||
1398 | * ICH4, ICH4-M, ICH5, ICH5-M ACPI: Three IO regions pointed to by longwords at | ||
1399 | * 0x40 (128 bytes of ACPI, GPIO & TCO registers) | ||
1400 | @@ -541,12 +552,33 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443MX_3, qui | ||
1401 | static void __devinit quirk_ich4_lpc_acpi(struct pci_dev *dev) | ||
1402 | { | ||
1403 | u32 region; | ||
1404 | + u8 enable; | ||
1405 | |||
1406 | - pci_read_config_dword(dev, 0x40, ®ion); | ||
1407 | - quirk_io_region(dev, region, 128, PCI_BRIDGE_RESOURCES, "ICH4 ACPI/GPIO/TCO"); | ||
1408 | + /* | ||
1409 | + * The check for PCIBIOS_MIN_IO is to ensure we won't create a conflict | ||
1410 | + * with low legacy (and fixed) ports. We don't know the decoding | ||
1411 | + * priority and can't tell whether the legacy device or the one created | ||
1412 | + * here is really at that address. This happens on boards with broken | ||
1413 | + * BIOSes. | ||
1414 | + */ | ||
1415 | + | ||
1416 | + pci_read_config_byte(dev, ICH_ACPI_CNTL, &enable); | ||
1417 | + if (enable & ICH4_ACPI_EN) { | ||
1418 | + pci_read_config_dword(dev, ICH_PMBASE, ®ion); | ||
1419 | + region &= PCI_BASE_ADDRESS_IO_MASK; | ||
1420 | + if (region >= PCIBIOS_MIN_IO) | ||
1421 | + quirk_io_region(dev, region, 128, PCI_BRIDGE_RESOURCES, | ||
1422 | + "ICH4 ACPI/GPIO/TCO"); | ||
1423 | + } | ||
1424 | |||
1425 | - pci_read_config_dword(dev, 0x58, ®ion); | ||
1426 | - quirk_io_region(dev, region, 64, PCI_BRIDGE_RESOURCES+1, "ICH4 GPIO"); | ||
1427 | + pci_read_config_byte(dev, ICH4_GPIO_CNTL, &enable); | ||
1428 | + if (enable & ICH4_GPIO_EN) { | ||
1429 | + pci_read_config_dword(dev, ICH4_GPIOBASE, ®ion); | ||
1430 | + region &= PCI_BASE_ADDRESS_IO_MASK; | ||
1431 | + if (region >= PCIBIOS_MIN_IO) | ||
1432 | + quirk_io_region(dev, region, 64, | ||
1433 | + PCI_BRIDGE_RESOURCES + 1, "ICH4 GPIO"); | ||
1434 | + } | ||
1435 | } | ||
1436 | DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_0, quirk_ich4_lpc_acpi); | ||
1437 | DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_0, quirk_ich4_lpc_acpi); | ||
1438 | @@ -562,12 +594,25 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_1, qui | ||
1439 | static void __devinit ich6_lpc_acpi_gpio(struct pci_dev *dev) | ||
1440 | { | ||
1441 | u32 region; | ||
1442 | + u8 enable; | ||
1443 | |||
1444 | - pci_read_config_dword(dev, 0x40, ®ion); | ||
1445 | - quirk_io_region(dev, region, 128, PCI_BRIDGE_RESOURCES, "ICH6 ACPI/GPIO/TCO"); | ||
1446 | + pci_read_config_byte(dev, ICH_ACPI_CNTL, &enable); | ||
1447 | + if (enable & ICH6_ACPI_EN) { | ||
1448 | + pci_read_config_dword(dev, ICH_PMBASE, ®ion); | ||
1449 | + region &= PCI_BASE_ADDRESS_IO_MASK; | ||
1450 | + if (region >= PCIBIOS_MIN_IO) | ||
1451 | + quirk_io_region(dev, region, 128, PCI_BRIDGE_RESOURCES, | ||
1452 | + "ICH6 ACPI/GPIO/TCO"); | ||
1453 | + } | ||
1454 | |||
1455 | - pci_read_config_dword(dev, 0x48, ®ion); | ||
1456 | - quirk_io_region(dev, region, 64, PCI_BRIDGE_RESOURCES+1, "ICH6 GPIO"); | ||
1457 | + pci_read_config_byte(dev, ICH6_GPIO_CNTL, &enable); | ||
1458 | + if (enable & ICH4_GPIO_EN) { | ||
1459 | + pci_read_config_dword(dev, ICH6_GPIOBASE, ®ion); | ||
1460 | + region &= PCI_BASE_ADDRESS_IO_MASK; | ||
1461 | + if (region >= PCIBIOS_MIN_IO) | ||
1462 | + quirk_io_region(dev, region, 64, | ||
1463 | + PCI_BRIDGE_RESOURCES + 1, "ICH6 GPIO"); | ||
1464 | + } | ||
1465 | } | ||
1466 | |||
1467 | static void __devinit ich6_lpc_generic_decode(struct pci_dev *dev, unsigned reg, const char *name, int dynsize) | ||
1468 | @@ -2618,58 +2663,6 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x4375, | ||
1469 | |||
1470 | #endif /* CONFIG_PCI_MSI */ | ||
1471 | |||
1472 | -#ifdef CONFIG_PCI_IOV | ||
1473 | - | ||
1474 | -/* | ||
1475 | - * For Intel 82576 SR-IOV NIC, if BIOS doesn't allocate resources for the | ||
1476 | - * SR-IOV BARs, zero the Flash BAR and program the SR-IOV BARs to use the | ||
1477 | - * old Flash Memory Space. | ||
1478 | - */ | ||
1479 | -static void __devinit quirk_i82576_sriov(struct pci_dev *dev) | ||
1480 | -{ | ||
1481 | - int pos, flags; | ||
1482 | - u32 bar, start, size; | ||
1483 | - | ||
1484 | - if (PAGE_SIZE > 0x10000) | ||
1485 | - return; | ||
1486 | - | ||
1487 | - flags = pci_resource_flags(dev, 0); | ||
1488 | - if ((flags & PCI_BASE_ADDRESS_SPACE) != | ||
1489 | - PCI_BASE_ADDRESS_SPACE_MEMORY || | ||
1490 | - (flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK) != | ||
1491 | - PCI_BASE_ADDRESS_MEM_TYPE_32) | ||
1492 | - return; | ||
1493 | - | ||
1494 | - pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV); | ||
1495 | - if (!pos) | ||
1496 | - return; | ||
1497 | - | ||
1498 | - pci_read_config_dword(dev, pos + PCI_SRIOV_BAR, &bar); | ||
1499 | - if (bar & PCI_BASE_ADDRESS_MEM_MASK) | ||
1500 | - return; | ||
1501 | - | ||
1502 | - start = pci_resource_start(dev, 1); | ||
1503 | - size = pci_resource_len(dev, 1); | ||
1504 | - if (!start || size != 0x400000 || start & (size - 1)) | ||
1505 | - return; | ||
1506 | - | ||
1507 | - pci_resource_flags(dev, 1) = 0; | ||
1508 | - pci_write_config_dword(dev, PCI_BASE_ADDRESS_1, 0); | ||
1509 | - pci_write_config_dword(dev, pos + PCI_SRIOV_BAR, start); | ||
1510 | - pci_write_config_dword(dev, pos + PCI_SRIOV_BAR + 12, start + size / 2); | ||
1511 | - | ||
1512 | - dev_info(&dev->dev, "use Flash Memory Space for SR-IOV BARs\n"); | ||
1513 | -} | ||
1514 | -DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x10c9, quirk_i82576_sriov); | ||
1515 | -DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x10e6, quirk_i82576_sriov); | ||
1516 | -DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x10e7, quirk_i82576_sriov); | ||
1517 | -DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x10e8, quirk_i82576_sriov); | ||
1518 | -DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x150a, quirk_i82576_sriov); | ||
1519 | -DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x150d, quirk_i82576_sriov); | ||
1520 | -DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x1518, quirk_i82576_sriov); | ||
1521 | - | ||
1522 | -#endif /* CONFIG_PCI_IOV */ | ||
1523 | - | ||
1524 | /* Allow manual resource allocation for PCI hotplug bridges | ||
1525 | * via pci=hpmemsize=nnM and pci=hpiosize=nnM parameters. For | ||
1526 | * some PCI-PCI hotplug bridges, like PLX 6254 (former HINT HB6), | ||
1527 | diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c | ||
1528 | index 6b72932..30f2b33 100644 | ||
1529 | --- a/drivers/scsi/device_handler/scsi_dh_alua.c | ||
1530 | +++ b/drivers/scsi/device_handler/scsi_dh_alua.c | ||
1531 | @@ -285,7 +285,8 @@ static void stpg_endio(struct request *req, int error) | ||
1532 | print_alua_state(h->state)); | ||
1533 | } | ||
1534 | done: | ||
1535 | - blk_put_request(req); | ||
1536 | + req->end_io_data = NULL; | ||
1537 | + __blk_put_request(req->q, req); | ||
1538 | if (h->callback_fn) { | ||
1539 | h->callback_fn(h->callback_data, err); | ||
1540 | h->callback_fn = h->callback_data = NULL; | ||
1541 | diff --git a/drivers/staging/tidspbridge/rmgr/proc.c b/drivers/staging/tidspbridge/rmgr/proc.c | ||
1542 | index b47d7aa..e2fe165 100644 | ||
1543 | --- a/drivers/staging/tidspbridge/rmgr/proc.c | ||
1544 | +++ b/drivers/staging/tidspbridge/rmgr/proc.c | ||
1545 | @@ -781,12 +781,14 @@ int proc_begin_dma(void *hprocessor, void *pmpu_addr, u32 ul_size, | ||
1546 | (u32)pmpu_addr, | ||
1547 | ul_size, dir); | ||
1548 | |||
1549 | + mutex_lock(&proc_lock); | ||
1550 | + | ||
1551 | /* find requested memory are in cached mapping information */ | ||
1552 | map_obj = find_containing_mapping(pr_ctxt, (u32) pmpu_addr, ul_size); | ||
1553 | if (!map_obj) { | ||
1554 | pr_err("%s: find_containing_mapping failed\n", __func__); | ||
1555 | status = -EFAULT; | ||
1556 | - goto err_out; | ||
1557 | + goto no_map; | ||
1558 | } | ||
1559 | |||
1560 | if (memory_give_ownership(map_obj, (u32) pmpu_addr, ul_size, dir)) { | ||
1561 | @@ -795,6 +797,8 @@ int proc_begin_dma(void *hprocessor, void *pmpu_addr, u32 ul_size, | ||
1562 | status = -EFAULT; | ||
1563 | } | ||
1564 | |||
1565 | +no_map: | ||
1566 | + mutex_unlock(&proc_lock); | ||
1567 | err_out: | ||
1568 | |||
1569 | return status; | ||
1570 | @@ -819,21 +823,24 @@ int proc_end_dma(void *hprocessor, void *pmpu_addr, u32 ul_size, | ||
1571 | (u32)pmpu_addr, | ||
1572 | ul_size, dir); | ||
1573 | |||
1574 | + mutex_lock(&proc_lock); | ||
1575 | + | ||
1576 | /* find requested memory are in cached mapping information */ | ||
1577 | map_obj = find_containing_mapping(pr_ctxt, (u32) pmpu_addr, ul_size); | ||
1578 | if (!map_obj) { | ||
1579 | pr_err("%s: find_containing_mapping failed\n", __func__); | ||
1580 | status = -EFAULT; | ||
1581 | - goto err_out; | ||
1582 | + goto no_map; | ||
1583 | } | ||
1584 | |||
1585 | if (memory_regain_ownership(map_obj, (u32) pmpu_addr, ul_size, dir)) { | ||
1586 | pr_err("%s: InValid address parameters %p %x\n", | ||
1587 | __func__, pmpu_addr, ul_size); | ||
1588 | status = -EFAULT; | ||
1589 | - goto err_out; | ||
1590 | } | ||
1591 | |||
1592 | +no_map: | ||
1593 | + mutex_unlock(&proc_lock); | ||
1594 | err_out: | ||
1595 | return status; | ||
1596 | } | ||
1597 | @@ -1726,9 +1733,8 @@ int proc_un_map(void *hprocessor, void *map_addr, | ||
1598 | (p_proc_object->hbridge_context, va_align, size_align); | ||
1599 | } | ||
1600 | |||
1601 | - mutex_unlock(&proc_lock); | ||
1602 | if (status) | ||
1603 | - goto func_end; | ||
1604 | + goto unmap_failed; | ||
1605 | |||
1606 | /* | ||
1607 | * A successful unmap should be followed by removal of map_obj | ||
1608 | @@ -1737,6 +1743,9 @@ int proc_un_map(void *hprocessor, void *map_addr, | ||
1609 | */ | ||
1610 | remove_mapping_information(pr_ctxt, (u32) map_addr, size_align); | ||
1611 | |||
1612 | +unmap_failed: | ||
1613 | + mutex_unlock(&proc_lock); | ||
1614 | + | ||
1615 | func_end: | ||
1616 | dev_dbg(bridge, "%s: hprocessor: 0x%p map_addr: 0x%p status: 0x%x\n", | ||
1617 | __func__, hprocessor, map_addr, status); | ||
1618 | diff --git a/drivers/staging/winbond/core.h b/drivers/staging/winbond/core.h | ||
1619 | index 2b87a00..7f06e26 100644 | ||
1620 | --- a/drivers/staging/winbond/core.h | ||
1621 | +++ b/drivers/staging/winbond/core.h | ||
1622 | @@ -3,6 +3,7 @@ | ||
1623 | |||
1624 | #include <linux/wireless.h> | ||
1625 | #include <linux/types.h> | ||
1626 | +#include <linux/delay.h> | ||
1627 | |||
1628 | #include "wbhal_s.h" | ||
1629 | #include "mto.h" | ||
1630 | diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c | ||
1631 | index 4de52dc..b1e1880 100644 | ||
1632 | --- a/drivers/usb/core/hcd-pci.c | ||
1633 | +++ b/drivers/usb/core/hcd-pci.c | ||
1634 | @@ -364,8 +364,7 @@ static int check_root_hub_suspended(struct device *dev) | ||
1635 | struct pci_dev *pci_dev = to_pci_dev(dev); | ||
1636 | struct usb_hcd *hcd = pci_get_drvdata(pci_dev); | ||
1637 | |||
1638 | - if (!(hcd->state == HC_STATE_SUSPENDED || | ||
1639 | - hcd->state == HC_STATE_HALT)) { | ||
1640 | + if (HCD_RH_RUNNING(hcd)) { | ||
1641 | dev_warn(dev, "Root hub is not suspended\n"); | ||
1642 | return -EBUSY; | ||
1643 | } | ||
1644 | @@ -387,7 +386,7 @@ static int suspend_common(struct device *dev, bool do_wakeup) | ||
1645 | if (retval) | ||
1646 | return retval; | ||
1647 | |||
1648 | - if (hcd->driver->pci_suspend) { | ||
1649 | + if (hcd->driver->pci_suspend && !HCD_DEAD(hcd)) { | ||
1650 | /* Optimization: Don't suspend if a root-hub wakeup is | ||
1651 | * pending and it would cause the HCD to wake up anyway. | ||
1652 | */ | ||
1653 | @@ -428,7 +427,7 @@ static int resume_common(struct device *dev, int event) | ||
1654 | struct usb_hcd *hcd = pci_get_drvdata(pci_dev); | ||
1655 | int retval; | ||
1656 | |||
1657 | - if (hcd->state != HC_STATE_SUSPENDED) { | ||
1658 | + if (HCD_RH_RUNNING(hcd)) { | ||
1659 | dev_dbg(dev, "can't resume, not suspended!\n"); | ||
1660 | return 0; | ||
1661 | } | ||
1662 | @@ -443,7 +442,7 @@ static int resume_common(struct device *dev, int event) | ||
1663 | |||
1664 | clear_bit(HCD_FLAG_SAW_IRQ, &hcd->flags); | ||
1665 | |||
1666 | - if (hcd->driver->pci_resume) { | ||
1667 | + if (hcd->driver->pci_resume && !HCD_DEAD(hcd)) { | ||
1668 | if (event != PM_EVENT_AUTO_RESUME) | ||
1669 | wait_for_companions(pci_dev, hcd); | ||
1670 | |||
1671 | @@ -476,10 +475,10 @@ static int hcd_pci_suspend_noirq(struct device *dev) | ||
1672 | |||
1673 | pci_save_state(pci_dev); | ||
1674 | |||
1675 | - /* If the root hub is HALTed rather than SUSPENDed, | ||
1676 | + /* If the root hub is dead rather than suspended, | ||
1677 | * disallow remote wakeup. | ||
1678 | */ | ||
1679 | - if (hcd->state == HC_STATE_HALT) | ||
1680 | + if (HCD_DEAD(hcd)) | ||
1681 | device_set_wakeup_enable(dev, 0); | ||
1682 | dev_dbg(dev, "wakeup: %d\n", device_may_wakeup(dev)); | ||
1683 | |||
1684 | diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c | ||
1685 | index 8aa6b51..d2c10d0 100644 | ||
1686 | --- a/drivers/usb/core/hcd.c | ||
1687 | +++ b/drivers/usb/core/hcd.c | ||
1688 | @@ -984,7 +984,7 @@ static int register_root_hub(struct usb_hcd *hcd) | ||
1689 | spin_unlock_irq (&hcd_root_hub_lock); | ||
1690 | |||
1691 | /* Did the HC die before the root hub was registered? */ | ||
1692 | - if (hcd->state == HC_STATE_HALT) | ||
1693 | + if (HCD_DEAD(hcd) || hcd->state == HC_STATE_HALT) | ||
1694 | usb_hc_died (hcd); /* This time clean up */ | ||
1695 | } | ||
1696 | |||
1697 | @@ -1090,13 +1090,10 @@ int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb) | ||
1698 | * Check the host controller's state and add the URB to the | ||
1699 | * endpoint's queue. | ||
1700 | */ | ||
1701 | - switch (hcd->state) { | ||
1702 | - case HC_STATE_RUNNING: | ||
1703 | - case HC_STATE_RESUMING: | ||
1704 | + if (HCD_RH_RUNNING(hcd)) { | ||
1705 | urb->unlinked = 0; | ||
1706 | list_add_tail(&urb->urb_list, &urb->ep->urb_list); | ||
1707 | - break; | ||
1708 | - default: | ||
1709 | + } else { | ||
1710 | rc = -ESHUTDOWN; | ||
1711 | goto done; | ||
1712 | } | ||
1713 | @@ -1914,7 +1911,7 @@ int usb_hcd_get_frame_number (struct usb_device *udev) | ||
1714 | { | ||
1715 | struct usb_hcd *hcd = bus_to_hcd(udev->bus); | ||
1716 | |||
1717 | - if (!HC_IS_RUNNING (hcd->state)) | ||
1718 | + if (!HCD_RH_RUNNING(hcd)) | ||
1719 | return -ESHUTDOWN; | ||
1720 | return hcd->driver->get_frame_number (hcd); | ||
1721 | } | ||
1722 | @@ -1931,9 +1928,15 @@ int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg) | ||
1723 | |||
1724 | dev_dbg(&rhdev->dev, "bus %s%s\n", | ||
1725 | (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "suspend"); | ||
1726 | + if (HCD_DEAD(hcd)) { | ||
1727 | + dev_dbg(&rhdev->dev, "skipped %s of dead bus\n", "suspend"); | ||
1728 | + return 0; | ||
1729 | + } | ||
1730 | + | ||
1731 | if (!hcd->driver->bus_suspend) { | ||
1732 | status = -ENOENT; | ||
1733 | } else { | ||
1734 | + clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags); | ||
1735 | hcd->state = HC_STATE_QUIESCING; | ||
1736 | status = hcd->driver->bus_suspend(hcd); | ||
1737 | } | ||
1738 | @@ -1941,7 +1944,12 @@ int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg) | ||
1739 | usb_set_device_state(rhdev, USB_STATE_SUSPENDED); | ||
1740 | hcd->state = HC_STATE_SUSPENDED; | ||
1741 | } else { | ||
1742 | - hcd->state = old_state; | ||
1743 | + spin_lock_irq(&hcd_root_hub_lock); | ||
1744 | + if (!HCD_DEAD(hcd)) { | ||
1745 | + set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags); | ||
1746 | + hcd->state = old_state; | ||
1747 | + } | ||
1748 | + spin_unlock_irq(&hcd_root_hub_lock); | ||
1749 | dev_dbg(&rhdev->dev, "bus %s fail, err %d\n", | ||
1750 | "suspend", status); | ||
1751 | } | ||
1752 | @@ -1956,9 +1964,13 @@ int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg) | ||
1753 | |||
1754 | dev_dbg(&rhdev->dev, "usb %s%s\n", | ||
1755 | (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "resume"); | ||
1756 | + if (HCD_DEAD(hcd)) { | ||
1757 | + dev_dbg(&rhdev->dev, "skipped %s of dead bus\n", "resume"); | ||
1758 | + return 0; | ||
1759 | + } | ||
1760 | if (!hcd->driver->bus_resume) | ||
1761 | return -ENOENT; | ||
1762 | - if (hcd->state == HC_STATE_RUNNING) | ||
1763 | + if (HCD_RH_RUNNING(hcd)) | ||
1764 | return 0; | ||
1765 | |||
1766 | hcd->state = HC_STATE_RESUMING; | ||
1767 | @@ -1967,10 +1979,15 @@ int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg) | ||
1768 | if (status == 0) { | ||
1769 | /* TRSMRCY = 10 msec */ | ||
1770 | msleep(10); | ||
1771 | - usb_set_device_state(rhdev, rhdev->actconfig | ||
1772 | - ? USB_STATE_CONFIGURED | ||
1773 | - : USB_STATE_ADDRESS); | ||
1774 | - hcd->state = HC_STATE_RUNNING; | ||
1775 | + spin_lock_irq(&hcd_root_hub_lock); | ||
1776 | + if (!HCD_DEAD(hcd)) { | ||
1777 | + usb_set_device_state(rhdev, rhdev->actconfig | ||
1778 | + ? USB_STATE_CONFIGURED | ||
1779 | + : USB_STATE_ADDRESS); | ||
1780 | + set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags); | ||
1781 | + hcd->state = HC_STATE_RUNNING; | ||
1782 | + } | ||
1783 | + spin_unlock_irq(&hcd_root_hub_lock); | ||
1784 | } else { | ||
1785 | hcd->state = old_state; | ||
1786 | dev_dbg(&rhdev->dev, "bus %s fail, err %d\n", | ||
1787 | @@ -2081,7 +2098,7 @@ irqreturn_t usb_hcd_irq (int irq, void *__hcd) | ||
1788 | */ | ||
1789 | local_irq_save(flags); | ||
1790 | |||
1791 | - if (unlikely(hcd->state == HC_STATE_HALT || !HCD_HW_ACCESSIBLE(hcd))) { | ||
1792 | + if (unlikely(HCD_DEAD(hcd) || !HCD_HW_ACCESSIBLE(hcd))) { | ||
1793 | rc = IRQ_NONE; | ||
1794 | } else if (hcd->driver->irq(hcd) == IRQ_NONE) { | ||
1795 | rc = IRQ_NONE; | ||
1796 | @@ -2115,6 +2132,8 @@ void usb_hc_died (struct usb_hcd *hcd) | ||
1797 | dev_err (hcd->self.controller, "HC died; cleaning up\n"); | ||
1798 | |||
1799 | spin_lock_irqsave (&hcd_root_hub_lock, flags); | ||
1800 | + clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags); | ||
1801 | + set_bit(HCD_FLAG_DEAD, &hcd->flags); | ||
1802 | if (hcd->rh_registered) { | ||
1803 | clear_bit(HCD_FLAG_POLL_RH, &hcd->flags); | ||
1804 | |||
1805 | @@ -2257,6 +2276,12 @@ int usb_add_hcd(struct usb_hcd *hcd, | ||
1806 | */ | ||
1807 | device_init_wakeup(&rhdev->dev, 1); | ||
1808 | |||
1809 | + /* HCD_FLAG_RH_RUNNING doesn't matter until the root hub is | ||
1810 | + * registered. But since the controller can die at any time, | ||
1811 | + * let's initialize the flag before touching the hardware. | ||
1812 | + */ | ||
1813 | + set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags); | ||
1814 | + | ||
1815 | /* "reset" is misnamed; its role is now one-time init. the controller | ||
1816 | * should already have been reset (and boot firmware kicked off etc). | ||
1817 | */ | ||
1818 | @@ -2324,6 +2349,7 @@ int usb_add_hcd(struct usb_hcd *hcd, | ||
1819 | return retval; | ||
1820 | |||
1821 | error_create_attr_group: | ||
1822 | + clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags); | ||
1823 | if (HC_IS_RUNNING(hcd->state)) | ||
1824 | hcd->state = HC_STATE_QUIESCING; | ||
1825 | spin_lock_irq(&hcd_root_hub_lock); | ||
1826 | @@ -2376,6 +2402,7 @@ void usb_remove_hcd(struct usb_hcd *hcd) | ||
1827 | usb_get_dev(rhdev); | ||
1828 | sysfs_remove_group(&rhdev->dev.kobj, &usb_bus_attr_group); | ||
1829 | |||
1830 | + clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags); | ||
1831 | if (HC_IS_RUNNING (hcd->state)) | ||
1832 | hcd->state = HC_STATE_QUIESCING; | ||
1833 | |||
1834 | diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c | ||
1835 | index c14fc08..ae334b0 100644 | ||
1836 | --- a/drivers/usb/core/urb.c | ||
1837 | +++ b/drivers/usb/core/urb.c | ||
1838 | @@ -366,7 +366,16 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags) | ||
1839 | if (xfertype == USB_ENDPOINT_XFER_ISOC) { | ||
1840 | int n, len; | ||
1841 | |||
1842 | - /* FIXME SuperSpeed isoc endpoints have up to 16 bursts */ | ||
1843 | + /* SuperSpeed isoc endpoints have up to 16 bursts of up to | ||
1844 | + * 3 packets each | ||
1845 | + */ | ||
1846 | + if (dev->speed == USB_SPEED_SUPER) { | ||
1847 | + int burst = 1 + ep->ss_ep_comp.bMaxBurst; | ||
1848 | + int mult = USB_SS_MULT(ep->ss_ep_comp.bmAttributes); | ||
1849 | + max *= burst; | ||
1850 | + max *= mult; | ||
1851 | + } | ||
1852 | + | ||
1853 | /* "high bandwidth" mode, 1-3 packets/uframe? */ | ||
1854 | if (dev->speed == USB_SPEED_HIGH) { | ||
1855 | int mult = 1 + ((max >> 11) & 0x03); | ||
1856 | diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c | ||
1857 | index 8a515f0..72ae77c 100644 | ||
1858 | --- a/drivers/usb/host/ehci-hub.c | ||
1859 | +++ b/drivers/usb/host/ehci-hub.c | ||
1860 | @@ -106,6 +106,27 @@ static void ehci_handover_companion_ports(struct ehci_hcd *ehci) | ||
1861 | ehci->owned_ports = 0; | ||
1862 | } | ||
1863 | |||
1864 | +static int ehci_port_change(struct ehci_hcd *ehci) | ||
1865 | +{ | ||
1866 | + int i = HCS_N_PORTS(ehci->hcs_params); | ||
1867 | + | ||
1868 | + /* First check if the controller indicates a change event */ | ||
1869 | + | ||
1870 | + if (ehci_readl(ehci, &ehci->regs->status) & STS_PCD) | ||
1871 | + return 1; | ||
1872 | + | ||
1873 | + /* | ||
1874 | + * Not all controllers appear to update this while going from D3 to D0, | ||
1875 | + * so check the individual port status registers as well | ||
1876 | + */ | ||
1877 | + | ||
1878 | + while (i--) | ||
1879 | + if (ehci_readl(ehci, &ehci->regs->port_status[i]) & PORT_CSC) | ||
1880 | + return 1; | ||
1881 | + | ||
1882 | + return 0; | ||
1883 | +} | ||
1884 | + | ||
1885 | static void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci, | ||
1886 | bool suspending, bool do_wakeup) | ||
1887 | { | ||
1888 | @@ -173,7 +194,7 @@ static void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci, | ||
1889 | } | ||
1890 | |||
1891 | /* Does the root hub have a port wakeup pending? */ | ||
1892 | - if (!suspending && (ehci_readl(ehci, &ehci->regs->status) & STS_PCD)) | ||
1893 | + if (!suspending && ehci_port_change(ehci)) | ||
1894 | usb_hcd_resume_root_hub(ehci_to_hcd(ehci)); | ||
1895 | |||
1896 | spin_unlock_irqrestore(&ehci->lock, flags); | ||
1897 | diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c | ||
1898 | index bdba8c5..c470cc8 100644 | ||
1899 | --- a/drivers/usb/host/isp1760-hcd.c | ||
1900 | +++ b/drivers/usb/host/isp1760-hcd.c | ||
1901 | @@ -33,6 +33,7 @@ struct isp1760_hcd { | ||
1902 | struct inter_packet_info atl_ints[32]; | ||
1903 | struct inter_packet_info int_ints[32]; | ||
1904 | struct memory_chunk memory_pool[BLOCKS]; | ||
1905 | + u32 atl_queued; | ||
1906 | |||
1907 | /* periodic schedule support */ | ||
1908 | #define DEFAULT_I_TDPS 1024 | ||
1909 | @@ -850,6 +851,11 @@ static void enqueue_an_ATL_packet(struct usb_hcd *hcd, struct isp1760_qh *qh, | ||
1910 | skip_map &= ~queue_entry; | ||
1911 | isp1760_writel(skip_map, hcd->regs + HC_ATL_PTD_SKIPMAP_REG); | ||
1912 | |||
1913 | + priv->atl_queued++; | ||
1914 | + if (priv->atl_queued == 2) | ||
1915 | + isp1760_writel(INTERRUPT_ENABLE_SOT_MASK, | ||
1916 | + hcd->regs + HC_INTERRUPT_ENABLE); | ||
1917 | + | ||
1918 | buffstatus = isp1760_readl(hcd->regs + HC_BUFFER_STATUS_REG); | ||
1919 | buffstatus |= ATL_BUFFER; | ||
1920 | isp1760_writel(buffstatus, hcd->regs + HC_BUFFER_STATUS_REG); | ||
1921 | @@ -992,6 +998,7 @@ static void do_atl_int(struct usb_hcd *usb_hcd) | ||
1922 | u32 dw3; | ||
1923 | |||
1924 | status = 0; | ||
1925 | + priv->atl_queued--; | ||
1926 | |||
1927 | queue_entry = __ffs(done_map); | ||
1928 | done_map &= ~(1 << queue_entry); | ||
1929 | @@ -1054,11 +1061,6 @@ static void do_atl_int(struct usb_hcd *usb_hcd) | ||
1930 | * device is not able to send data fast enough. | ||
1931 | * This happens mostly on slower hardware. | ||
1932 | */ | ||
1933 | - printk(KERN_NOTICE "Reloading ptd %p/%p... qh %p read: " | ||
1934 | - "%d of %zu done: %08x cur: %08x\n", qtd, | ||
1935 | - urb, qh, PTD_XFERRED_LENGTH(dw3), | ||
1936 | - qtd->length, done_map, | ||
1937 | - (1 << queue_entry)); | ||
1938 | |||
1939 | /* RL counter = ERR counter */ | ||
1940 | dw3 &= ~(0xf << 19); | ||
1941 | @@ -1086,6 +1088,11 @@ static void do_atl_int(struct usb_hcd *usb_hcd) | ||
1942 | priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs + | ||
1943 | atl_regs, sizeof(ptd)); | ||
1944 | |||
1945 | + priv->atl_queued++; | ||
1946 | + if (priv->atl_queued == 2) | ||
1947 | + isp1760_writel(INTERRUPT_ENABLE_SOT_MASK, | ||
1948 | + usb_hcd->regs + HC_INTERRUPT_ENABLE); | ||
1949 | + | ||
1950 | buffstatus = isp1760_readl(usb_hcd->regs + | ||
1951 | HC_BUFFER_STATUS_REG); | ||
1952 | buffstatus |= ATL_BUFFER; | ||
1953 | @@ -1191,6 +1198,9 @@ static void do_atl_int(struct usb_hcd *usb_hcd) | ||
1954 | skip_map = isp1760_readl(usb_hcd->regs + | ||
1955 | HC_ATL_PTD_SKIPMAP_REG); | ||
1956 | } | ||
1957 | + if (priv->atl_queued <= 1) | ||
1958 | + isp1760_writel(INTERRUPT_ENABLE_MASK, | ||
1959 | + usb_hcd->regs + HC_INTERRUPT_ENABLE); | ||
1960 | } | ||
1961 | |||
1962 | static void do_intl_int(struct usb_hcd *usb_hcd) | ||
1963 | @@ -1770,7 +1780,7 @@ static irqreturn_t isp1760_irq(struct usb_hcd *usb_hcd) | ||
1964 | goto leave; | ||
1965 | |||
1966 | isp1760_writel(imask, usb_hcd->regs + HC_INTERRUPT_REG); | ||
1967 | - if (imask & HC_ATL_INT) | ||
1968 | + if (imask & (HC_ATL_INT | HC_SOT_INT)) | ||
1969 | do_atl_int(usb_hcd); | ||
1970 | |||
1971 | if (imask & HC_INTL_INT) | ||
1972 | diff --git a/drivers/usb/host/isp1760-hcd.h b/drivers/usb/host/isp1760-hcd.h | ||
1973 | index 6931ef5..612bce5 100644 | ||
1974 | --- a/drivers/usb/host/isp1760-hcd.h | ||
1975 | +++ b/drivers/usb/host/isp1760-hcd.h | ||
1976 | @@ -69,6 +69,7 @@ void deinit_kmem_cache(void); | ||
1977 | |||
1978 | #define HC_INTERRUPT_ENABLE 0x314 | ||
1979 | #define INTERRUPT_ENABLE_MASK (HC_INTL_INT | HC_ATL_INT | HC_EOT_INT) | ||
1980 | +#define INTERRUPT_ENABLE_SOT_MASK (HC_INTL_INT | HC_SOT_INT | HC_EOT_INT) | ||
1981 | |||
1982 | #define HC_ISO_INT (1 << 9) | ||
1983 | #define HC_ATL_INT (1 << 8) | ||
1984 | diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c | ||
1985 | index 09bb3c9..6478fff 100644 | ||
1986 | --- a/drivers/usb/host/xhci-ring.c | ||
1987 | +++ b/drivers/usb/host/xhci-ring.c | ||
1988 | @@ -505,15 +505,26 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci, | ||
1989 | state->new_cycle_state = ~(state->new_cycle_state) & 0x1; | ||
1990 | next_trb(xhci, ep_ring, &state->new_deq_seg, &state->new_deq_ptr); | ||
1991 | |||
1992 | + /* | ||
1993 | + * If there is only one segment in a ring, find_trb_seg()'s while loop | ||
1994 | + * will not run, and it will return before it has a chance to see if it | ||
1995 | + * needs to toggle the cycle bit. It can't tell if the stalled transfer | ||
1996 | + * ended just before the link TRB on a one-segment ring, or if the TD | ||
1997 | + * wrapped around the top of the ring, because it doesn't have the TD in | ||
1998 | + * question. Look for the one-segment case where stalled TRB's address | ||
1999 | + * is greater than the new dequeue pointer address. | ||
2000 | + */ | ||
2001 | + if (ep_ring->first_seg == ep_ring->first_seg->next && | ||
2002 | + state->new_deq_ptr < dev->eps[ep_index].stopped_trb) | ||
2003 | + state->new_cycle_state ^= 0x1; | ||
2004 | + xhci_dbg(xhci, "Cycle state = 0x%x\n", state->new_cycle_state); | ||
2005 | + | ||
2006 | /* Don't update the ring cycle state for the producer (us). */ | ||
2007 | xhci_dbg(xhci, "New dequeue segment = %p (virtual)\n", | ||
2008 | state->new_deq_seg); | ||
2009 | addr = xhci_trb_virt_to_dma(state->new_deq_seg, state->new_deq_ptr); | ||
2010 | xhci_dbg(xhci, "New dequeue pointer = 0x%llx (DMA)\n", | ||
2011 | (unsigned long long) addr); | ||
2012 | - xhci_dbg(xhci, "Setting dequeue pointer in internal ring state.\n"); | ||
2013 | - ep_ring->dequeue = state->new_deq_ptr; | ||
2014 | - ep_ring->deq_seg = state->new_deq_seg; | ||
2015 | } | ||
2016 | |||
2017 | static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring, | ||
2018 | @@ -956,9 +967,26 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci, | ||
2019 | } else { | ||
2020 | xhci_dbg(xhci, "Successful Set TR Deq Ptr cmd, deq = @%08llx\n", | ||
2021 | ep_ctx->deq); | ||
2022 | + if (xhci_trb_virt_to_dma(dev->eps[ep_index].queued_deq_seg, | ||
2023 | + dev->eps[ep_index].queued_deq_ptr) == | ||
2024 | + (ep_ctx->deq & ~(EP_CTX_CYCLE_MASK))) { | ||
2025 | + /* Update the ring's dequeue segment and dequeue pointer | ||
2026 | + * to reflect the new position. | ||
2027 | + */ | ||
2028 | + ep_ring->deq_seg = dev->eps[ep_index].queued_deq_seg; | ||
2029 | + ep_ring->dequeue = dev->eps[ep_index].queued_deq_ptr; | ||
2030 | + } else { | ||
2031 | + xhci_warn(xhci, "Mismatch between completed Set TR Deq " | ||
2032 | + "Ptr command & xHCI internal state.\n"); | ||
2033 | + xhci_warn(xhci, "ep deq seg = %p, deq ptr = %p\n", | ||
2034 | + dev->eps[ep_index].queued_deq_seg, | ||
2035 | + dev->eps[ep_index].queued_deq_ptr); | ||
2036 | + } | ||
2037 | } | ||
2038 | |||
2039 | dev->eps[ep_index].ep_state &= ~SET_DEQ_PENDING; | ||
2040 | + dev->eps[ep_index].queued_deq_seg = NULL; | ||
2041 | + dev->eps[ep_index].queued_deq_ptr = NULL; | ||
2042 | /* Restart any rings with pending URBs */ | ||
2043 | ring_doorbell_for_active_rings(xhci, slot_id, ep_index); | ||
2044 | } | ||
2045 | @@ -3218,6 +3246,7 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id, | ||
2046 | u32 trb_ep_index = EP_ID_FOR_TRB(ep_index); | ||
2047 | u32 trb_stream_id = STREAM_ID_FOR_TRB(stream_id); | ||
2048 | u32 type = TRB_TYPE(TRB_SET_DEQ); | ||
2049 | + struct xhci_virt_ep *ep; | ||
2050 | |||
2051 | addr = xhci_trb_virt_to_dma(deq_seg, deq_ptr); | ||
2052 | if (addr == 0) { | ||
2053 | @@ -3226,6 +3255,14 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id, | ||
2054 | deq_seg, deq_ptr); | ||
2055 | return 0; | ||
2056 | } | ||
2057 | + ep = &xhci->devs[slot_id]->eps[ep_index]; | ||
2058 | + if ((ep->ep_state & SET_DEQ_PENDING)) { | ||
2059 | + xhci_warn(xhci, "WARN Cannot submit Set TR Deq Ptr\n"); | ||
2060 | + xhci_warn(xhci, "A Set TR Deq Ptr command is pending.\n"); | ||
2061 | + return 0; | ||
2062 | + } | ||
2063 | + ep->queued_deq_seg = deq_seg; | ||
2064 | + ep->queued_deq_ptr = deq_ptr; | ||
2065 | return queue_command(xhci, lower_32_bits(addr) | cycle_state, | ||
2066 | upper_32_bits(addr), trb_stream_id, | ||
2067 | trb_slot_id | trb_ep_index | type, false); | ||
2068 | diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h | ||
2069 | index 170c367..2ba3f66 100644 | ||
2070 | --- a/drivers/usb/host/xhci.h | ||
2071 | +++ b/drivers/usb/host/xhci.h | ||
2072 | @@ -648,6 +648,9 @@ struct xhci_ep_ctx { | ||
2073 | #define AVG_TRB_LENGTH_FOR_EP(p) ((p) & 0xffff) | ||
2074 | #define MAX_ESIT_PAYLOAD_FOR_EP(p) (((p) & 0xffff) << 16) | ||
2075 | |||
2076 | +/* deq bitmasks */ | ||
2077 | +#define EP_CTX_CYCLE_MASK (1 << 0) | ||
2078 | + | ||
2079 | |||
2080 | /** | ||
2081 | * struct xhci_input_control_context | ||
2082 | @@ -750,6 +753,12 @@ struct xhci_virt_ep { | ||
2083 | struct timer_list stop_cmd_timer; | ||
2084 | int stop_cmds_pending; | ||
2085 | struct xhci_hcd *xhci; | ||
2086 | + /* Dequeue pointer and dequeue segment for a submitted Set TR Dequeue | ||
2087 | + * command. We'll need to update the ring's dequeue segment and dequeue | ||
2088 | + * pointer after the command completes. | ||
2089 | + */ | ||
2090 | + struct xhci_segment *queued_deq_seg; | ||
2091 | + union xhci_trb *queued_deq_ptr; | ||
2092 | /* | ||
2093 | * Sometimes the xHC can not process isochronous endpoint ring quickly | ||
2094 | * enough, and it will miss some isoc tds on the ring and generate | ||
2095 | diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c | ||
2096 | index 7b8815d..14ac87e 100644 | ||
2097 | --- a/drivers/usb/serial/ch341.c | ||
2098 | +++ b/drivers/usb/serial/ch341.c | ||
2099 | @@ -75,6 +75,7 @@ static int debug; | ||
2100 | static const struct usb_device_id id_table[] = { | ||
2101 | { USB_DEVICE(0x4348, 0x5523) }, | ||
2102 | { USB_DEVICE(0x1a86, 0x7523) }, | ||
2103 | + { USB_DEVICE(0x1a86, 0x5523) }, | ||
2104 | { }, | ||
2105 | }; | ||
2106 | MODULE_DEVICE_TABLE(usb, id_table); | ||
2107 | diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c | ||
2108 | index bd5bd85..b382d9a 100644 | ||
2109 | --- a/drivers/usb/serial/kobil_sct.c | ||
2110 | +++ b/drivers/usb/serial/kobil_sct.c | ||
2111 | @@ -372,7 +372,7 @@ static void kobil_read_int_callback(struct urb *urb) | ||
2112 | } | ||
2113 | |||
2114 | tty = tty_port_tty_get(&port->port); | ||
2115 | - if (urb->actual_length) { | ||
2116 | + if (tty && urb->actual_length) { | ||
2117 | |||
2118 | /* BEGIN DEBUG */ | ||
2119 | /* | ||
2120 | diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c | ||
2121 | index 356c870..14cd1c0 100644 | ||
2122 | --- a/drivers/usb/serial/option.c | ||
2123 | +++ b/drivers/usb/serial/option.c | ||
2124 | @@ -653,7 +653,8 @@ static const struct usb_device_id option_ids[] = { | ||
2125 | { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0028, 0xff, 0xff, 0xff) }, | ||
2126 | { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0029, 0xff, 0xff, 0xff) }, | ||
2127 | { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0030, 0xff, 0xff, 0xff) }, | ||
2128 | - { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF626, 0xff, 0xff, 0xff) }, | ||
2129 | + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF626, 0xff, | ||
2130 | + 0xff, 0xff), .driver_info = (kernel_ulong_t)&four_g_w14_blacklist }, | ||
2131 | { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0032, 0xff, 0xff, 0xff) }, | ||
2132 | { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0033, 0xff, 0xff, 0xff) }, | ||
2133 | { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0034, 0xff, 0xff, 0xff) }, | ||
2134 | diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c | ||
2135 | index 546a521..2ff90a9 100644 | ||
2136 | --- a/drivers/usb/serial/usb-serial.c | ||
2137 | +++ b/drivers/usb/serial/usb-serial.c | ||
2138 | @@ -911,9 +911,8 @@ int usb_serial_probe(struct usb_interface *interface, | ||
2139 | dev_err(&interface->dev, "No free urbs available\n"); | ||
2140 | goto probe_error; | ||
2141 | } | ||
2142 | - buffer_size = serial->type->bulk_in_size; | ||
2143 | - if (!buffer_size) | ||
2144 | - buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); | ||
2145 | + buffer_size = max_t(int, serial->type->bulk_in_size, | ||
2146 | + le16_to_cpu(endpoint->wMaxPacketSize)); | ||
2147 | port->bulk_in_size = buffer_size; | ||
2148 | port->bulk_in_endpointAddress = endpoint->bEndpointAddress; | ||
2149 | port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL); | ||
2150 | diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c | ||
2151 | index 66836d8..c22a3d1 100644 | ||
2152 | --- a/fs/btrfs/file.c | ||
2153 | +++ b/fs/btrfs/file.c | ||
2154 | @@ -69,6 +69,19 @@ static noinline int btrfs_copy_from_user(loff_t pos, int num_pages, | ||
2155 | |||
2156 | /* Flush processor's dcache for this page */ | ||
2157 | flush_dcache_page(page); | ||
2158 | + | ||
2159 | + /* | ||
2160 | + * if we get a partial write, we can end up with | ||
2161 | + * partially up to date pages. These add | ||
2162 | + * a lot of complexity, so make sure they don't | ||
2163 | + * happen by forcing this copy to be retried. | ||
2164 | + * | ||
2165 | + * The rest of the btrfs_file_write code will fall | ||
2166 | + * back to page at a time copies after we return 0. | ||
2167 | + */ | ||
2168 | + if (!PageUptodate(page) && copied < count) | ||
2169 | + copied = 0; | ||
2170 | + | ||
2171 | iov_iter_advance(i, copied); | ||
2172 | write_bytes -= copied; | ||
2173 | total_copied += copied; | ||
2174 | diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c | ||
2175 | index bce9dce..d1e0d89 100644 | ||
2176 | --- a/fs/ext3/namei.c | ||
2177 | +++ b/fs/ext3/namei.c | ||
2178 | @@ -1549,8 +1549,8 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry, | ||
2179 | goto cleanup; | ||
2180 | node2 = (struct dx_node *)(bh2->b_data); | ||
2181 | entries2 = node2->entries; | ||
2182 | + memset(&node2->fake, 0, sizeof(struct fake_dirent)); | ||
2183 | node2->fake.rec_len = ext3_rec_len_to_disk(sb->s_blocksize); | ||
2184 | - node2->fake.inode = 0; | ||
2185 | BUFFER_TRACE(frame->bh, "get_write_access"); | ||
2186 | err = ext3_journal_get_write_access(handle, frame->bh); | ||
2187 | if (err) | ||
2188 | diff --git a/fs/nfs/nfs2xdr.c b/fs/nfs/nfs2xdr.c | ||
2189 | index b382a1b..33a038d 100644 | ||
2190 | --- a/fs/nfs/nfs2xdr.c | ||
2191 | +++ b/fs/nfs/nfs2xdr.c | ||
2192 | @@ -477,11 +477,13 @@ nfs_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, struct nfs_se | ||
2193 | entry->ino = ntohl(*p++); | ||
2194 | entry->len = ntohl(*p++); | ||
2195 | |||
2196 | - p = xdr_inline_decode(xdr, entry->len + 4); | ||
2197 | + p = xdr_inline_decode(xdr, entry->len); | ||
2198 | if (unlikely(!p)) | ||
2199 | goto out_overflow; | ||
2200 | entry->name = (const char *) p; | ||
2201 | - p += XDR_QUADLEN(entry->len); | ||
2202 | + p = xdr_inline_decode(xdr, 4); | ||
2203 | + if (unlikely(!p)) | ||
2204 | + goto out_overflow; | ||
2205 | entry->prev_cookie = entry->cookie; | ||
2206 | entry->cookie = ntohl(*p++); | ||
2207 | |||
2208 | diff --git a/fs/nfs/nfs3xdr.c b/fs/nfs/nfs3xdr.c | ||
2209 | index ba91236..dcd934f 100644 | ||
2210 | --- a/fs/nfs/nfs3xdr.c | ||
2211 | +++ b/fs/nfs/nfs3xdr.c | ||
2212 | @@ -614,11 +614,13 @@ nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, struct nfs_s | ||
2213 | p = xdr_decode_hyper(p, &entry->ino); | ||
2214 | entry->len = ntohl(*p++); | ||
2215 | |||
2216 | - p = xdr_inline_decode(xdr, entry->len + 8); | ||
2217 | + p = xdr_inline_decode(xdr, entry->len); | ||
2218 | if (unlikely(!p)) | ||
2219 | goto out_overflow; | ||
2220 | entry->name = (const char *) p; | ||
2221 | - p += XDR_QUADLEN(entry->len); | ||
2222 | + p = xdr_inline_decode(xdr, 8); | ||
2223 | + if (unlikely(!p)) | ||
2224 | + goto out_overflow; | ||
2225 | entry->prev_cookie = entry->cookie; | ||
2226 | p = xdr_decode_hyper(p, &entry->cookie); | ||
2227 | |||
2228 | diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c | ||
2229 | index c2c7a6b..d851c07 100644 | ||
2230 | --- a/fs/nfs/nfs4proc.c | ||
2231 | +++ b/fs/nfs/nfs4proc.c | ||
2232 | @@ -3226,7 +3226,7 @@ static int buf_to_pages_noslab(const void *buf, size_t buflen, | ||
2233 | spages = pages; | ||
2234 | |||
2235 | do { | ||
2236 | - len = min(PAGE_CACHE_SIZE, buflen); | ||
2237 | + len = min_t(size_t, PAGE_CACHE_SIZE, buflen); | ||
2238 | newpage = alloc_page(GFP_KERNEL); | ||
2239 | |||
2240 | if (newpage == NULL) | ||
2241 | diff --git a/fs/nfs/nfsroot.c b/fs/nfs/nfsroot.c | ||
2242 | index 903908a..c541093 100644 | ||
2243 | --- a/fs/nfs/nfsroot.c | ||
2244 | +++ b/fs/nfs/nfsroot.c | ||
2245 | @@ -86,11 +86,14 @@ | ||
2246 | /* Default path we try to mount. "%s" gets replaced by our IP address */ | ||
2247 | #define NFS_ROOT "/tftpboot/%s" | ||
2248 | |||
2249 | +/* Default NFSROOT mount options. */ | ||
2250 | +#define NFS_DEF_OPTIONS "udp" | ||
2251 | + | ||
2252 | /* Parameters passed from the kernel command line */ | ||
2253 | static char nfs_root_parms[256] __initdata = ""; | ||
2254 | |||
2255 | /* Text-based mount options passed to super.c */ | ||
2256 | -static char nfs_root_options[256] __initdata = ""; | ||
2257 | +static char nfs_root_options[256] __initdata = NFS_DEF_OPTIONS; | ||
2258 | |||
2259 | /* Address of NFS server */ | ||
2260 | static __be32 servaddr __initdata = htonl(INADDR_NONE); | ||
2261 | @@ -160,8 +163,14 @@ static int __init root_nfs_copy(char *dest, const char *src, | ||
2262 | } | ||
2263 | |||
2264 | static int __init root_nfs_cat(char *dest, const char *src, | ||
2265 | - const size_t destlen) | ||
2266 | + const size_t destlen) | ||
2267 | { | ||
2268 | + size_t len = strlen(dest); | ||
2269 | + | ||
2270 | + if (len && dest[len - 1] != ',') | ||
2271 | + if (strlcat(dest, ",", destlen) > destlen) | ||
2272 | + return -1; | ||
2273 | + | ||
2274 | if (strlcat(dest, src, destlen) > destlen) | ||
2275 | return -1; | ||
2276 | return 0; | ||
2277 | @@ -194,16 +203,6 @@ static int __init root_nfs_parse_options(char *incoming, char *exppath, | ||
2278 | if (root_nfs_cat(nfs_root_options, incoming, | ||
2279 | sizeof(nfs_root_options))) | ||
2280 | return -1; | ||
2281 | - | ||
2282 | - /* | ||
2283 | - * Possibly prepare for more options to be appended | ||
2284 | - */ | ||
2285 | - if (nfs_root_options[0] != '\0' && | ||
2286 | - nfs_root_options[strlen(nfs_root_options)] != ',') | ||
2287 | - if (root_nfs_cat(nfs_root_options, ",", | ||
2288 | - sizeof(nfs_root_options))) | ||
2289 | - return -1; | ||
2290 | - | ||
2291 | return 0; | ||
2292 | } | ||
2293 | |||
2294 | @@ -217,7 +216,7 @@ static int __init root_nfs_parse_options(char *incoming, char *exppath, | ||
2295 | */ | ||
2296 | static int __init root_nfs_data(char *cmdline) | ||
2297 | { | ||
2298 | - char addr_option[sizeof("nolock,addr=") + INET_ADDRSTRLEN + 1]; | ||
2299 | + char mand_options[sizeof("nolock,addr=") + INET_ADDRSTRLEN + 1]; | ||
2300 | int len, retval = -1; | ||
2301 | char *tmp = NULL; | ||
2302 | const size_t tmplen = sizeof(nfs_export_path); | ||
2303 | @@ -244,9 +243,9 @@ static int __init root_nfs_data(char *cmdline) | ||
2304 | * Append mandatory options for nfsroot so they override | ||
2305 | * what has come before | ||
2306 | */ | ||
2307 | - snprintf(addr_option, sizeof(addr_option), "nolock,addr=%pI4", | ||
2308 | + snprintf(mand_options, sizeof(mand_options), "nolock,addr=%pI4", | ||
2309 | &servaddr); | ||
2310 | - if (root_nfs_cat(nfs_root_options, addr_option, | ||
2311 | + if (root_nfs_cat(nfs_root_options, mand_options, | ||
2312 | sizeof(nfs_root_options))) | ||
2313 | goto out_optionstoolong; | ||
2314 | |||
2315 | diff --git a/fs/partitions/osf.c b/fs/partitions/osf.c | ||
2316 | index 48cec7c..764b86a 100644 | ||
2317 | --- a/fs/partitions/osf.c | ||
2318 | +++ b/fs/partitions/osf.c | ||
2319 | @@ -10,10 +10,13 @@ | ||
2320 | #include "check.h" | ||
2321 | #include "osf.h" | ||
2322 | |||
2323 | +#define MAX_OSF_PARTITIONS 18 | ||
2324 | + | ||
2325 | int osf_partition(struct parsed_partitions *state) | ||
2326 | { | ||
2327 | int i; | ||
2328 | int slot = 1; | ||
2329 | + unsigned int npartitions; | ||
2330 | Sector sect; | ||
2331 | unsigned char *data; | ||
2332 | struct disklabel { | ||
2333 | @@ -45,7 +48,7 @@ int osf_partition(struct parsed_partitions *state) | ||
2334 | u8 p_fstype; | ||
2335 | u8 p_frag; | ||
2336 | __le16 p_cpg; | ||
2337 | - } d_partitions[8]; | ||
2338 | + } d_partitions[MAX_OSF_PARTITIONS]; | ||
2339 | } * label; | ||
2340 | struct d_partition * partition; | ||
2341 | |||
2342 | @@ -63,7 +66,12 @@ int osf_partition(struct parsed_partitions *state) | ||
2343 | put_dev_sector(sect); | ||
2344 | return 0; | ||
2345 | } | ||
2346 | - for (i = 0 ; i < le16_to_cpu(label->d_npartitions); i++, partition++) { | ||
2347 | + npartitions = le16_to_cpu(label->d_npartitions); | ||
2348 | + if (npartitions > MAX_OSF_PARTITIONS) { | ||
2349 | + put_dev_sector(sect); | ||
2350 | + return 0; | ||
2351 | + } | ||
2352 | + for (i = 0 ; i < npartitions; i++, partition++) { | ||
2353 | if (slot == state->limit) | ||
2354 | break; | ||
2355 | if (le32_to_cpu(partition->p_size)) | ||
2356 | diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h | ||
2357 | index dcd6a7c..ca29e03 100644 | ||
2358 | --- a/include/linux/ftrace.h | ||
2359 | +++ b/include/linux/ftrace.h | ||
2360 | @@ -428,6 +428,7 @@ extern void unregister_ftrace_graph(void); | ||
2361 | |||
2362 | extern void ftrace_graph_init_task(struct task_struct *t); | ||
2363 | extern void ftrace_graph_exit_task(struct task_struct *t); | ||
2364 | +extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu); | ||
2365 | |||
2366 | static inline int task_curr_ret_stack(struct task_struct *t) | ||
2367 | { | ||
2368 | @@ -451,6 +452,7 @@ static inline void unpause_graph_tracing(void) | ||
2369 | |||
2370 | static inline void ftrace_graph_init_task(struct task_struct *t) { } | ||
2371 | static inline void ftrace_graph_exit_task(struct task_struct *t) { } | ||
2372 | +static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { } | ||
2373 | |||
2374 | static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc, | ||
2375 | trace_func_graph_ent_t entryfunc) | ||
2376 | diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h | ||
2377 | index f917bbb..b8eb2b5 100644 | ||
2378 | --- a/include/linux/usb/ch9.h | ||
2379 | +++ b/include/linux/usb/ch9.h | ||
2380 | @@ -575,6 +575,8 @@ struct usb_ss_ep_comp_descriptor { | ||
2381 | #define USB_DT_SS_EP_COMP_SIZE 6 | ||
2382 | /* Bits 4:0 of bmAttributes if this is a bulk endpoint */ | ||
2383 | #define USB_SS_MAX_STREAMS(p) (1 << (p & 0x1f)) | ||
2384 | +/* Bits 1:0 of bmAttributes if this is an isoc endpoint */ | ||
2385 | +#define USB_SS_MULT(p) (1 + ((p) & 0x3)) | ||
2386 | |||
2387 | /*-------------------------------------------------------------------------*/ | ||
2388 | |||
2389 | diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h | ||
2390 | index 6c37d78..91ad20f 100644 | ||
2391 | --- a/include/linux/usb/hcd.h | ||
2392 | +++ b/include/linux/usb/hcd.h | ||
2393 | @@ -99,6 +99,8 @@ struct usb_hcd { | ||
2394 | #define HCD_FLAG_POLL_RH 2 /* poll for rh status? */ | ||
2395 | #define HCD_FLAG_POLL_PENDING 3 /* status has changed? */ | ||
2396 | #define HCD_FLAG_WAKEUP_PENDING 4 /* root hub is resuming? */ | ||
2397 | +#define HCD_FLAG_RH_RUNNING 5 /* root hub is running? */ | ||
2398 | +#define HCD_FLAG_DEAD 6 /* controller has died? */ | ||
2399 | |||
2400 | /* The flags can be tested using these macros; they are likely to | ||
2401 | * be slightly faster than test_bit(). | ||
2402 | @@ -108,6 +110,8 @@ struct usb_hcd { | ||
2403 | #define HCD_POLL_RH(hcd) ((hcd)->flags & (1U << HCD_FLAG_POLL_RH)) | ||
2404 | #define HCD_POLL_PENDING(hcd) ((hcd)->flags & (1U << HCD_FLAG_POLL_PENDING)) | ||
2405 | #define HCD_WAKEUP_PENDING(hcd) ((hcd)->flags & (1U << HCD_FLAG_WAKEUP_PENDING)) | ||
2406 | +#define HCD_RH_RUNNING(hcd) ((hcd)->flags & (1U << HCD_FLAG_RH_RUNNING)) | ||
2407 | +#define HCD_DEAD(hcd) ((hcd)->flags & (1U << HCD_FLAG_DEAD)) | ||
2408 | |||
2409 | /* Flags that get set only during HCD registration or removal. */ | ||
2410 | unsigned rh_registered:1;/* is root hub registered? */ | ||
2411 | diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h | ||
2412 | index c904913..45f3b9d 100644 | ||
2413 | --- a/include/linux/usb/serial.h | ||
2414 | +++ b/include/linux/usb/serial.h | ||
2415 | @@ -191,7 +191,8 @@ static inline void usb_set_serial_data(struct usb_serial *serial, void *data) | ||
2416 | * @id_table: pointer to a list of usb_device_id structures that define all | ||
2417 | * of the devices this structure can support. | ||
2418 | * @num_ports: the number of different ports this device will have. | ||
2419 | - * @bulk_in_size: bytes to allocate for bulk-in buffer (0 = end-point size) | ||
2420 | + * @bulk_in_size: minimum number of bytes to allocate for bulk-in buffer | ||
2421 | + * (0 = end-point size) | ||
2422 | * @bulk_out_size: bytes to allocate for bulk-out buffer (0 = end-point size) | ||
2423 | * @calc_num_ports: pointer to a function to determine how many ports this | ||
2424 | * device has dynamically. It will be called after the probe() | ||
2425 | diff --git a/kernel/perf_event.c b/kernel/perf_event.c | ||
2426 | index 785c66a..ee489d0 100644 | ||
2427 | --- a/kernel/perf_event.c | ||
2428 | +++ b/kernel/perf_event.c | ||
2429 | @@ -4414,7 +4414,7 @@ static int perf_exclude_event(struct perf_event *event, | ||
2430 | struct pt_regs *regs) | ||
2431 | { | ||
2432 | if (event->hw.state & PERF_HES_STOPPED) | ||
2433 | - return 0; | ||
2434 | + return 1; | ||
2435 | |||
2436 | if (regs) { | ||
2437 | if (event->attr.exclude_user && user_mode(regs)) | ||
2438 | @@ -4770,6 +4770,8 @@ static int perf_tp_event_match(struct perf_event *event, | ||
2439 | struct perf_sample_data *data, | ||
2440 | struct pt_regs *regs) | ||
2441 | { | ||
2442 | + if (event->hw.state & PERF_HES_STOPPED) | ||
2443 | + return 0; | ||
2444 | /* | ||
2445 | * All tracepoints are from kernel-space. | ||
2446 | */ | ||
2447 | diff --git a/kernel/sched.c b/kernel/sched.c | ||
2448 | index 2f912b7..5e0a919 100644 | ||
2449 | --- a/kernel/sched.c | ||
2450 | +++ b/kernel/sched.c | ||
2451 | @@ -5706,7 +5706,7 @@ void __cpuinit init_idle(struct task_struct *idle, int cpu) | ||
2452 | * The idle tasks have their own, simple scheduling class: | ||
2453 | */ | ||
2454 | idle->sched_class = &idle_sched_class; | ||
2455 | - ftrace_graph_init_task(idle); | ||
2456 | + ftrace_graph_init_idle_task(idle, cpu); | ||
2457 | } | ||
2458 | |||
2459 | /* | ||
2460 | diff --git a/kernel/smp.c b/kernel/smp.c | ||
2461 | index 8448f8f..a210d13 100644 | ||
2462 | --- a/kernel/smp.c | ||
2463 | +++ b/kernel/smp.c | ||
2464 | @@ -440,7 +440,7 @@ void smp_call_function_many(const struct cpumask *mask, | ||
2465 | { | ||
2466 | struct call_function_data *data; | ||
2467 | unsigned long flags; | ||
2468 | - int cpu, next_cpu, this_cpu = smp_processor_id(); | ||
2469 | + int refs, cpu, next_cpu, this_cpu = smp_processor_id(); | ||
2470 | |||
2471 | /* | ||
2472 | * Can deadlock when called with interrupts disabled. | ||
2473 | @@ -451,7 +451,7 @@ void smp_call_function_many(const struct cpumask *mask, | ||
2474 | WARN_ON_ONCE(cpu_online(this_cpu) && irqs_disabled() | ||
2475 | && !oops_in_progress); | ||
2476 | |||
2477 | - /* So, what's a CPU they want? Ignoring this one. */ | ||
2478 | + /* Try to fastpath. So, what's a CPU they want? Ignoring this one. */ | ||
2479 | cpu = cpumask_first_and(mask, cpu_online_mask); | ||
2480 | if (cpu == this_cpu) | ||
2481 | cpu = cpumask_next_and(cpu, mask, cpu_online_mask); | ||
2482 | @@ -473,22 +473,49 @@ void smp_call_function_many(const struct cpumask *mask, | ||
2483 | |||
2484 | data = &__get_cpu_var(cfd_data); | ||
2485 | csd_lock(&data->csd); | ||
2486 | + | ||
2487 | + /* This BUG_ON verifies our reuse assertions and can be removed */ | ||
2488 | BUG_ON(atomic_read(&data->refs) || !cpumask_empty(data->cpumask)); | ||
2489 | |||
2490 | + /* | ||
2491 | + * The global call function queue list add and delete are protected | ||
2492 | + * by a lock, but the list is traversed without any lock, relying | ||
2493 | + * on the rcu list add and delete to allow safe concurrent traversal. | ||
2494 | + * We reuse the call function data without waiting for any grace | ||
2495 | + * period after some other cpu removes it from the global queue. | ||
2496 | + * This means a cpu might find our data block as it is being | ||
2497 | + * filled out. | ||
2498 | + * | ||
2499 | + * We hold off the interrupt handler on the other cpu by | ||
2500 | + * ordering our writes to the cpu mask vs our setting of the | ||
2501 | + * refs counter. We assert only the cpu owning the data block | ||
2502 | + * will set a bit in cpumask, and each bit will only be cleared | ||
2503 | + * by the subject cpu. Each cpu must first find its bit is | ||
2504 | + * set and then check that refs is set indicating the element is | ||
2505 | + * ready to be processed, otherwise it must skip the entry. | ||
2506 | + * | ||
2507 | + * On the previous iteration refs was set to 0 by another cpu. | ||
2508 | + * To avoid the use of transitivity, set the counter to 0 here | ||
2509 | + * so the wmb will pair with the rmb in the interrupt handler. | ||
2510 | + */ | ||
2511 | + atomic_set(&data->refs, 0); /* convert 3rd to 1st party write */ | ||
2512 | + | ||
2513 | data->csd.func = func; | ||
2514 | data->csd.info = info; | ||
2515 | - cpumask_and(data->cpumask, mask, cpu_online_mask); | ||
2516 | - cpumask_clear_cpu(this_cpu, data->cpumask); | ||
2517 | |||
2518 | - /* | ||
2519 | - * To ensure the interrupt handler gets an complete view | ||
2520 | - * we order the cpumask and refs writes and order the read | ||
2521 | - * of them in the interrupt handler. In addition we may | ||
2522 | - * only clear our own cpu bit from the mask. | ||
2523 | - */ | ||
2524 | + /* Ensure 0 refs is visible before mask. Also orders func and info */ | ||
2525 | smp_wmb(); | ||
2526 | |||
2527 | - atomic_set(&data->refs, cpumask_weight(data->cpumask)); | ||
2528 | + /* We rely on the "and" being processed before the store */ | ||
2529 | + cpumask_and(data->cpumask, mask, cpu_online_mask); | ||
2530 | + cpumask_clear_cpu(this_cpu, data->cpumask); | ||
2531 | + refs = cpumask_weight(data->cpumask); | ||
2532 | + | ||
2533 | + /* Some callers race with other cpus changing the passed mask */ | ||
2534 | + if (unlikely(!refs)) { | ||
2535 | + csd_unlock(&data->csd); | ||
2536 | + return; | ||
2537 | + } | ||
2538 | |||
2539 | raw_spin_lock_irqsave(&call_function.lock, flags); | ||
2540 | /* | ||
2541 | @@ -497,6 +524,12 @@ void smp_call_function_many(const struct cpumask *mask, | ||
2542 | * will not miss any other list entries: | ||
2543 | */ | ||
2544 | list_add_rcu(&data->csd.list, &call_function.queue); | ||
2545 | + /* | ||
2546 | + * We rely on the wmb() in list_add_rcu to complete our writes | ||
2547 | + * to the cpumask before this write to refs, which indicates | ||
2548 | + * data is on the list and is ready to be processed. | ||
2549 | + */ | ||
2550 | + atomic_set(&data->refs, refs); | ||
2551 | raw_spin_unlock_irqrestore(&call_function.lock, flags); | ||
2552 | |||
2553 | /* | ||
2554 | diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c | ||
2555 | index f3dadae..888b611 100644 | ||
2556 | --- a/kernel/trace/ftrace.c | ||
2557 | +++ b/kernel/trace/ftrace.c | ||
2558 | @@ -3328,7 +3328,7 @@ static int start_graph_tracing(void) | ||
2559 | /* The cpu_boot init_task->ret_stack will never be freed */ | ||
2560 | for_each_online_cpu(cpu) { | ||
2561 | if (!idle_task(cpu)->ret_stack) | ||
2562 | - ftrace_graph_init_task(idle_task(cpu)); | ||
2563 | + ftrace_graph_init_idle_task(idle_task(cpu), cpu); | ||
2564 | } | ||
2565 | |||
2566 | do { | ||
2567 | @@ -3418,6 +3418,49 @@ void unregister_ftrace_graph(void) | ||
2568 | mutex_unlock(&ftrace_lock); | ||
2569 | } | ||
2570 | |||
2571 | +static DEFINE_PER_CPU(struct ftrace_ret_stack *, idle_ret_stack); | ||
2572 | + | ||
2573 | +static void | ||
2574 | +graph_init_task(struct task_struct *t, struct ftrace_ret_stack *ret_stack) | ||
2575 | +{ | ||
2576 | + atomic_set(&t->tracing_graph_pause, 0); | ||
2577 | + atomic_set(&t->trace_overrun, 0); | ||
2578 | + t->ftrace_timestamp = 0; | ||
2579 | + /* make curr_ret_stack visable before we add the ret_stack */ | ||
2580 | + smp_wmb(); | ||
2581 | + t->ret_stack = ret_stack; | ||
2582 | +} | ||
2583 | + | ||
2584 | +/* | ||
2585 | + * Allocate a return stack for the idle task. May be the first | ||
2586 | + * time through, or it may be done by CPU hotplug online. | ||
2587 | + */ | ||
2588 | +void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) | ||
2589 | +{ | ||
2590 | + t->curr_ret_stack = -1; | ||
2591 | + /* | ||
2592 | + * The idle task has no parent, it either has its own | ||
2593 | + * stack or no stack at all. | ||
2594 | + */ | ||
2595 | + if (t->ret_stack) | ||
2596 | + WARN_ON(t->ret_stack != per_cpu(idle_ret_stack, cpu)); | ||
2597 | + | ||
2598 | + if (ftrace_graph_active) { | ||
2599 | + struct ftrace_ret_stack *ret_stack; | ||
2600 | + | ||
2601 | + ret_stack = per_cpu(idle_ret_stack, cpu); | ||
2602 | + if (!ret_stack) { | ||
2603 | + ret_stack = kmalloc(FTRACE_RETFUNC_DEPTH | ||
2604 | + * sizeof(struct ftrace_ret_stack), | ||
2605 | + GFP_KERNEL); | ||
2606 | + if (!ret_stack) | ||
2607 | + return; | ||
2608 | + per_cpu(idle_ret_stack, cpu) = ret_stack; | ||
2609 | + } | ||
2610 | + graph_init_task(t, ret_stack); | ||
2611 | + } | ||
2612 | +} | ||
2613 | + | ||
2614 | /* Allocate a return stack for newly created task */ | ||
2615 | void ftrace_graph_init_task(struct task_struct *t) | ||
2616 | { | ||
2617 | @@ -3433,12 +3476,7 @@ void ftrace_graph_init_task(struct task_struct *t) | ||
2618 | GFP_KERNEL); | ||
2619 | if (!ret_stack) | ||
2620 | return; | ||
2621 | - atomic_set(&t->tracing_graph_pause, 0); | ||
2622 | - atomic_set(&t->trace_overrun, 0); | ||
2623 | - t->ftrace_timestamp = 0; | ||
2624 | - /* make curr_ret_stack visable before we add the ret_stack */ | ||
2625 | - smp_wmb(); | ||
2626 | - t->ret_stack = ret_stack; | ||
2627 | + graph_init_task(t, ret_stack); | ||
2628 | } | ||
2629 | } | ||
2630 | |||
2631 | diff --git a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c | ||
2632 | index 37f8adb..63f60fc 100644 | ||
2633 | --- a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c | ||
2634 | +++ b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c | ||
2635 | @@ -97,7 +97,7 @@ static int ct_show_secctx(struct seq_file *s, const struct nf_conn *ct) | ||
2636 | |||
2637 | ret = security_secid_to_secctx(ct->secmark, &secctx, &len); | ||
2638 | if (ret) | ||
2639 | - return ret; | ||
2640 | + return 0; | ||
2641 | |||
2642 | ret = seq_printf(s, "secctx=%s ", secctx); | ||
2643 | |||
2644 | diff --git a/net/netfilter/nf_conntrack_netlink.c b/net/netfilter/nf_conntrack_netlink.c | ||
2645 | index 742a6dc..bce11a5 100644 | ||
2646 | --- a/net/netfilter/nf_conntrack_netlink.c | ||
2647 | +++ b/net/netfilter/nf_conntrack_netlink.c | ||
2648 | @@ -254,7 +254,7 @@ ctnetlink_dump_secctx(struct sk_buff *skb, const struct nf_conn *ct) | ||
2649 | |||
2650 | ret = security_secid_to_secctx(ct->secmark, &secctx, &len); | ||
2651 | if (ret) | ||
2652 | - return ret; | ||
2653 | + return 0; | ||
2654 | |||
2655 | ret = -1; | ||
2656 | nest_secctx = nla_nest_start(skb, CTA_SECCTX | NLA_F_NESTED); | ||
2657 | @@ -453,16 +453,22 @@ ctnetlink_counters_size(const struct nf_conn *ct) | ||
2658 | ; | ||
2659 | } | ||
2660 | |||
2661 | -#ifdef CONFIG_NF_CONNTRACK_SECMARK | ||
2662 | -static int ctnetlink_nlmsg_secctx_size(const struct nf_conn *ct) | ||
2663 | +static inline int | ||
2664 | +ctnetlink_secctx_size(const struct nf_conn *ct) | ||
2665 | { | ||
2666 | - int len; | ||
2667 | +#ifdef CONFIG_NF_CONNTRACK_SECMARK | ||
2668 | + int len, ret; | ||
2669 | |||
2670 | - security_secid_to_secctx(ct->secmark, NULL, &len); | ||
2671 | + ret = security_secid_to_secctx(ct->secmark, NULL, &len); | ||
2672 | + if (ret) | ||
2673 | + return 0; | ||
2674 | |||
2675 | - return sizeof(char) * len; | ||
2676 | -} | ||
2677 | + return nla_total_size(0) /* CTA_SECCTX */ | ||
2678 | + + nla_total_size(sizeof(char) * len); /* CTA_SECCTX_NAME */ | ||
2679 | +#else | ||
2680 | + return 0; | ||
2681 | #endif | ||
2682 | +} | ||
2683 | |||
2684 | static inline size_t | ||
2685 | ctnetlink_nlmsg_size(const struct nf_conn *ct) | ||
2686 | @@ -479,10 +485,7 @@ ctnetlink_nlmsg_size(const struct nf_conn *ct) | ||
2687 | + nla_total_size(0) /* CTA_PROTOINFO */ | ||
2688 | + nla_total_size(0) /* CTA_HELP */ | ||
2689 | + nla_total_size(NF_CT_HELPER_NAME_LEN) /* CTA_HELP_NAME */ | ||
2690 | -#ifdef CONFIG_NF_CONNTRACK_SECMARK | ||
2691 | - + nla_total_size(0) /* CTA_SECCTX */ | ||
2692 | - + nla_total_size(ctnetlink_nlmsg_secctx_size(ct)) /* CTA_SECCTX_NAME */ | ||
2693 | -#endif | ||
2694 | + + ctnetlink_secctx_size(ct) | ||
2695 | #ifdef CONFIG_NF_NAT_NEEDED | ||
2696 | + 2 * nla_total_size(0) /* CTA_NAT_SEQ_ADJ_ORIG|REPL */ | ||
2697 | + 6 * nla_total_size(sizeof(u_int32_t)) /* CTA_NAT_SEQ_OFFSET */ | ||
2698 | diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c | ||
2699 | index 0fb6570..b4d7f0f 100644 | ||
2700 | --- a/net/netfilter/nf_conntrack_standalone.c | ||
2701 | +++ b/net/netfilter/nf_conntrack_standalone.c | ||
2702 | @@ -118,7 +118,7 @@ static int ct_show_secctx(struct seq_file *s, const struct nf_conn *ct) | ||
2703 | |||
2704 | ret = security_secid_to_secctx(ct->secmark, &secctx, &len); | ||
2705 | if (ret) | ||
2706 | - return ret; | ||
2707 | + return 0; | ||
2708 | |||
2709 | ret = seq_printf(s, "secctx=%s ", secctx); | ||
2710 | |||
2711 | diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c | ||
2712 | index 92ce94f..503fbbb 100644 | ||
2713 | --- a/net/sunrpc/clnt.c | ||
2714 | +++ b/net/sunrpc/clnt.c | ||
2715 | @@ -436,7 +436,9 @@ void rpc_killall_tasks(struct rpc_clnt *clnt) | ||
2716 | if (!(rovr->tk_flags & RPC_TASK_KILLED)) { | ||
2717 | rovr->tk_flags |= RPC_TASK_KILLED; | ||
2718 | rpc_exit(rovr, -EIO); | ||
2719 | - rpc_wake_up_queued_task(rovr->tk_waitqueue, rovr); | ||
2720 | + if (RPC_IS_QUEUED(rovr)) | ||
2721 | + rpc_wake_up_queued_task(rovr->tk_waitqueue, | ||
2722 | + rovr); | ||
2723 | } | ||
2724 | } | ||
2725 | spin_unlock(&clnt->cl_lock); | ||
2726 | diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c | ||
2727 | index 243fc09..168fb81 100644 | ||
2728 | --- a/net/sunrpc/sched.c | ||
2729 | +++ b/net/sunrpc/sched.c | ||
2730 | @@ -623,14 +623,12 @@ static void __rpc_execute(struct rpc_task *task) | ||
2731 | save_callback = task->tk_callback; | ||
2732 | task->tk_callback = NULL; | ||
2733 | save_callback(task); | ||
2734 | - } | ||
2735 | - | ||
2736 | - /* | ||
2737 | - * Perform the next FSM step. | ||
2738 | - * tk_action may be NULL when the task has been killed | ||
2739 | - * by someone else. | ||
2740 | - */ | ||
2741 | - if (!RPC_IS_QUEUED(task)) { | ||
2742 | + } else { | ||
2743 | + /* | ||
2744 | + * Perform the next FSM step. | ||
2745 | + * tk_action may be NULL when the task has been killed | ||
2746 | + * by someone else. | ||
2747 | + */ | ||
2748 | if (task->tk_action == NULL) | ||
2749 | break; | ||
2750 | task->tk_action(task); | ||
2751 | diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c | ||
2752 | index dfcab5a..3ad452b 100644 | ||
2753 | --- a/net/sunrpc/xprtsock.c | ||
2754 | +++ b/net/sunrpc/xprtsock.c | ||
2755 | @@ -1631,7 +1631,8 @@ static struct socket *xs_create_sock(struct rpc_xprt *xprt, | ||
2756 | } | ||
2757 | xs_reclassify_socket(family, sock); | ||
2758 | |||
2759 | - if (xs_bind(transport, sock)) { | ||
2760 | + err = xs_bind(transport, sock); | ||
2761 | + if (err) { | ||
2762 | sock_release(sock); | ||
2763 | goto out; | ||
2764 | } | ||
2765 | diff --git a/security/tomoyo/file.c b/security/tomoyo/file.c | ||
2766 | index 9d32f18..cb09f1f 100644 | ||
2767 | --- a/security/tomoyo/file.c | ||
2768 | +++ b/security/tomoyo/file.c | ||
2769 | @@ -927,7 +927,7 @@ int tomoyo_check_open_permission(struct tomoyo_domain_info *domain, | ||
2770 | struct path *path, const int flag) | ||
2771 | { | ||
2772 | const u8 acc_mode = ACC_MODE(flag); | ||
2773 | - int error = -ENOMEM; | ||
2774 | + int error = 0; | ||
2775 | struct tomoyo_path_info buf; | ||
2776 | struct tomoyo_request_info r; | ||
2777 | int idx; | ||
2778 | @@ -938,9 +938,6 @@ int tomoyo_check_open_permission(struct tomoyo_domain_info *domain, | ||
2779 | buf.name = NULL; | ||
2780 | r.mode = TOMOYO_CONFIG_DISABLED; | ||
2781 | idx = tomoyo_read_lock(); | ||
2782 | - if (!tomoyo_get_realpath(&buf, path)) | ||
2783 | - goto out; | ||
2784 | - error = 0; | ||
2785 | /* | ||
2786 | * If the filename is specified by "deny_rewrite" keyword, | ||
2787 | * we need to check "allow_rewrite" permission when the filename is not | ||
2788 | diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c | ||
2789 | index 12b44b0..a0da775 100644 | ||
2790 | --- a/sound/drivers/aloop.c | ||
2791 | +++ b/sound/drivers/aloop.c | ||
2792 | @@ -482,8 +482,9 @@ static unsigned int loopback_pos_update(struct loopback_cable *cable) | ||
2793 | cable->streams[SNDRV_PCM_STREAM_CAPTURE]; | ||
2794 | unsigned long delta_play = 0, delta_capt = 0; | ||
2795 | unsigned int running; | ||
2796 | + unsigned long flags; | ||
2797 | |||
2798 | - spin_lock(&cable->lock); | ||
2799 | + spin_lock_irqsave(&cable->lock, flags); | ||
2800 | running = cable->running ^ cable->pause; | ||
2801 | if (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) { | ||
2802 | delta_play = jiffies - dpcm_play->last_jiffies; | ||
2803 | @@ -495,10 +496,8 @@ static unsigned int loopback_pos_update(struct loopback_cable *cable) | ||
2804 | dpcm_capt->last_jiffies += delta_capt; | ||
2805 | } | ||
2806 | |||
2807 | - if (delta_play == 0 && delta_capt == 0) { | ||
2808 | - spin_unlock(&cable->lock); | ||
2809 | - return running; | ||
2810 | - } | ||
2811 | + if (delta_play == 0 && delta_capt == 0) | ||
2812 | + goto unlock; | ||
2813 | |||
2814 | if (delta_play > delta_capt) { | ||
2815 | loopback_bytepos_update(dpcm_play, delta_play - delta_capt, | ||
2816 | @@ -510,14 +509,14 @@ static unsigned int loopback_pos_update(struct loopback_cable *cable) | ||
2817 | delta_capt = delta_play; | ||
2818 | } | ||
2819 | |||
2820 | - if (delta_play == 0 && delta_capt == 0) { | ||
2821 | - spin_unlock(&cable->lock); | ||
2822 | - return running; | ||
2823 | - } | ||
2824 | + if (delta_play == 0 && delta_capt == 0) | ||
2825 | + goto unlock; | ||
2826 | + | ||
2827 | /* note delta_capt == delta_play at this moment */ | ||
2828 | loopback_bytepos_update(dpcm_capt, delta_capt, BYTEPOS_UPDATE_COPY); | ||
2829 | loopback_bytepos_update(dpcm_play, delta_play, BYTEPOS_UPDATE_POSONLY); | ||
2830 | - spin_unlock(&cable->lock); | ||
2831 | + unlock: | ||
2832 | + spin_unlock_irqrestore(&cable->lock, flags); | ||
2833 | return running; | ||
2834 | } | ||
2835 | |||
2836 | diff --git a/sound/pci/asihpi/hpioctl.c b/sound/pci/asihpi/hpioctl.c | ||
2837 | index 22dbd91..448dd01 100644 | ||
2838 | --- a/sound/pci/asihpi/hpioctl.c | ||
2839 | +++ b/sound/pci/asihpi/hpioctl.c | ||
2840 | @@ -155,6 +155,11 @@ long asihpi_hpi_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | ||
2841 | goto out; | ||
2842 | } | ||
2843 | |||
2844 | + if (hm->h.adapter_index >= HPI_MAX_ADAPTERS) { | ||
2845 | + err = -EINVAL; | ||
2846 | + goto out; | ||
2847 | + } | ||
2848 | + | ||
2849 | pa = &adapters[hm->h.adapter_index]; | ||
2850 | hr->h.size = 0; | ||
2851 | if (hm->h.object == HPI_OBJ_SUBSYSTEM) { | ||
2852 | diff --git a/sound/pci/ctxfi/ctatc.c b/sound/pci/ctxfi/ctatc.c | ||
2853 | index 1bff80c..b932154 100644 | ||
2854 | --- a/sound/pci/ctxfi/ctatc.c | ||
2855 | +++ b/sound/pci/ctxfi/ctatc.c | ||
2856 | @@ -869,7 +869,7 @@ spdif_passthru_playback_setup(struct ct_atc *atc, struct ct_atc_pcm *apcm) | ||
2857 | mutex_lock(&atc->atc_mutex); | ||
2858 | dao->ops->get_spos(dao, &status); | ||
2859 | if (((status >> 24) & IEC958_AES3_CON_FS) != iec958_con_fs) { | ||
2860 | - status &= ((~IEC958_AES3_CON_FS) << 24); | ||
2861 | + status &= ~(IEC958_AES3_CON_FS << 24); | ||
2862 | status |= (iec958_con_fs << 24); | ||
2863 | dao->ops->set_spos(dao, status); | ||
2864 | dao->ops->commit_write(dao); | ||
2865 | diff --git a/sound/pci/ctxfi/ctdaio.c b/sound/pci/ctxfi/ctdaio.c | ||
2866 | index af56eb9..47d9ea9 100644 | ||
2867 | --- a/sound/pci/ctxfi/ctdaio.c | ||
2868 | +++ b/sound/pci/ctxfi/ctdaio.c | ||
2869 | @@ -176,6 +176,7 @@ static int dao_set_left_input(struct dao *dao, struct rsc *input) | ||
2870 | if (!entry) | ||
2871 | return -ENOMEM; | ||
2872 | |||
2873 | + dao->ops->clear_left_input(dao); | ||
2874 | /* Program master and conjugate resources */ | ||
2875 | input->ops->master(input); | ||
2876 | daio->rscl.ops->master(&daio->rscl); | ||
2877 | @@ -204,6 +205,7 @@ static int dao_set_right_input(struct dao *dao, struct rsc *input) | ||
2878 | if (!entry) | ||
2879 | return -ENOMEM; | ||
2880 | |||
2881 | + dao->ops->clear_right_input(dao); | ||
2882 | /* Program master and conjugate resources */ | ||
2883 | input->ops->master(input); | ||
2884 | daio->rscr.ops->master(&daio->rscr); | ||
2885 | diff --git a/sound/pci/ctxfi/ctmixer.c b/sound/pci/ctxfi/ctmixer.c | ||
2886 | index 15c1e72..c3519ff 100644 | ||
2887 | --- a/sound/pci/ctxfi/ctmixer.c | ||
2888 | +++ b/sound/pci/ctxfi/ctmixer.c | ||
2889 | @@ -566,19 +566,6 @@ static int ct_spdif_get_mask(struct snd_kcontrol *kcontrol, | ||
2890 | return 0; | ||
2891 | } | ||
2892 | |||
2893 | -static int ct_spdif_default_get(struct snd_kcontrol *kcontrol, | ||
2894 | - struct snd_ctl_elem_value *ucontrol) | ||
2895 | -{ | ||
2896 | - unsigned int status = SNDRV_PCM_DEFAULT_CON_SPDIF; | ||
2897 | - | ||
2898 | - ucontrol->value.iec958.status[0] = (status >> 0) & 0xff; | ||
2899 | - ucontrol->value.iec958.status[1] = (status >> 8) & 0xff; | ||
2900 | - ucontrol->value.iec958.status[2] = (status >> 16) & 0xff; | ||
2901 | - ucontrol->value.iec958.status[3] = (status >> 24) & 0xff; | ||
2902 | - | ||
2903 | - return 0; | ||
2904 | -} | ||
2905 | - | ||
2906 | static int ct_spdif_get(struct snd_kcontrol *kcontrol, | ||
2907 | struct snd_ctl_elem_value *ucontrol) | ||
2908 | { | ||
2909 | @@ -586,6 +573,10 @@ static int ct_spdif_get(struct snd_kcontrol *kcontrol, | ||
2910 | unsigned int status; | ||
2911 | |||
2912 | atc->spdif_out_get_status(atc, &status); | ||
2913 | + | ||
2914 | + if (status == 0) | ||
2915 | + status = SNDRV_PCM_DEFAULT_CON_SPDIF; | ||
2916 | + | ||
2917 | ucontrol->value.iec958.status[0] = (status >> 0) & 0xff; | ||
2918 | ucontrol->value.iec958.status[1] = (status >> 8) & 0xff; | ||
2919 | ucontrol->value.iec958.status[2] = (status >> 16) & 0xff; | ||
2920 | @@ -629,7 +620,7 @@ static struct snd_kcontrol_new iec958_default_ctl = { | ||
2921 | .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), | ||
2922 | .count = 1, | ||
2923 | .info = ct_spdif_info, | ||
2924 | - .get = ct_spdif_default_get, | ||
2925 | + .get = ct_spdif_get, | ||
2926 | .put = ct_spdif_put, | ||
2927 | .private_value = MIXER_IEC958_DEFAULT | ||
2928 | }; | ||
2929 | diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c | ||
2930 | index e61c87c..6e44994 100644 | ||
2931 | --- a/sound/pci/hda/patch_realtek.c | ||
2932 | +++ b/sound/pci/hda/patch_realtek.c | ||
2933 | @@ -393,6 +393,7 @@ struct alc_spec { | ||
2934 | /* other flags */ | ||
2935 | unsigned int no_analog :1; /* digital I/O only */ | ||
2936 | unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */ | ||
2937 | + unsigned int single_input_src:1; | ||
2938 | int init_amp; | ||
2939 | int codec_variant; /* flag for other variants */ | ||
2940 | |||
2941 | @@ -3798,6 +3799,8 @@ static struct hda_amp_list alc880_lg_loopbacks[] = { | ||
2942 | * Common callbacks | ||
2943 | */ | ||
2944 | |||
2945 | +static void alc_init_special_input_src(struct hda_codec *codec); | ||
2946 | + | ||
2947 | static int alc_init(struct hda_codec *codec) | ||
2948 | { | ||
2949 | struct alc_spec *spec = codec->spec; | ||
2950 | @@ -3808,6 +3811,7 @@ static int alc_init(struct hda_codec *codec) | ||
2951 | |||
2952 | for (i = 0; i < spec->num_init_verbs; i++) | ||
2953 | snd_hda_sequence_write(codec, spec->init_verbs[i]); | ||
2954 | + alc_init_special_input_src(codec); | ||
2955 | |||
2956 | if (spec->init_hook) | ||
2957 | spec->init_hook(codec); | ||
2958 | @@ -5441,6 +5445,7 @@ static void fixup_single_adc(struct hda_codec *codec) | ||
2959 | spec->capsrc_nids += i; | ||
2960 | spec->adc_nids += i; | ||
2961 | spec->num_adc_nids = 1; | ||
2962 | + spec->single_input_src = 1; | ||
2963 | } | ||
2964 | } | ||
2965 | |||
2966 | @@ -5452,6 +5457,16 @@ static void fixup_dual_adc_switch(struct hda_codec *codec) | ||
2967 | init_capsrc_for_pin(codec, spec->int_mic.pin); | ||
2968 | } | ||
2969 | |||
2970 | +/* initialize some special cases for input sources */ | ||
2971 | +static void alc_init_special_input_src(struct hda_codec *codec) | ||
2972 | +{ | ||
2973 | + struct alc_spec *spec = codec->spec; | ||
2974 | + if (spec->dual_adc_switch) | ||
2975 | + fixup_dual_adc_switch(codec); | ||
2976 | + else if (spec->single_input_src) | ||
2977 | + init_capsrc_for_pin(codec, spec->autocfg.inputs[0].pin); | ||
2978 | +} | ||
2979 | + | ||
2980 | static void set_capture_mixer(struct hda_codec *codec) | ||
2981 | { | ||
2982 | struct alc_spec *spec = codec->spec; | ||
2983 | @@ -5467,7 +5482,7 @@ static void set_capture_mixer(struct hda_codec *codec) | ||
2984 | int mux = 0; | ||
2985 | int num_adcs = spec->num_adc_nids; | ||
2986 | if (spec->dual_adc_switch) | ||
2987 | - fixup_dual_adc_switch(codec); | ||
2988 | + num_adcs = 1; | ||
2989 | else if (spec->auto_mic) | ||
2990 | fixup_automic_adc(codec); | ||
2991 | else if (spec->input_mux) { | ||
2992 | @@ -5476,8 +5491,6 @@ static void set_capture_mixer(struct hda_codec *codec) | ||
2993 | else if (spec->input_mux->num_items == 1) | ||
2994 | fixup_single_adc(codec); | ||
2995 | } | ||
2996 | - if (spec->dual_adc_switch) | ||
2997 | - num_adcs = 1; | ||
2998 | spec->cap_mixer = caps[mux][num_adcs - 1]; | ||
2999 | } | ||
3000 | } | ||
3001 | @@ -10736,23 +10749,28 @@ static void alc882_auto_init_hp_out(struct hda_codec *codec) | ||
3002 | hda_nid_t pin, dac; | ||
3003 | int i; | ||
3004 | |||
3005 | - for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) { | ||
3006 | - pin = spec->autocfg.hp_pins[i]; | ||
3007 | - if (!pin) | ||
3008 | - break; | ||
3009 | - dac = spec->multiout.hp_nid; | ||
3010 | - if (!dac) | ||
3011 | - dac = spec->multiout.dac_nids[0]; /* to front */ | ||
3012 | - alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac); | ||
3013 | + if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT) { | ||
3014 | + for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) { | ||
3015 | + pin = spec->autocfg.hp_pins[i]; | ||
3016 | + if (!pin) | ||
3017 | + break; | ||
3018 | + dac = spec->multiout.hp_nid; | ||
3019 | + if (!dac) | ||
3020 | + dac = spec->multiout.dac_nids[0]; /* to front */ | ||
3021 | + alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac); | ||
3022 | + } | ||
3023 | } | ||
3024 | - for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) { | ||
3025 | - pin = spec->autocfg.speaker_pins[i]; | ||
3026 | - if (!pin) | ||
3027 | - break; | ||
3028 | - dac = spec->multiout.extra_out_nid[0]; | ||
3029 | - if (!dac) | ||
3030 | - dac = spec->multiout.dac_nids[0]; /* to front */ | ||
3031 | - alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac); | ||
3032 | + | ||
3033 | + if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT) { | ||
3034 | + for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) { | ||
3035 | + pin = spec->autocfg.speaker_pins[i]; | ||
3036 | + if (!pin) | ||
3037 | + break; | ||
3038 | + dac = spec->multiout.extra_out_nid[0]; | ||
3039 | + if (!dac) | ||
3040 | + dac = spec->multiout.dac_nids[0]; /* to front */ | ||
3041 | + alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac); | ||
3042 | + } | ||
3043 | } | ||
3044 | } | ||
3045 | |||
3046 | diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c | ||
3047 | index fc16beb..797a16c 100644 | ||
3048 | --- a/sound/pci/hda/patch_sigmatel.c | ||
3049 | +++ b/sound/pci/hda/patch_sigmatel.c | ||
3050 | @@ -749,7 +749,7 @@ static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e | ||
3051 | struct sigmatel_spec *spec = codec->spec; | ||
3052 | unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); | ||
3053 | const struct hda_input_mux *imux = spec->input_mux; | ||
3054 | - unsigned int idx, prev_idx; | ||
3055 | + unsigned int idx, prev_idx, didx; | ||
3056 | |||
3057 | idx = ucontrol->value.enumerated.item[0]; | ||
3058 | if (idx >= imux->num_items) | ||
3059 | @@ -761,7 +761,8 @@ static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e | ||
3060 | snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0, | ||
3061 | AC_VERB_SET_CONNECT_SEL, | ||
3062 | imux->items[idx].index); | ||
3063 | - if (prev_idx >= spec->num_analog_muxes) { | ||
3064 | + if (prev_idx >= spec->num_analog_muxes && | ||
3065 | + spec->mux_nids[adc_idx] != spec->dmux_nids[adc_idx]) { | ||
3066 | imux = spec->dinput_mux; | ||
3067 | /* 0 = analog */ | ||
3068 | snd_hda_codec_write_cache(codec, | ||
3069 | @@ -771,9 +772,13 @@ static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e | ||
3070 | } | ||
3071 | } else { | ||
3072 | imux = spec->dinput_mux; | ||
3073 | + /* first dimux item is hardcoded to select analog imux, | ||
3074 | + * so lets skip it | ||
3075 | + */ | ||
3076 | + didx = idx - spec->num_analog_muxes + 1; | ||
3077 | snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0, | ||
3078 | AC_VERB_SET_CONNECT_SEL, | ||
3079 | - imux->items[idx - 1].index); | ||
3080 | + imux->items[didx].index); | ||
3081 | } | ||
3082 | spec->cur_mux[adc_idx] = idx; | ||
3083 | return 1; | ||
3084 | diff --git a/sound/soc/codecs/wm8978.c b/sound/soc/codecs/wm8978.c | ||
3085 | index 13b979a..a008aeb 100644 | ||
3086 | --- a/sound/soc/codecs/wm8978.c | ||
3087 | +++ b/sound/soc/codecs/wm8978.c | ||
3088 | @@ -147,18 +147,18 @@ static const struct snd_kcontrol_new wm8978_snd_controls[] = { | ||
3089 | SOC_SINGLE("DAC Playback Limiter Threshold", | ||
3090 | WM8978_DAC_LIMITER_2, 4, 7, 0), | ||
3091 | SOC_SINGLE("DAC Playback Limiter Boost", | ||
3092 | - WM8978_DAC_LIMITER_2, 0, 15, 0), | ||
3093 | + WM8978_DAC_LIMITER_2, 0, 12, 0), | ||
3094 | |||
3095 | SOC_ENUM("ALC Enable Switch", alc1), | ||
3096 | SOC_SINGLE("ALC Capture Min Gain", WM8978_ALC_CONTROL_1, 0, 7, 0), | ||
3097 | SOC_SINGLE("ALC Capture Max Gain", WM8978_ALC_CONTROL_1, 3, 7, 0), | ||
3098 | |||
3099 | - SOC_SINGLE("ALC Capture Hold", WM8978_ALC_CONTROL_2, 4, 7, 0), | ||
3100 | + SOC_SINGLE("ALC Capture Hold", WM8978_ALC_CONTROL_2, 4, 10, 0), | ||
3101 | SOC_SINGLE("ALC Capture Target", WM8978_ALC_CONTROL_2, 0, 15, 0), | ||
3102 | |||
3103 | SOC_ENUM("ALC Capture Mode", alc3), | ||
3104 | - SOC_SINGLE("ALC Capture Decay", WM8978_ALC_CONTROL_3, 4, 15, 0), | ||
3105 | - SOC_SINGLE("ALC Capture Attack", WM8978_ALC_CONTROL_3, 0, 15, 0), | ||
3106 | + SOC_SINGLE("ALC Capture Decay", WM8978_ALC_CONTROL_3, 4, 10, 0), | ||
3107 | + SOC_SINGLE("ALC Capture Attack", WM8978_ALC_CONTROL_3, 0, 10, 0), | ||
3108 | |||
3109 | SOC_SINGLE("ALC Capture Noise Gate Switch", WM8978_NOISE_GATE, 3, 1, 0), | ||
3110 | SOC_SINGLE("ALC Capture Noise Gate Threshold", | ||
3111 | @@ -213,8 +213,10 @@ static const struct snd_kcontrol_new wm8978_snd_controls[] = { | ||
3112 | WM8978_LOUT2_SPK_CONTROL, WM8978_ROUT2_SPK_CONTROL, 6, 1, 1), | ||
3113 | |||
3114 | /* DAC / ADC oversampling */ | ||
3115 | - SOC_SINGLE("DAC 128x Oversampling Switch", WM8978_DAC_CONTROL, 8, 1, 0), | ||
3116 | - SOC_SINGLE("ADC 128x Oversampling Switch", WM8978_ADC_CONTROL, 8, 1, 0), | ||
3117 | + SOC_SINGLE("DAC 128x Oversampling Switch", WM8978_DAC_CONTROL, | ||
3118 | + 5, 1, 0), | ||
3119 | + SOC_SINGLE("ADC 128x Oversampling Switch", WM8978_ADC_CONTROL, | ||
3120 | + 5, 1, 0), | ||
3121 | }; | ||
3122 | |||
3123 | /* Mixer #1: Output (OUT1, OUT2) Mixer: mix AUX, Input mixer output and DAC */ | ||
3124 | diff --git a/tools/perf/util/PERF-VERSION-GEN b/tools/perf/util/PERF-VERSION-GEN | ||
3125 | index 97d7656..26d4d3f 100755 | ||
3126 | --- a/tools/perf/util/PERF-VERSION-GEN | ||
3127 | +++ b/tools/perf/util/PERF-VERSION-GEN | ||
3128 | @@ -23,10 +23,10 @@ if test -d ../../.git -o -f ../../.git && | ||
3129 | then | ||
3130 | VN=$(echo "$VN" | sed -e 's/-/./g'); | ||
3131 | else | ||
3132 | - eval `grep '^VERSION\s*=' ../../Makefile|tr -d ' '` | ||
3133 | - eval `grep '^PATCHLEVEL\s*=' ../../Makefile|tr -d ' '` | ||
3134 | - eval `grep '^SUBLEVEL\s*=' ../../Makefile|tr -d ' '` | ||
3135 | - eval `grep '^EXTRAVERSION\s*=' ../../Makefile|tr -d ' '` | ||
3136 | + eval $(grep '^VERSION[[:space:]]*=' ../../Makefile|tr -d ' ') | ||
3137 | + eval $(grep '^PATCHLEVEL[[:space:]]*=' ../../Makefile|tr -d ' ') | ||
3138 | + eval $(grep '^SUBLEVEL[[:space:]]*=' ../../Makefile|tr -d ' ') | ||
3139 | + eval $(grep '^EXTRAVERSION[[:space:]]*=' ../../Makefile|tr -d ' ') | ||
3140 | |||
3141 | VN="${VERSION}.${PATCHLEVEL}.${SUBLEVEL}${EXTRAVERSION}" | ||
3142 | fi |