Magellan Linux

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

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

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 2306 - (hide annotations) (download)
    Mon Oct 14 07:15:35 2013 UTC (10 years, 8 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