Annotation of /trunk/kernel-lts/patches-3.4/0164-3.4.65-all-fixes.patch
Parent Directory | Revision Log
Revision 2306 -
(hide annotations)
(download)
Mon Oct 14 07:15:35 2013 UTC (10 years, 11 months ago) by niro
File size: 19055 byte(s)
Mon Oct 14 07:15:35 2013 UTC (10 years, 11 months ago) by niro
File size: 19055 byte(s)
-linux-3.4.65
1 | niro | 2306 | diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c |
2 | index df1b604..bd70df6 100644 | ||
3 | --- a/arch/x86/kernel/reboot.c | ||
4 | +++ b/arch/x86/kernel/reboot.c | ||
5 | @@ -479,6 +479,22 @@ static struct dmi_system_id __initdata pci_reboot_dmi_table[] = { | ||
6 | DMI_MATCH(DMI_PRODUCT_NAME, "Precision M6600"), | ||
7 | }, | ||
8 | }, | ||
9 | + { /* Handle problems with rebooting on the Dell PowerEdge C6100. */ | ||
10 | + .callback = set_pci_reboot, | ||
11 | + .ident = "Dell PowerEdge C6100", | ||
12 | + .matches = { | ||
13 | + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), | ||
14 | + DMI_MATCH(DMI_PRODUCT_NAME, "C6100"), | ||
15 | + }, | ||
16 | + }, | ||
17 | + { /* Some C6100 machines were shipped with vendor being 'Dell'. */ | ||
18 | + .callback = set_pci_reboot, | ||
19 | + .ident = "Dell PowerEdge C6100", | ||
20 | + .matches = { | ||
21 | + DMI_MATCH(DMI_SYS_VENDOR, "Dell"), | ||
22 | + DMI_MATCH(DMI_PRODUCT_NAME, "C6100"), | ||
23 | + }, | ||
24 | + }, | ||
25 | { } | ||
26 | }; | ||
27 | |||
28 | diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c | ||
29 | index 1e40637..454548c 100644 | ||
30 | --- a/arch/x86/platform/efi/efi.c | ||
31 | +++ b/arch/x86/platform/efi/efi.c | ||
32 | @@ -845,10 +845,13 @@ void __init efi_enter_virtual_mode(void) | ||
33 | |||
34 | for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { | ||
35 | md = p; | ||
36 | - if (!(md->attribute & EFI_MEMORY_RUNTIME) && | ||
37 | - md->type != EFI_BOOT_SERVICES_CODE && | ||
38 | - md->type != EFI_BOOT_SERVICES_DATA) | ||
39 | - continue; | ||
40 | + if (!(md->attribute & EFI_MEMORY_RUNTIME)) { | ||
41 | +#ifdef CONFIG_X86_64 | ||
42 | + if (md->type != EFI_BOOT_SERVICES_CODE && | ||
43 | + md->type != EFI_BOOT_SERVICES_DATA) | ||
44 | +#endif | ||
45 | + continue; | ||
46 | + } | ||
47 | |||
48 | size = md->num_pages << EFI_PAGE_SHIFT; | ||
49 | end = md->phys_addr + size; | ||
50 | diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c | ||
51 | index 069725c..eee6cd3 100644 | ||
52 | --- a/drivers/gpu/drm/i915/intel_dp.c | ||
53 | +++ b/drivers/gpu/drm/i915/intel_dp.c | ||
54 | @@ -625,7 +625,18 @@ intel_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode, | ||
55 | DRM_DEBUG_KMS("aux_ch native nack\n"); | ||
56 | return -EREMOTEIO; | ||
57 | case AUX_NATIVE_REPLY_DEFER: | ||
58 | - udelay(100); | ||
59 | + /* | ||
60 | + * For now, just give more slack to branch devices. We | ||
61 | + * could check the DPCD for I2C bit rate capabilities, | ||
62 | + * and if available, adjust the interval. We could also | ||
63 | + * be more careful with DP-to-Legacy adapters where a | ||
64 | + * long legacy cable may force very low I2C bit rates. | ||
65 | + */ | ||
66 | + if (intel_dp->dpcd[DP_DOWNSTREAMPORT_PRESENT] & | ||
67 | + DP_DWN_STRM_PORT_PRESENT) | ||
68 | + usleep_range(500, 600); | ||
69 | + else | ||
70 | + usleep_range(300, 400); | ||
71 | continue; | ||
72 | default: | ||
73 | DRM_ERROR("aux_ch invalid native reply 0x%02x\n", | ||
74 | diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c | ||
75 | index 1209f15..2f555d7 100644 | ||
76 | --- a/drivers/gpu/drm/radeon/radeon_device.c | ||
77 | +++ b/drivers/gpu/drm/radeon/radeon_device.c | ||
78 | @@ -835,13 +835,22 @@ int radeon_device_init(struct radeon_device *rdev, | ||
79 | return r; | ||
80 | } | ||
81 | if ((radeon_testing & 1)) { | ||
82 | - radeon_test_moves(rdev); | ||
83 | + if (rdev->accel_working) | ||
84 | + radeon_test_moves(rdev); | ||
85 | + else | ||
86 | + DRM_INFO("radeon: acceleration disabled, skipping move tests\n"); | ||
87 | } | ||
88 | if ((radeon_testing & 2)) { | ||
89 | - radeon_test_syncing(rdev); | ||
90 | + if (rdev->accel_working) | ||
91 | + radeon_test_syncing(rdev); | ||
92 | + else | ||
93 | + DRM_INFO("radeon: acceleration disabled, skipping sync tests\n"); | ||
94 | } | ||
95 | if (radeon_benchmarking) { | ||
96 | - radeon_benchmark(rdev, radeon_benchmarking); | ||
97 | + if (rdev->accel_working) | ||
98 | + radeon_benchmark(rdev, radeon_benchmarking); | ||
99 | + else | ||
100 | + DRM_INFO("radeon: acceleration disabled, skipping benchmarks\n"); | ||
101 | } | ||
102 | return 0; | ||
103 | } | ||
104 | diff --git a/drivers/hid/hid-lg2ff.c b/drivers/hid/hid-lg2ff.c | ||
105 | index 3c31bc6..128f011 100644 | ||
106 | --- a/drivers/hid/hid-lg2ff.c | ||
107 | +++ b/drivers/hid/hid-lg2ff.c | ||
108 | @@ -66,26 +66,13 @@ int lg2ff_init(struct hid_device *hid) | ||
109 | struct hid_report *report; | ||
110 | struct hid_input *hidinput = list_entry(hid->inputs.next, | ||
111 | struct hid_input, list); | ||
112 | - struct list_head *report_list = | ||
113 | - &hid->report_enum[HID_OUTPUT_REPORT].report_list; | ||
114 | struct input_dev *dev = hidinput->input; | ||
115 | int error; | ||
116 | |||
117 | - if (list_empty(report_list)) { | ||
118 | - hid_err(hid, "no output report found\n"); | ||
119 | + /* Check that the report looks ok */ | ||
120 | + report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7); | ||
121 | + if (!report) | ||
122 | return -ENODEV; | ||
123 | - } | ||
124 | - | ||
125 | - report = list_entry(report_list->next, struct hid_report, list); | ||
126 | - | ||
127 | - if (report->maxfield < 1) { | ||
128 | - hid_err(hid, "output report is empty\n"); | ||
129 | - return -ENODEV; | ||
130 | - } | ||
131 | - if (report->field[0]->report_count < 7) { | ||
132 | - hid_err(hid, "not enough values in the field\n"); | ||
133 | - return -ENODEV; | ||
134 | - } | ||
135 | |||
136 | lg2ff = kmalloc(sizeof(struct lg2ff_device), GFP_KERNEL); | ||
137 | if (!lg2ff) | ||
138 | diff --git a/drivers/hid/hid-lg3ff.c b/drivers/hid/hid-lg3ff.c | ||
139 | index f98644c..91f981f 100644 | ||
140 | --- a/drivers/hid/hid-lg3ff.c | ||
141 | +++ b/drivers/hid/hid-lg3ff.c | ||
142 | @@ -68,10 +68,11 @@ static int hid_lg3ff_play(struct input_dev *dev, void *data, | ||
143 | int x, y; | ||
144 | |||
145 | /* | ||
146 | - * Maxusage should always be 63 (maximum fields) | ||
147 | - * likely a better way to ensure this data is clean | ||
148 | + * Available values in the field should always be 63, but we only use up to | ||
149 | + * 35. Instead, clear the entire area, however big it is. | ||
150 | */ | ||
151 | - memset(report->field[0]->value, 0, sizeof(__s32)*report->field[0]->maxusage); | ||
152 | + memset(report->field[0]->value, 0, | ||
153 | + sizeof(__s32) * report->field[0]->report_count); | ||
154 | |||
155 | switch (effect->type) { | ||
156 | case FF_CONSTANT: | ||
157 | @@ -131,32 +132,14 @@ static const signed short ff3_joystick_ac[] = { | ||
158 | int lg3ff_init(struct hid_device *hid) | ||
159 | { | ||
160 | struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); | ||
161 | - struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; | ||
162 | struct input_dev *dev = hidinput->input; | ||
163 | - struct hid_report *report; | ||
164 | - struct hid_field *field; | ||
165 | const signed short *ff_bits = ff3_joystick_ac; | ||
166 | int error; | ||
167 | int i; | ||
168 | |||
169 | - /* Find the report to use */ | ||
170 | - if (list_empty(report_list)) { | ||
171 | - hid_err(hid, "No output report found\n"); | ||
172 | - return -1; | ||
173 | - } | ||
174 | - | ||
175 | /* Check that the report looks ok */ | ||
176 | - report = list_entry(report_list->next, struct hid_report, list); | ||
177 | - if (!report) { | ||
178 | - hid_err(hid, "NULL output report\n"); | ||
179 | - return -1; | ||
180 | - } | ||
181 | - | ||
182 | - field = report->field[0]; | ||
183 | - if (!field) { | ||
184 | - hid_err(hid, "NULL field\n"); | ||
185 | - return -1; | ||
186 | - } | ||
187 | + if (!hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 35)) | ||
188 | + return -ENODEV; | ||
189 | |||
190 | /* Assume single fixed device G940 */ | ||
191 | for (i = 0; ff_bits[i] >= 0; i++) | ||
192 | diff --git a/drivers/hid/hid-lg4ff.c b/drivers/hid/hid-lg4ff.c | ||
193 | index 6ecc9e2..44bb0a5 100644 | ||
194 | --- a/drivers/hid/hid-lg4ff.c | ||
195 | +++ b/drivers/hid/hid-lg4ff.c | ||
196 | @@ -339,33 +339,15 @@ static ssize_t lg4ff_range_store(struct device *dev, struct device_attribute *at | ||
197 | int lg4ff_init(struct hid_device *hid) | ||
198 | { | ||
199 | struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); | ||
200 | - struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; | ||
201 | struct input_dev *dev = hidinput->input; | ||
202 | - struct hid_report *report; | ||
203 | - struct hid_field *field; | ||
204 | struct lg4ff_device_entry *entry; | ||
205 | struct usb_device_descriptor *udesc; | ||
206 | int error, i, j; | ||
207 | __u16 bcdDevice, rev_maj, rev_min; | ||
208 | |||
209 | - /* Find the report to use */ | ||
210 | - if (list_empty(report_list)) { | ||
211 | - hid_err(hid, "No output report found\n"); | ||
212 | - return -1; | ||
213 | - } | ||
214 | - | ||
215 | /* Check that the report looks ok */ | ||
216 | - report = list_entry(report_list->next, struct hid_report, list); | ||
217 | - if (!report) { | ||
218 | - hid_err(hid, "NULL output report\n"); | ||
219 | + if (!hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7)) | ||
220 | return -1; | ||
221 | - } | ||
222 | - | ||
223 | - field = report->field[0]; | ||
224 | - if (!field) { | ||
225 | - hid_err(hid, "NULL field\n"); | ||
226 | - return -1; | ||
227 | - } | ||
228 | |||
229 | /* Check what wheel has been connected */ | ||
230 | for (i = 0; i < ARRAY_SIZE(lg4ff_devices); i++) { | ||
231 | diff --git a/drivers/hid/hid-lgff.c b/drivers/hid/hid-lgff.c | ||
232 | index 27bc54f..1d978daa 100644 | ||
233 | --- a/drivers/hid/hid-lgff.c | ||
234 | +++ b/drivers/hid/hid-lgff.c | ||
235 | @@ -130,27 +130,14 @@ static void hid_lgff_set_autocenter(struct input_dev *dev, u16 magnitude) | ||
236 | int lgff_init(struct hid_device* hid) | ||
237 | { | ||
238 | struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); | ||
239 | - struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; | ||
240 | struct input_dev *dev = hidinput->input; | ||
241 | - struct hid_report *report; | ||
242 | - struct hid_field *field; | ||
243 | const signed short *ff_bits = ff_joystick; | ||
244 | int error; | ||
245 | int i; | ||
246 | |||
247 | - /* Find the report to use */ | ||
248 | - if (list_empty(report_list)) { | ||
249 | - hid_err(hid, "No output report found\n"); | ||
250 | - return -1; | ||
251 | - } | ||
252 | - | ||
253 | /* Check that the report looks ok */ | ||
254 | - report = list_entry(report_list->next, struct hid_report, list); | ||
255 | - field = report->field[0]; | ||
256 | - if (!field) { | ||
257 | - hid_err(hid, "NULL field\n"); | ||
258 | - return -1; | ||
259 | - } | ||
260 | + if (!hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7)) | ||
261 | + return -ENODEV; | ||
262 | |||
263 | for (i = 0; i < ARRAY_SIZE(devices); i++) { | ||
264 | if (dev->id.vendor == devices[i].idVendor && | ||
265 | diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c | ||
266 | index 70d62f5..73bea49 100644 | ||
267 | --- a/drivers/hwmon/applesmc.c | ||
268 | +++ b/drivers/hwmon/applesmc.c | ||
269 | @@ -489,16 +489,25 @@ static int applesmc_init_smcreg_try(void) | ||
270 | { | ||
271 | struct applesmc_registers *s = &smcreg; | ||
272 | bool left_light_sensor, right_light_sensor; | ||
273 | + unsigned int count; | ||
274 | u8 tmp[1]; | ||
275 | int ret; | ||
276 | |||
277 | if (s->init_complete) | ||
278 | return 0; | ||
279 | |||
280 | - ret = read_register_count(&s->key_count); | ||
281 | + ret = read_register_count(&count); | ||
282 | if (ret) | ||
283 | return ret; | ||
284 | |||
285 | + if (s->cache && s->key_count != count) { | ||
286 | + pr_warn("key count changed from %d to %d\n", | ||
287 | + s->key_count, count); | ||
288 | + kfree(s->cache); | ||
289 | + s->cache = NULL; | ||
290 | + } | ||
291 | + s->key_count = count; | ||
292 | + | ||
293 | if (!s->cache) | ||
294 | s->cache = kcalloc(s->key_count, sizeof(*s->cache), GFP_KERNEL); | ||
295 | if (!s->cache) | ||
296 | diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c | ||
297 | index 3ac4156..4caa8e6 100644 | ||
298 | --- a/drivers/md/dm-snap-persistent.c | ||
299 | +++ b/drivers/md/dm-snap-persistent.c | ||
300 | @@ -256,7 +256,7 @@ static int chunk_io(struct pstore *ps, void *area, chunk_t chunk, int rw, | ||
301 | */ | ||
302 | INIT_WORK_ONSTACK(&req.work, do_metadata); | ||
303 | queue_work(ps->metadata_wq, &req.work); | ||
304 | - flush_work(&req.work); | ||
305 | + flush_workqueue(ps->metadata_wq); | ||
306 | |||
307 | return req.result; | ||
308 | } | ||
309 | diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c | ||
310 | index ff62ddc..448050c 100644 | ||
311 | --- a/drivers/md/dm-snap.c | ||
312 | +++ b/drivers/md/dm-snap.c | ||
313 | @@ -721,17 +721,16 @@ static int calc_max_buckets(void) | ||
314 | */ | ||
315 | static int init_hash_tables(struct dm_snapshot *s) | ||
316 | { | ||
317 | - sector_t hash_size, cow_dev_size, origin_dev_size, max_buckets; | ||
318 | + sector_t hash_size, cow_dev_size, max_buckets; | ||
319 | |||
320 | /* | ||
321 | * Calculate based on the size of the original volume or | ||
322 | * the COW volume... | ||
323 | */ | ||
324 | cow_dev_size = get_dev_size(s->cow->bdev); | ||
325 | - origin_dev_size = get_dev_size(s->origin->bdev); | ||
326 | max_buckets = calc_max_buckets(); | ||
327 | |||
328 | - hash_size = min(origin_dev_size, cow_dev_size) >> s->store->chunk_shift; | ||
329 | + hash_size = cow_dev_size >> s->store->chunk_shift; | ||
330 | hash_size = min(hash_size, max_buckets); | ||
331 | |||
332 | if (hash_size < 64) | ||
333 | diff --git a/drivers/staging/vt6656/main_usb.c b/drivers/staging/vt6656/main_usb.c | ||
334 | index 628545d..1f34a34 100644 | ||
335 | --- a/drivers/staging/vt6656/main_usb.c | ||
336 | +++ b/drivers/staging/vt6656/main_usb.c | ||
337 | @@ -1220,6 +1220,8 @@ device_release_WPADEV(pDevice); | ||
338 | memset(pMgmt->abyCurrBSSID, 0, 6); | ||
339 | pMgmt->eCurrState = WMAC_STATE_IDLE; | ||
340 | |||
341 | + pDevice->flags &= ~DEVICE_FLAGS_OPENED; | ||
342 | + | ||
343 | device_free_tx_bufs(pDevice); | ||
344 | device_free_rx_bufs(pDevice); | ||
345 | device_free_int_bufs(pDevice); | ||
346 | @@ -1231,7 +1233,6 @@ device_release_WPADEV(pDevice); | ||
347 | usb_free_urb(pDevice->pInterruptURB); | ||
348 | |||
349 | BSSvClearNodeDBTable(pDevice, 0); | ||
350 | - pDevice->flags &=(~DEVICE_FLAGS_OPENED); | ||
351 | |||
352 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n"); | ||
353 | |||
354 | diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c | ||
355 | index 336b82d..371fe69 100644 | ||
356 | --- a/drivers/usb/core/devio.c | ||
357 | +++ b/drivers/usb/core/devio.c | ||
358 | @@ -684,6 +684,22 @@ static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype, | ||
359 | if ((index & ~USB_DIR_IN) == 0) | ||
360 | return 0; | ||
361 | ret = findintfep(ps->dev, index); | ||
362 | + if (ret < 0) { | ||
363 | + /* | ||
364 | + * Some not fully compliant Win apps seem to get | ||
365 | + * index wrong and have the endpoint number here | ||
366 | + * rather than the endpoint address (with the | ||
367 | + * correct direction). Win does let this through, | ||
368 | + * so we'll not reject it here but leave it to | ||
369 | + * the device to not break KVM. But we warn. | ||
370 | + */ | ||
371 | + ret = findintfep(ps->dev, index ^ 0x80); | ||
372 | + if (ret >= 0) | ||
373 | + dev_info(&ps->dev->dev, | ||
374 | + "%s: process %i (%s) requesting ep %02x but needs %02x\n", | ||
375 | + __func__, task_pid_nr(current), | ||
376 | + current->comm, index, index ^ 0x80); | ||
377 | + } | ||
378 | if (ret >= 0) | ||
379 | ret = checkintf(ps, ret); | ||
380 | break; | ||
381 | diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c | ||
382 | index 8331893..e0478b7 100644 | ||
383 | --- a/drivers/usb/host/xhci-hub.c | ||
384 | +++ b/drivers/usb/host/xhci-hub.c | ||
385 | @@ -287,7 +287,7 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend) | ||
386 | if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue) | ||
387 | xhci_queue_stop_endpoint(xhci, slot_id, i, suspend); | ||
388 | } | ||
389 | - cmd->command_trb = xhci->cmd_ring->enqueue; | ||
390 | + cmd->command_trb = xhci_find_next_enqueue(xhci->cmd_ring); | ||
391 | list_add_tail(&cmd->cmd_list, &virt_dev->cmd_list); | ||
392 | xhci_queue_stop_endpoint(xhci, slot_id, 0, suspend); | ||
393 | xhci_ring_cmd_db(xhci); | ||
394 | diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c | ||
395 | index 1770ed5..87ee28e 100644 | ||
396 | --- a/drivers/usb/host/xhci-ring.c | ||
397 | +++ b/drivers/usb/host/xhci-ring.c | ||
398 | @@ -122,6 +122,16 @@ static int enqueue_is_link_trb(struct xhci_ring *ring) | ||
399 | return TRB_TYPE_LINK_LE32(link->control); | ||
400 | } | ||
401 | |||
402 | +union xhci_trb *xhci_find_next_enqueue(struct xhci_ring *ring) | ||
403 | +{ | ||
404 | + /* Enqueue pointer can be left pointing to the link TRB, | ||
405 | + * we must handle that | ||
406 | + */ | ||
407 | + if (TRB_TYPE_LINK_LE32(ring->enqueue->link.control)) | ||
408 | + return ring->enq_seg->next->trbs; | ||
409 | + return ring->enqueue; | ||
410 | +} | ||
411 | + | ||
412 | /* Updates trb to point to the next TRB in the ring, and updates seg if the next | ||
413 | * TRB is in a new segment. This does not skip over link TRBs, and it does not | ||
414 | * effect the ring dequeue or enqueue pointers. | ||
415 | @@ -847,8 +857,12 @@ remove_finished_td: | ||
416 | /* Otherwise ring the doorbell(s) to restart queued transfers */ | ||
417 | ring_doorbell_for_active_rings(xhci, slot_id, ep_index); | ||
418 | } | ||
419 | - ep->stopped_td = NULL; | ||
420 | - ep->stopped_trb = NULL; | ||
421 | + | ||
422 | + /* Clear stopped_td and stopped_trb if endpoint is not halted */ | ||
423 | + if (!(ep->ep_state & EP_HALTED)) { | ||
424 | + ep->stopped_td = NULL; | ||
425 | + ep->stopped_trb = NULL; | ||
426 | + } | ||
427 | |||
428 | /* | ||
429 | * Drop the lock and complete the URBs in the cancelled TD list. | ||
430 | @@ -1390,6 +1404,12 @@ static void handle_cmd_completion(struct xhci_hcd *xhci, | ||
431 | inc_deq(xhci, xhci->cmd_ring); | ||
432 | return; | ||
433 | } | ||
434 | + /* There is no command to handle if we get a stop event when the | ||
435 | + * command ring is empty, event->cmd_trb points to the next | ||
436 | + * unset command | ||
437 | + */ | ||
438 | + if (xhci->cmd_ring->dequeue == xhci->cmd_ring->enqueue) | ||
439 | + return; | ||
440 | } | ||
441 | |||
442 | switch (le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3]) | ||
443 | diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c | ||
444 | index 1504946..c8ea954 100644 | ||
445 | --- a/drivers/usb/host/xhci.c | ||
446 | +++ b/drivers/usb/host/xhci.c | ||
447 | @@ -2582,15 +2582,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci, | ||
448 | if (command) { | ||
449 | cmd_completion = command->completion; | ||
450 | cmd_status = &command->status; | ||
451 | - command->command_trb = xhci->cmd_ring->enqueue; | ||
452 | - | ||
453 | - /* Enqueue pointer can be left pointing to the link TRB, | ||
454 | - * we must handle that | ||
455 | - */ | ||
456 | - if (TRB_TYPE_LINK_LE32(command->command_trb->link.control)) | ||
457 | - command->command_trb = | ||
458 | - xhci->cmd_ring->enq_seg->next->trbs; | ||
459 | - | ||
460 | + command->command_trb = xhci_find_next_enqueue(xhci->cmd_ring); | ||
461 | list_add_tail(&command->cmd_list, &virt_dev->cmd_list); | ||
462 | } else { | ||
463 | cmd_completion = &virt_dev->cmd_completion; | ||
464 | @@ -2598,7 +2590,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci, | ||
465 | } | ||
466 | init_completion(cmd_completion); | ||
467 | |||
468 | - cmd_trb = xhci->cmd_ring->dequeue; | ||
469 | + cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring); | ||
470 | if (!ctx_change) | ||
471 | ret = xhci_queue_configure_endpoint(xhci, in_ctx->dma, | ||
472 | udev->slot_id, must_succeed); | ||
473 | @@ -3383,14 +3375,7 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev) | ||
474 | |||
475 | /* Attempt to submit the Reset Device command to the command ring */ | ||
476 | spin_lock_irqsave(&xhci->lock, flags); | ||
477 | - reset_device_cmd->command_trb = xhci->cmd_ring->enqueue; | ||
478 | - | ||
479 | - /* Enqueue pointer can be left pointing to the link TRB, | ||
480 | - * we must handle that | ||
481 | - */ | ||
482 | - if (TRB_TYPE_LINK_LE32(reset_device_cmd->command_trb->link.control)) | ||
483 | - reset_device_cmd->command_trb = | ||
484 | - xhci->cmd_ring->enq_seg->next->trbs; | ||
485 | + reset_device_cmd->command_trb = xhci_find_next_enqueue(xhci->cmd_ring); | ||
486 | |||
487 | list_add_tail(&reset_device_cmd->cmd_list, &virt_dev->cmd_list); | ||
488 | ret = xhci_queue_reset_device(xhci, slot_id); | ||
489 | @@ -3594,7 +3579,7 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev) | ||
490 | union xhci_trb *cmd_trb; | ||
491 | |||
492 | spin_lock_irqsave(&xhci->lock, flags); | ||
493 | - cmd_trb = xhci->cmd_ring->dequeue; | ||
494 | + cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring); | ||
495 | ret = xhci_queue_slot_control(xhci, TRB_ENABLE_SLOT, 0); | ||
496 | if (ret) { | ||
497 | spin_unlock_irqrestore(&xhci->lock, flags); | ||
498 | @@ -3721,7 +3706,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev) | ||
499 | xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2); | ||
500 | |||
501 | spin_lock_irqsave(&xhci->lock, flags); | ||
502 | - cmd_trb = xhci->cmd_ring->dequeue; | ||
503 | + cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring); | ||
504 | ret = xhci_queue_address_device(xhci, virt_dev->in_ctx->dma, | ||
505 | udev->slot_id); | ||
506 | if (ret) { | ||
507 | diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h | ||
508 | index a54a408..71dd138 100644 | ||
509 | --- a/drivers/usb/host/xhci.h | ||
510 | +++ b/drivers/usb/host/xhci.h | ||
511 | @@ -1811,6 +1811,7 @@ int xhci_cancel_cmd(struct xhci_hcd *xhci, struct xhci_command *command, | ||
512 | union xhci_trb *cmd_trb); | ||
513 | void xhci_ring_ep_doorbell(struct xhci_hcd *xhci, unsigned int slot_id, | ||
514 | unsigned int ep_index, unsigned int stream_id); | ||
515 | +union xhci_trb *xhci_find_next_enqueue(struct xhci_ring *ring); | ||
516 | |||
517 | /* xHCI roothub code */ | ||
518 | void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array, | ||
519 | diff --git a/mm/oom_kill.c b/mm/oom_kill.c | ||
520 | index 46bf2ed5..597ecac 100644 | ||
521 | --- a/mm/oom_kill.c | ||
522 | +++ b/mm/oom_kill.c | ||
523 | @@ -562,11 +562,11 @@ void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask, | ||
524 | struct task_struct *p; | ||
525 | |||
526 | /* | ||
527 | - * If current has a pending SIGKILL, then automatically select it. The | ||
528 | - * goal is to allow it to allocate so that it may quickly exit and free | ||
529 | - * its memory. | ||
530 | + * If current has a pending SIGKILL or is exiting, then automatically | ||
531 | + * select it. The goal is to allow it to allocate so that it may | ||
532 | + * quickly exit and free its memory. | ||
533 | */ | ||
534 | - if (fatal_signal_pending(current)) { | ||
535 | + if (fatal_signal_pending(current) || current->flags & PF_EXITING) { | ||
536 | set_thread_flag(TIF_MEMDIE); | ||
537 | return; | ||
538 | } | ||
539 | diff --git a/sound/core/compress_offload.c b/sound/core/compress_offload.c | ||
540 | index 84717ce..7895983 100644 | ||
541 | --- a/sound/core/compress_offload.c | ||
542 | +++ b/sound/core/compress_offload.c | ||
543 | @@ -663,7 +663,8 @@ static int snd_compress_dev_disconnect(struct snd_device *device) | ||
544 | struct snd_compr *compr; | ||
545 | |||
546 | compr = device->device_data; | ||
547 | - snd_unregister_device(compr->direction, compr->card, compr->device); | ||
548 | + snd_unregister_device(SNDRV_DEVICE_TYPE_COMPRESS, compr->card, | ||
549 | + compr->device); | ||
550 | return 0; | ||
551 | } | ||
552 |