Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-lts/patches-3.4/0164-3.4.65-all-fixes.patch

    Contents of /trunk/kernel-lts/patches-3.4/0164-3.4.65-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 2306 - (show annotations) (download)
    Mon Oct 14 07:15:35 2013 UTC (10 years, 6 months ago) by niro
    File size: 19055 byte(s) 
    -linux-3.4.65
    1 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