diff options
Diffstat (limited to '3.2.60/1058_linux-3.2.59.patch')
| -rw-r--r-- | 3.2.60/1058_linux-3.2.59.patch | 1213 |
1 files changed, 1213 insertions, 0 deletions
diff --git a/3.2.60/1058_linux-3.2.59.patch b/3.2.60/1058_linux-3.2.59.patch new file mode 100644 index 0000000..cd59fe9 --- /dev/null +++ b/3.2.60/1058_linux-3.2.59.patch @@ -0,0 +1,1213 @@ +diff --git a/Makefile b/Makefile +index d59b394..1be3414 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 3 + PATCHLEVEL = 2 +-SUBLEVEL = 58 ++SUBLEVEL = 59 + EXTRAVERSION = + NAME = Saber-toothed Squirrel + +diff --git a/arch/arm/include/asm/div64.h b/arch/arm/include/asm/div64.h +index d3f0a9e..506e33b 100644 +--- a/arch/arm/include/asm/div64.h ++++ b/arch/arm/include/asm/div64.h +@@ -156,7 +156,7 @@ + /* Select the best insn combination to perform the */ \ + /* actual __m * __n / (__p << 64) operation. */ \ + if (!__c) { \ +- asm ( "umull %Q0, %R0, %1, %Q2\n\t" \ ++ asm ( "umull %Q0, %R0, %Q1, %Q2\n\t" \ + "mov %Q0, #0" \ + : "=&r" (__res) \ + : "r" (__m), "r" (__n) \ +diff --git a/arch/parisc/kernel/syscall_table.S b/arch/parisc/kernel/syscall_table.S +index 3735abd..4014d90 100644 +--- a/arch/parisc/kernel/syscall_table.S ++++ b/arch/parisc/kernel/syscall_table.S +@@ -395,7 +395,7 @@ + ENTRY_COMP(vmsplice) + ENTRY_COMP(move_pages) /* 295 */ + ENTRY_SAME(getcpu) +- ENTRY_SAME(epoll_pwait) ++ ENTRY_COMP(epoll_pwait) + ENTRY_COMP(statfs64) + ENTRY_COMP(fstatfs64) + ENTRY_COMP(kexec_load) /* 300 */ +diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c +index b3f0f5a..2b662725 100644 +--- a/drivers/ata/libata-core.c ++++ b/drivers/ata/libata-core.c +@@ -4718,21 +4718,26 @@ void swap_buf_le16(u16 *buf, unsigned int buf_words) + static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap) + { + struct ata_queued_cmd *qc = NULL; +- unsigned int i; ++ unsigned int i, tag; + + /* no command while frozen */ + if (unlikely(ap->pflags & ATA_PFLAG_FROZEN)) + return NULL; + +- /* the last tag is reserved for internal command. */ +- for (i = 0; i < ATA_MAX_QUEUE - 1; i++) +- if (!test_and_set_bit(i, &ap->qc_allocated)) { +- qc = __ata_qc_from_tag(ap, i); ++ for (i = 0; i < ATA_MAX_QUEUE; i++) { ++ tag = (i + ap->last_tag + 1) % ATA_MAX_QUEUE; ++ ++ /* the last tag is reserved for internal command. */ ++ if (tag == ATA_TAG_INTERNAL) ++ continue; ++ ++ if (!test_and_set_bit(tag, &ap->qc_allocated)) { ++ qc = __ata_qc_from_tag(ap, tag); ++ qc->tag = tag; ++ ap->last_tag = tag; + break; + } +- +- if (qc) +- qc->tag = i; ++ } + + return qc; + } +diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c +index 7a90d4a..6d0f3e1 100644 +--- a/drivers/block/floppy.c ++++ b/drivers/block/floppy.c +@@ -3060,7 +3060,10 @@ static int raw_cmd_copyout(int cmd, void __user *param, + int ret; + + while (ptr) { +- ret = copy_to_user(param, ptr, sizeof(*ptr)); ++ struct floppy_raw_cmd cmd = *ptr; ++ cmd.next = NULL; ++ cmd.kernel_data = NULL; ++ ret = copy_to_user(param, &cmd, sizeof(cmd)); + if (ret) + return -EFAULT; + param += sizeof(struct floppy_raw_cmd); +@@ -3114,10 +3117,11 @@ loop: + return -ENOMEM; + *rcmd = ptr; + ret = copy_from_user(ptr, param, sizeof(*ptr)); +- if (ret) +- return -EFAULT; + ptr->next = NULL; + ptr->buffer_length = 0; ++ ptr->kernel_data = NULL; ++ if (ret) ++ return -EFAULT; + param += sizeof(struct floppy_raw_cmd); + if (ptr->cmd_count > 33) + /* the command may now also take up the space +@@ -3133,7 +3137,6 @@ loop: + for (i = 0; i < 16; i++) + ptr->reply[i] = 0; + ptr->resultcode = 0; +- ptr->kernel_data = NULL; + + if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) { + if (ptr->length <= 0) +diff --git a/drivers/firmware/dmi_scan.c b/drivers/firmware/dmi_scan.c +index 4cd392d..2861ef4 100644 +--- a/drivers/firmware/dmi_scan.c ++++ b/drivers/firmware/dmi_scan.c +@@ -534,9 +534,15 @@ static bool dmi_matches(const struct dmi_system_id *dmi) + int s = dmi->matches[i].slot; + if (s == DMI_NONE) + break; +- if (dmi_ident[s] +- && strstr(dmi_ident[s], dmi->matches[i].substr)) +- continue; ++ if (dmi_ident[s]) { ++ if (!dmi->matches[i].exact_match && ++ strstr(dmi_ident[s], dmi->matches[i].substr)) ++ continue; ++ else if (dmi->matches[i].exact_match && ++ !strcmp(dmi_ident[s], dmi->matches[i].substr)) ++ continue; ++ } ++ + /* No match */ + return false; + } +diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c +index bc35070..886c191 100644 +--- a/drivers/input/mouse/synaptics.c ++++ b/drivers/input/mouse/synaptics.c +@@ -1394,6 +1394,14 @@ static const struct dmi_system_id min_max_dmi_table[] __initconst = { + .driver_data = (int []){1232, 5710, 1156, 4696}, + }, + { ++ /* Lenovo ThinkPad T431s */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), ++ DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T431"), ++ }, ++ .driver_data = (int []){1024, 5112, 2024, 4832}, ++ }, ++ { + /* Lenovo ThinkPad T440s */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), +@@ -1402,6 +1410,14 @@ static const struct dmi_system_id min_max_dmi_table[] __initconst = { + .driver_data = (int []){1024, 5112, 2024, 4832}, + }, + { ++ /* Lenovo ThinkPad L440 */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), ++ DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad L440"), ++ }, ++ .driver_data = (int []){1024, 5112, 2024, 4832}, ++ }, ++ { + /* Lenovo ThinkPad T540p */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), +@@ -1409,6 +1425,32 @@ static const struct dmi_system_id min_max_dmi_table[] __initconst = { + }, + .driver_data = (int []){1024, 5056, 2058, 4832}, + }, ++ { ++ /* Lenovo ThinkPad L540 */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), ++ DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad L540"), ++ }, ++ .driver_data = (int []){1024, 5112, 2024, 4832}, ++ }, ++ { ++ /* Lenovo Yoga S1 */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), ++ DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, ++ "ThinkPad S1 Yoga"), ++ }, ++ .driver_data = (int []){1232, 5710, 1156, 4696}, ++ }, ++ { ++ /* Lenovo ThinkPad X1 Carbon Haswell (3rd generation) */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), ++ DMI_MATCH(DMI_PRODUCT_VERSION, ++ "ThinkPad X1 Carbon 2nd"), ++ }, ++ .driver_data = (int []){1024, 5112, 2024, 4832}, ++ }, + #endif + { } + }; +diff --git a/drivers/net/ethernet/mellanox/mlx4/en_cq.c b/drivers/net/ethernet/mellanox/mlx4/en_cq.c +index 5829e0b..ba7c861 100644 +--- a/drivers/net/ethernet/mellanox/mlx4/en_cq.c ++++ b/drivers/net/ethernet/mellanox/mlx4/en_cq.c +@@ -58,7 +58,6 @@ int mlx4_en_create_cq(struct mlx4_en_priv *priv, + + cq->ring = ring; + cq->is_tx = mode; +- spin_lock_init(&cq->lock); + + err = mlx4_alloc_hwq_res(mdev->dev, &cq->wqres, + cq->buf_size, 2 * PAGE_SIZE); +diff --git a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c +index 78d776b..308349a 100644 +--- a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c ++++ b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c +@@ -355,15 +355,11 @@ static void mlx4_en_netpoll(struct net_device *dev) + { + struct mlx4_en_priv *priv = netdev_priv(dev); + struct mlx4_en_cq *cq; +- unsigned long flags; + int i; + + for (i = 0; i < priv->rx_ring_num; i++) { + cq = &priv->rx_cq[i]; +- spin_lock_irqsave(&cq->lock, flags); +- napi_synchronize(&cq->napi); +- mlx4_en_process_rx_cq(dev, cq, 0); +- spin_unlock_irqrestore(&cq->lock, flags); ++ napi_schedule(&cq->napi); + } + } + #endif +diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h +index 207b5ad..4920558 100644 +--- a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h ++++ b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h +@@ -300,7 +300,6 @@ struct mlx4_en_cq { + struct mlx4_cq mcq; + struct mlx4_hwq_resources wqres; + int ring; +- spinlock_t lock; + struct net_device *dev; + struct napi_struct napi; + /* Per-core Tx cq processing support */ +diff --git a/drivers/net/wireless/rtlwifi/rtl8192c/dm_common.c b/drivers/net/wireless/rtlwifi/rtl8192c/dm_common.c +index a004ad7..ba7ef2f 100644 +--- a/drivers/net/wireless/rtlwifi/rtl8192c/dm_common.c ++++ b/drivers/net/wireless/rtlwifi/rtl8192c/dm_common.c +@@ -1228,11 +1228,14 @@ static void rtl92c_dm_refresh_rate_adaptive_mask(struct ieee80211_hw *hw) + if (rtlhal->interface == INTF_PCI) { + rcu_read_lock(); + sta = ieee80211_find_sta(mac->vif, mac->bssid); ++ if (!sta) ++ goto out_unlock; + } + rtlpriv->cfg->ops->update_rate_tbl(hw, sta, + p_ra->ratr_state); + + p_ra->pre_ratr_state = p_ra->ratr_state; ++ out_unlock: + if (rtlhal->interface == INTF_PCI) + rcu_read_unlock(); + } +diff --git a/drivers/staging/rtl8712/rtl871x_recv.c b/drivers/staging/rtl8712/rtl871x_recv.c +index 7069f06..4cc68d1 100644 +--- a/drivers/staging/rtl8712/rtl871x_recv.c ++++ b/drivers/staging/rtl8712/rtl871x_recv.c +@@ -254,7 +254,7 @@ union recv_frame *r8712_portctrl(struct _adapter *adapter, + struct sta_info *psta; + struct sta_priv *pstapriv; + union recv_frame *prtnframe; +- u16 ether_type = 0; ++ u16 ether_type; + + pstapriv = &adapter->stapriv; + ptr = get_recvframe_data(precv_frame); +@@ -263,15 +263,14 @@ union recv_frame *r8712_portctrl(struct _adapter *adapter, + psta = r8712_get_stainfo(pstapriv, psta_addr); + auth_alg = adapter->securitypriv.AuthAlgrthm; + if (auth_alg == 2) { ++ /* get ether_type */ ++ ptr = ptr + pfhdr->attrib.hdrlen + LLC_HEADER_SIZE; ++ memcpy(ðer_type, ptr, 2); ++ ether_type = ntohs((unsigned short)ether_type); ++ + if ((psta != NULL) && (psta->ieee8021x_blocked)) { + /* blocked + * only accept EAPOL frame */ +- prtnframe = precv_frame; +- /*get ether_type */ +- ptr = ptr + pfhdr->attrib.hdrlen + +- pfhdr->attrib.iv_len + LLC_HEADER_SIZE; +- memcpy(ðer_type, ptr, 2); +- ether_type = ntohs((unsigned short)ether_type); + if (ether_type == 0x888e) + prtnframe = precv_frame; + else { +diff --git a/drivers/tty/n_tty.c b/drivers/tty/n_tty.c +index 0f8a785..bac83d8 100644 +--- a/drivers/tty/n_tty.c ++++ b/drivers/tty/n_tty.c +@@ -1997,7 +1997,9 @@ static ssize_t n_tty_write(struct tty_struct *tty, struct file *file, + tty->ops->flush_chars(tty); + } else { + while (nr > 0) { ++ mutex_lock(&tty->output_lock); + c = tty->ops->write(tty, b, nr); ++ mutex_unlock(&tty->output_lock); + if (c < 0) { + retval = c; + goto break_out; +diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c +index 636ee9e..320db2a 100644 +--- a/drivers/usb/class/cdc-acm.c ++++ b/drivers/usb/class/cdc-acm.c +@@ -1493,13 +1493,27 @@ static const struct usb_device_id acm_ids[] = { + }, + /* Motorola H24 HSPA module: */ + { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */ +- { USB_DEVICE(0x22b8, 0x2d92) }, /* modem + diagnostics */ +- { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port */ +- { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics */ +- { USB_DEVICE(0x22b8, 0x2d96) }, /* modem + NMEA */ +- { USB_DEVICE(0x22b8, 0x2d97) }, /* modem + diagnostics + NMEA */ +- { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port + NMEA */ +- { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */ ++ { USB_DEVICE(0x22b8, 0x2d92), /* modem + diagnostics */ ++ .driver_info = NO_UNION_NORMAL, /* handle only modem interface */ ++ }, ++ { USB_DEVICE(0x22b8, 0x2d93), /* modem + AT port */ ++ .driver_info = NO_UNION_NORMAL, /* handle only modem interface */ ++ }, ++ { USB_DEVICE(0x22b8, 0x2d95), /* modem + AT port + diagnostics */ ++ .driver_info = NO_UNION_NORMAL, /* handle only modem interface */ ++ }, ++ { USB_DEVICE(0x22b8, 0x2d96), /* modem + NMEA */ ++ .driver_info = NO_UNION_NORMAL, /* handle only modem interface */ ++ }, ++ { USB_DEVICE(0x22b8, 0x2d97), /* modem + diagnostics + NMEA */ ++ .driver_info = NO_UNION_NORMAL, /* handle only modem interface */ ++ }, ++ { USB_DEVICE(0x22b8, 0x2d99), /* modem + AT port + NMEA */ ++ .driver_info = NO_UNION_NORMAL, /* handle only modem interface */ ++ }, ++ { USB_DEVICE(0x22b8, 0x2d9a), /* modem + AT port + diagnostics + NMEA */ ++ .driver_info = NO_UNION_NORMAL, /* handle only modem interface */ ++ }, + + { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */ + .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on +diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c +index 2b4f42b..1886544 100644 +--- a/drivers/usb/host/xhci-ring.c ++++ b/drivers/usb/host/xhci-ring.c +@@ -570,10 +570,11 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci, + struct xhci_dequeue_state *state) + { + struct xhci_virt_device *dev = xhci->devs[slot_id]; ++ struct xhci_virt_ep *ep = &dev->eps[ep_index]; + struct xhci_ring *ep_ring; + struct xhci_generic_trb *trb; +- struct xhci_ep_ctx *ep_ctx; + dma_addr_t addr; ++ u64 hw_dequeue; + + ep_ring = xhci_triad_to_transfer_ring(xhci, slot_id, + ep_index, stream_id); +@@ -583,52 +584,62 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci, + stream_id); + return; + } +- state->new_cycle_state = 0; +- xhci_dbg(xhci, "Finding segment containing stopped TRB.\n"); +- state->new_deq_seg = find_trb_seg(cur_td->start_seg, +- dev->eps[ep_index].stopped_trb, +- &state->new_cycle_state); +- if (!state->new_deq_seg) { +- WARN_ON(1); +- return; +- } + + /* Dig out the cycle state saved by the xHC during the stop ep cmd */ + xhci_dbg(xhci, "Finding endpoint context\n"); +- ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index); +- state->new_cycle_state = 0x1 & le64_to_cpu(ep_ctx->deq); ++ /* 4.6.9 the css flag is written to the stream context for streams */ ++ if (ep->ep_state & EP_HAS_STREAMS) { ++ struct xhci_stream_ctx *ctx = ++ &ep->stream_info->stream_ctx_array[stream_id]; ++ hw_dequeue = le64_to_cpu(ctx->stream_ring); ++ } else { ++ struct xhci_ep_ctx *ep_ctx ++ = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index); ++ hw_dequeue = le64_to_cpu(ep_ctx->deq); ++ } ++ ++ /* Find virtual address and segment of hardware dequeue pointer */ ++ state->new_deq_seg = ep_ring->deq_seg; ++ state->new_deq_ptr = ep_ring->dequeue; ++ while (xhci_trb_virt_to_dma(state->new_deq_seg, state->new_deq_ptr) ++ != (dma_addr_t)(hw_dequeue & ~0xf)) { ++ next_trb(xhci, ep_ring, &state->new_deq_seg, ++ &state->new_deq_ptr); ++ if (state->new_deq_ptr == ep_ring->dequeue) { ++ WARN_ON(1); ++ return; ++ } ++ } ++ /* ++ * Find cycle state for last_trb, starting at old cycle state of ++ * hw_dequeue. If there is only one segment ring, find_trb_seg() will ++ * return immediately and cannot toggle the cycle state if this search ++ * wraps around, so add one more toggle manually in that case. ++ */ ++ state->new_cycle_state = hw_dequeue & 0x1; ++ if (ep_ring->first_seg == ep_ring->first_seg->next && ++ cur_td->last_trb < state->new_deq_ptr) ++ state->new_cycle_state ^= 0x1; + + state->new_deq_ptr = cur_td->last_trb; + xhci_dbg(xhci, "Finding segment containing last TRB in TD.\n"); + state->new_deq_seg = find_trb_seg(state->new_deq_seg, +- state->new_deq_ptr, +- &state->new_cycle_state); ++ state->new_deq_ptr, &state->new_cycle_state); + if (!state->new_deq_seg) { + WARN_ON(1); + return; + } + ++ /* Increment to find next TRB after last_trb. Cycle if appropriate. */ + trb = &state->new_deq_ptr->generic; + if (TRB_TYPE_LINK_LE32(trb->field[3]) && + (trb->field[3] & cpu_to_le32(LINK_TOGGLE))) + state->new_cycle_state ^= 0x1; + next_trb(xhci, ep_ring, &state->new_deq_seg, &state->new_deq_ptr); + +- /* +- * If there is only one segment in a ring, find_trb_seg()'s while loop +- * will not run, and it will return before it has a chance to see if it +- * needs to toggle the cycle bit. It can't tell if the stalled transfer +- * ended just before the link TRB on a one-segment ring, or if the TD +- * wrapped around the top of the ring, because it doesn't have the TD in +- * question. Look for the one-segment case where stalled TRB's address +- * is greater than the new dequeue pointer address. +- */ +- if (ep_ring->first_seg == ep_ring->first_seg->next && +- state->new_deq_ptr < dev->eps[ep_index].stopped_trb) +- state->new_cycle_state ^= 0x1; ++ /* Don't update the ring cycle state for the producer (us). */ + xhci_dbg(xhci, "Cycle state = 0x%x\n", state->new_cycle_state); + +- /* Don't update the ring cycle state for the producer (us). */ + xhci_dbg(xhci, "New dequeue segment = %p (virtual)\n", + state->new_deq_seg); + addr = xhci_trb_virt_to_dma(state->new_deq_seg, state->new_deq_ptr); +@@ -813,7 +824,6 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci, + if (list_empty(&ep->cancelled_td_list)) { + xhci_stop_watchdog_timer_in_irq(xhci, ep); + ep->stopped_td = NULL; +- ep->stopped_trb = NULL; + ring_doorbell_for_active_rings(xhci, slot_id, ep_index); + return; + } +@@ -880,11 +890,9 @@ remove_finished_td: + ring_doorbell_for_active_rings(xhci, slot_id, ep_index); + } + +- /* Clear stopped_td and stopped_trb if endpoint is not halted */ +- if (!(ep->ep_state & EP_HALTED)) { ++ /* Clear stopped_td if endpoint is not halted */ ++ if (!(ep->ep_state & EP_HALTED)) + ep->stopped_td = NULL; +- ep->stopped_trb = NULL; +- } + + /* + * Drop the lock and complete the URBs in the cancelled TD list. +@@ -1744,14 +1752,12 @@ static void xhci_cleanup_halted_endpoint(struct xhci_hcd *xhci, + struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index]; + ep->ep_state |= EP_HALTED; + ep->stopped_td = td; +- ep->stopped_trb = event_trb; + ep->stopped_stream = stream_id; + + xhci_queue_reset_ep(xhci, slot_id, ep_index); + xhci_cleanup_stalled_ring(xhci, td->urb->dev, ep_index); + + ep->stopped_td = NULL; +- ep->stopped_trb = NULL; + ep->stopped_stream = 0; + + xhci_ring_cmd_db(xhci); +@@ -1833,7 +1839,6 @@ static int finish_td(struct xhci_hcd *xhci, struct xhci_td *td, + * the ring dequeue pointer or take this TD off any lists yet. + */ + ep->stopped_td = td; +- ep->stopped_trb = event_trb; + return 0; + } else { + if (trb_comp_code == COMP_STALL) { +@@ -1845,7 +1850,6 @@ static int finish_td(struct xhci_hcd *xhci, struct xhci_td *td, + * USB class driver clear the stall later. + */ + ep->stopped_td = td; +- ep->stopped_trb = event_trb; + ep->stopped_stream = ep_ring->stream_id; + } else if (xhci_requires_manual_halt_cleanup(xhci, + ep_ctx, trb_comp_code)) { +diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c +index 03c35da..b2eac8d 100644 +--- a/drivers/usb/host/xhci.c ++++ b/drivers/usb/host/xhci.c +@@ -378,16 +378,16 @@ static int xhci_try_enable_msi(struct usb_hcd *hcd) + + #else + +-static int xhci_try_enable_msi(struct usb_hcd *hcd) ++static inline int xhci_try_enable_msi(struct usb_hcd *hcd) + { + return 0; + } + +-static void xhci_cleanup_msix(struct xhci_hcd *xhci) ++static inline void xhci_cleanup_msix(struct xhci_hcd *xhci) + { + } + +-static void xhci_msix_sync_irqs(struct xhci_hcd *xhci) ++static inline void xhci_msix_sync_irqs(struct xhci_hcd *xhci) + { + } + +@@ -2884,7 +2884,6 @@ void xhci_endpoint_reset(struct usb_hcd *hcd, + xhci_ring_cmd_db(xhci); + } + virt_ep->stopped_td = NULL; +- virt_ep->stopped_trb = NULL; + virt_ep->stopped_stream = 0; + spin_unlock_irqrestore(&xhci->lock, flags); + +diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h +index cf4fd24..1bc91c8 100644 +--- a/drivers/usb/host/xhci.h ++++ b/drivers/usb/host/xhci.h +@@ -835,8 +835,6 @@ struct xhci_virt_ep { + #define EP_GETTING_NO_STREAMS (1 << 5) + /* ---- Related to URB cancellation ---- */ + struct list_head cancelled_td_list; +- /* The TRB that was last reported in a stopped endpoint ring */ +- union xhci_trb *stopped_trb; + struct xhci_td *stopped_td; + unsigned int stopped_stream; + /* Watchdog timer for stop endpoint command to cancel URBs */ +diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c +index c408ff7..01fd64a 100644 +--- a/drivers/usb/serial/cp210x.c ++++ b/drivers/usb/serial/cp210x.c +@@ -110,6 +110,7 @@ static const struct usb_device_id id_table[] = { + { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */ + { USB_DEVICE(0x10C4, 0x822B) }, /* Modem EDGE(GSM) Comander 2 */ + { USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */ ++ { USB_DEVICE(0x10C4, 0x8281) }, /* Nanotec Plug & Drive */ + { USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */ + { USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */ + { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */ +diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c +index 5c97d9f..332f04d 100644 +--- a/drivers/usb/serial/ftdi_sio.c ++++ b/drivers/usb/serial/ftdi_sio.c +@@ -920,6 +920,39 @@ static struct usb_device_id id_table_combined [] = { + { USB_DEVICE(FTDI_VID, FTDI_Z3X_PID) }, + /* Cressi Devices */ + { USB_DEVICE(FTDI_VID, FTDI_CRESSI_PID) }, ++ /* Brainboxes Devices */ ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_001_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_012_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_023_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_034_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_101_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_1_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_2_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_3_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_4_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_5_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_6_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_7_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_8_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_257_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_1_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_2_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_3_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_4_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_313_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_324_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_346_1_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_346_2_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_357_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_606_1_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_606_2_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_606_3_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_701_1_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_701_2_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_1_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_2_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_3_PID) }, ++ { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_4_PID) }, + { }, /* Optional parameter entry */ + { } /* Terminating entry */ + }; +diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h +index 71fe2de..83a440f 100644 +--- a/drivers/usb/serial/ftdi_sio_ids.h ++++ b/drivers/usb/serial/ftdi_sio_ids.h +@@ -1326,3 +1326,40 @@ + * Manufacturer: Cressi + */ + #define FTDI_CRESSI_PID 0x87d0 ++ ++/* ++ * Brainboxes devices ++ */ ++#define BRAINBOXES_VID 0x05d1 ++#define BRAINBOXES_VX_001_PID 0x1001 /* VX-001 ExpressCard 1 Port RS232 */ ++#define BRAINBOXES_VX_012_PID 0x1002 /* VX-012 ExpressCard 2 Port RS232 */ ++#define BRAINBOXES_VX_023_PID 0x1003 /* VX-023 ExpressCard 1 Port RS422/485 */ ++#define BRAINBOXES_VX_034_PID 0x1004 /* VX-034 ExpressCard 2 Port RS422/485 */ ++#define BRAINBOXES_US_101_PID 0x1011 /* US-101 1xRS232 */ ++#define BRAINBOXES_US_324_PID 0x1013 /* US-324 1xRS422/485 1Mbaud */ ++#define BRAINBOXES_US_606_1_PID 0x2001 /* US-606 6 Port RS232 Serial Port 1 and 2 */ ++#define BRAINBOXES_US_606_2_PID 0x2002 /* US-606 6 Port RS232 Serial Port 3 and 4 */ ++#define BRAINBOXES_US_606_3_PID 0x2003 /* US-606 6 Port RS232 Serial Port 4 and 6 */ ++#define BRAINBOXES_US_701_1_PID 0x2011 /* US-701 4xRS232 1Mbaud Port 1 and 2 */ ++#define BRAINBOXES_US_701_2_PID 0x2012 /* US-701 4xRS422 1Mbaud Port 3 and 4 */ ++#define BRAINBOXES_US_279_1_PID 0x2021 /* US-279 8xRS422 1Mbaud Port 1 and 2 */ ++#define BRAINBOXES_US_279_2_PID 0x2022 /* US-279 8xRS422 1Mbaud Port 3 and 4 */ ++#define BRAINBOXES_US_279_3_PID 0x2023 /* US-279 8xRS422 1Mbaud Port 5 and 6 */ ++#define BRAINBOXES_US_279_4_PID 0x2024 /* US-279 8xRS422 1Mbaud Port 7 and 8 */ ++#define BRAINBOXES_US_346_1_PID 0x3011 /* US-346 4xRS422/485 1Mbaud Port 1 and 2 */ ++#define BRAINBOXES_US_346_2_PID 0x3012 /* US-346 4xRS422/485 1Mbaud Port 3 and 4 */ ++#define BRAINBOXES_US_257_PID 0x5001 /* US-257 2xRS232 1Mbaud */ ++#define BRAINBOXES_US_313_PID 0x6001 /* US-313 2xRS422/485 1Mbaud */ ++#define BRAINBOXES_US_357_PID 0x7001 /* US_357 1xRS232/422/485 */ ++#define BRAINBOXES_US_842_1_PID 0x8001 /* US-842 8xRS422/485 1Mbaud Port 1 and 2 */ ++#define BRAINBOXES_US_842_2_PID 0x8002 /* US-842 8xRS422/485 1Mbaud Port 3 and 4 */ ++#define BRAINBOXES_US_842_3_PID 0x8003 /* US-842 8xRS422/485 1Mbaud Port 5 and 6 */ ++#define BRAINBOXES_US_842_4_PID 0x8004 /* US-842 8xRS422/485 1Mbaud Port 7 and 8 */ ++#define BRAINBOXES_US_160_1_PID 0x9001 /* US-160 16xRS232 1Mbaud Port 1 and 2 */ ++#define BRAINBOXES_US_160_2_PID 0x9002 /* US-160 16xRS232 1Mbaud Port 3 and 4 */ ++#define BRAINBOXES_US_160_3_PID 0x9003 /* US-160 16xRS232 1Mbaud Port 5 and 6 */ ++#define BRAINBOXES_US_160_4_PID 0x9004 /* US-160 16xRS232 1Mbaud Port 7 and 8 */ ++#define BRAINBOXES_US_160_5_PID 0x9005 /* US-160 16xRS232 1Mbaud Port 9 and 10 */ ++#define BRAINBOXES_US_160_6_PID 0x9006 /* US-160 16xRS232 1Mbaud Port 11 and 12 */ ++#define BRAINBOXES_US_160_7_PID 0x9007 /* US-160 16xRS232 1Mbaud Port 13 and 14 */ ++#define BRAINBOXES_US_160_8_PID 0x9008 /* US-160 16xRS232 1Mbaud Port 15 and 16 */ +diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c +index f42119d..c575e0a 100644 +--- a/drivers/usb/serial/io_ti.c ++++ b/drivers/usb/serial/io_ti.c +@@ -36,6 +36,7 @@ + #include <linux/spinlock.h> + #include <linux/mutex.h> + #include <linux/serial.h> ++#include <linux/swab.h> + #include <linux/kfifo.h> + #include <linux/ioctl.h> + #include <linux/firmware.h> +@@ -306,7 +307,7 @@ static int read_download_mem(struct usb_device *dev, int start_address, + { + int status = 0; + __u8 read_length; +- __be16 be_start_address; ++ u16 be_start_address; + + dbg("%s - @ %x for %d", __func__, start_address, length); + +@@ -323,10 +324,14 @@ static int read_download_mem(struct usb_device *dev, int start_address, + dbg("%s - @ %x for %d", __func__, + start_address, read_length); + } +- be_start_address = cpu_to_be16(start_address); ++ /* ++ * NOTE: Must use swab as wIndex is sent in little-endian ++ * byte order regardless of host byte order. ++ */ ++ be_start_address = swab16((u16)start_address); + status = ti_vread_sync(dev, UMPC_MEMORY_READ, + (__u16)address_type, +- (__force __u16)be_start_address, ++ be_start_address, + buffer, read_length); + + if (status) { +@@ -426,7 +431,7 @@ static int write_i2c_mem(struct edgeport_serial *serial, + { + int status = 0; + int write_length; +- __be16 be_start_address; ++ u16 be_start_address; + + /* We can only send a maximum of 1 aligned byte page at a time */ + +@@ -442,11 +447,16 @@ static int write_i2c_mem(struct edgeport_serial *serial, + usb_serial_debug_data(debug, &serial->serial->dev->dev, + __func__, write_length, buffer); + +- /* Write first page */ +- be_start_address = cpu_to_be16(start_address); ++ /* ++ * Write first page. ++ * ++ * NOTE: Must use swab as wIndex is sent in little-endian byte order ++ * regardless of host byte order. ++ */ ++ be_start_address = swab16((u16)start_address); + status = ti_vsend_sync(serial->serial->dev, + UMPC_MEMORY_WRITE, (__u16)address_type, +- (__force __u16)be_start_address, ++ be_start_address, + buffer, write_length); + if (status) { + dbg("%s - ERROR %d", __func__, status); +@@ -470,11 +480,16 @@ static int write_i2c_mem(struct edgeport_serial *serial, + usb_serial_debug_data(debug, &serial->serial->dev->dev, + __func__, write_length, buffer); + +- /* Write next page */ +- be_start_address = cpu_to_be16(start_address); ++ /* ++ * Write next page. ++ * ++ * NOTE: Must use swab as wIndex is sent in little-endian byte ++ * order regardless of host byte order. ++ */ ++ be_start_address = swab16((u16)start_address); + status = ti_vsend_sync(serial->serial->dev, UMPC_MEMORY_WRITE, + (__u16)address_type, +- (__force __u16)be_start_address, ++ be_start_address, + buffer, write_length); + if (status) { + dev_err(&serial->serial->dev->dev, "%s - ERROR %d\n", +@@ -681,8 +696,8 @@ static int get_descriptor_addr(struct edgeport_serial *serial, + if (rom_desc->Type == desc_type) + return start_address; + +- start_address = start_address + sizeof(struct ti_i2c_desc) +- + rom_desc->Size; ++ start_address = start_address + sizeof(struct ti_i2c_desc) + ++ le16_to_cpu(rom_desc->Size); + + } while ((start_address < TI_MAX_I2C_SIZE) && rom_desc->Type); + +@@ -695,7 +710,7 @@ static int valid_csum(struct ti_i2c_desc *rom_desc, __u8 *buffer) + __u16 i; + __u8 cs = 0; + +- for (i = 0; i < rom_desc->Size; i++) ++ for (i = 0; i < le16_to_cpu(rom_desc->Size); i++) + cs = (__u8)(cs + buffer[i]); + + if (cs != rom_desc->CheckSum) { +@@ -749,7 +764,7 @@ static int check_i2c_image(struct edgeport_serial *serial) + break; + + if ((start_address + sizeof(struct ti_i2c_desc) + +- rom_desc->Size) > TI_MAX_I2C_SIZE) { ++ le16_to_cpu(rom_desc->Size)) > TI_MAX_I2C_SIZE) { + status = -ENODEV; + dbg("%s - structure too big, erroring out.", __func__); + break; +@@ -764,7 +779,8 @@ static int check_i2c_image(struct edgeport_serial *serial) + /* Read the descriptor data */ + status = read_rom(serial, start_address + + sizeof(struct ti_i2c_desc), +- rom_desc->Size, buffer); ++ le16_to_cpu(rom_desc->Size), ++ buffer); + if (status) + break; + +@@ -773,7 +789,7 @@ static int check_i2c_image(struct edgeport_serial *serial) + break; + } + start_address = start_address + sizeof(struct ti_i2c_desc) + +- rom_desc->Size; ++ le16_to_cpu(rom_desc->Size); + + } while ((rom_desc->Type != I2C_DESC_TYPE_ION) && + (start_address < TI_MAX_I2C_SIZE)); +@@ -812,7 +828,7 @@ static int get_manuf_info(struct edgeport_serial *serial, __u8 *buffer) + + /* Read the descriptor data */ + status = read_rom(serial, start_address+sizeof(struct ti_i2c_desc), +- rom_desc->Size, buffer); ++ le16_to_cpu(rom_desc->Size), buffer); + if (status) + goto exit; + +diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c +index 5f5047f..9823e79 100644 +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -234,8 +234,31 @@ static void option_instat_callback(struct urb *urb); + #define QUALCOMM_VENDOR_ID 0x05C6 + + #define CMOTECH_VENDOR_ID 0x16d8 +-#define CMOTECH_PRODUCT_6008 0x6008 +-#define CMOTECH_PRODUCT_6280 0x6280 ++#define CMOTECH_PRODUCT_6001 0x6001 ++#define CMOTECH_PRODUCT_CMU_300 0x6002 ++#define CMOTECH_PRODUCT_6003 0x6003 ++#define CMOTECH_PRODUCT_6004 0x6004 ++#define CMOTECH_PRODUCT_6005 0x6005 ++#define CMOTECH_PRODUCT_CGU_628A 0x6006 ++#define CMOTECH_PRODUCT_CHE_628S 0x6007 ++#define CMOTECH_PRODUCT_CMU_301 0x6008 ++#define CMOTECH_PRODUCT_CHU_628 0x6280 ++#define CMOTECH_PRODUCT_CHU_628S 0x6281 ++#define CMOTECH_PRODUCT_CDU_680 0x6803 ++#define CMOTECH_PRODUCT_CDU_685A 0x6804 ++#define CMOTECH_PRODUCT_CHU_720S 0x7001 ++#define CMOTECH_PRODUCT_7002 0x7002 ++#define CMOTECH_PRODUCT_CHU_629K 0x7003 ++#define CMOTECH_PRODUCT_7004 0x7004 ++#define CMOTECH_PRODUCT_7005 0x7005 ++#define CMOTECH_PRODUCT_CGU_629 0x7006 ++#define CMOTECH_PRODUCT_CHU_629S 0x700a ++#define CMOTECH_PRODUCT_CHU_720I 0x7211 ++#define CMOTECH_PRODUCT_7212 0x7212 ++#define CMOTECH_PRODUCT_7213 0x7213 ++#define CMOTECH_PRODUCT_7251 0x7251 ++#define CMOTECH_PRODUCT_7252 0x7252 ++#define CMOTECH_PRODUCT_7253 0x7253 + + #define TELIT_VENDOR_ID 0x1bc7 + #define TELIT_PRODUCT_UC864E 0x1003 +@@ -243,6 +266,7 @@ static void option_instat_callback(struct urb *urb); + #define TELIT_PRODUCT_CC864_DUAL 0x1005 + #define TELIT_PRODUCT_CC864_SINGLE 0x1006 + #define TELIT_PRODUCT_DE910_DUAL 0x1010 ++#define TELIT_PRODUCT_UE910_V2 0x1012 + #define TELIT_PRODUCT_LE920 0x1200 + + /* ZTE PRODUCTS */ +@@ -291,6 +315,7 @@ static void option_instat_callback(struct urb *urb); + #define ALCATEL_PRODUCT_X060S_X200 0x0000 + #define ALCATEL_PRODUCT_X220_X500D 0x0017 + #define ALCATEL_PRODUCT_L100V 0x011e ++#define ALCATEL_PRODUCT_L800MA 0x0203 + + #define PIRELLI_VENDOR_ID 0x1266 + #define PIRELLI_PRODUCT_C100_1 0x1002 +@@ -353,6 +378,7 @@ static void option_instat_callback(struct urb *urb); + #define OLIVETTI_PRODUCT_OLICARD100 0xc000 + #define OLIVETTI_PRODUCT_OLICARD145 0xc003 + #define OLIVETTI_PRODUCT_OLICARD200 0xc005 ++#define OLIVETTI_PRODUCT_OLICARD500 0xc00b + + /* Celot products */ + #define CELOT_VENDOR_ID 0x211f +@@ -514,6 +540,10 @@ static const struct option_blacklist_info huawei_cdc12_blacklist = { + .reserved = BIT(1) | BIT(2), + }; + ++static const struct option_blacklist_info net_intf0_blacklist = { ++ .reserved = BIT(0), ++}; ++ + static const struct option_blacklist_info net_intf1_blacklist = { + .reserved = BIT(1), + }; +@@ -1048,13 +1078,53 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */ + { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x0023)}, /* ONYX 3G device */ + { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x9000)}, /* SIMCom SIM5218 */ +- { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6280) }, /* BP3-USB & BP3-EXT HSDPA */ +- { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6008) }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6001) }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CMU_300) }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6003), ++ .driver_info = (kernel_ulong_t)&net_intf0_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6004) }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6005) }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CGU_628A) }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHE_628S), ++ .driver_info = (kernel_ulong_t)&net_intf0_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CMU_301), ++ .driver_info = (kernel_ulong_t)&net_intf0_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_628), ++ .driver_info = (kernel_ulong_t)&net_intf0_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_628S) }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CDU_680) }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CDU_685A) }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_720S), ++ .driver_info = (kernel_ulong_t)&net_intf0_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7002), ++ .driver_info = (kernel_ulong_t)&net_intf0_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_629K), ++ .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7004), ++ .driver_info = (kernel_ulong_t)&net_intf3_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7005) }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CGU_629), ++ .driver_info = (kernel_ulong_t)&net_intf5_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_629S), ++ .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CHU_720I), ++ .driver_info = (kernel_ulong_t)&net_intf0_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7212), ++ .driver_info = (kernel_ulong_t)&net_intf0_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7213), ++ .driver_info = (kernel_ulong_t)&net_intf0_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7251), ++ .driver_info = (kernel_ulong_t)&net_intf1_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7252), ++ .driver_info = (kernel_ulong_t)&net_intf1_blacklist }, ++ { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_7253), ++ .driver_info = (kernel_ulong_t)&net_intf1_blacklist }, + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864E) }, + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864G) }, + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_CC864_DUAL) }, + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_CC864_SINGLE) }, + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_DE910_DUAL) }, ++ { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UE910_V2) }, + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE920), + .driver_info = (kernel_ulong_t)&telit_le920_blacklist }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF622, 0xff, 0xff, 0xff) }, /* ZTE WCDMA products */ +@@ -1518,6 +1588,8 @@ static const struct usb_device_id option_ids[] = { + .driver_info = (kernel_ulong_t)&net_intf5_blacklist }, + { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_L100V), + .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, ++ { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_L800MA), ++ .driver_info = (kernel_ulong_t)&net_intf2_blacklist }, + { USB_DEVICE(AIRPLUS_VENDOR_ID, AIRPLUS_PRODUCT_MCD650) }, + { USB_DEVICE(TLAYTECH_VENDOR_ID, TLAYTECH_PRODUCT_TEU800) }, + { USB_DEVICE(LONGCHEER_VENDOR_ID, FOUR_G_SYSTEMS_PRODUCT_W14), +@@ -1563,6 +1635,9 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD200), + .driver_info = (kernel_ulong_t)&net_intf6_blacklist + }, ++ { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD500), ++ .driver_info = (kernel_ulong_t)&net_intf4_blacklist ++ }, + { USB_DEVICE(CELOT_VENDOR_ID, CELOT_PRODUCT_CT680M) }, /* CT-650 CDMA 450 1xEVDO modem */ + { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_GT_B3730, USB_CLASS_CDC_DATA, 0x00, 0x00) }, /* Samsung GT-B3730 LTE USB modem.*/ + { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM600) }, +diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c +index 7b29317..45a288c 100644 +--- a/drivers/usb/serial/pl2303.c ++++ b/drivers/usb/serial/pl2303.c +@@ -86,6 +86,9 @@ static const struct usb_device_id id_table[] = { + { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) }, + { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) }, + { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) }, ++ { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) }, ++ { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) }, ++ { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) }, + { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) }, + { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) }, + { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) }, +diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h +index c38b8c0..42bc082 100644 +--- a/drivers/usb/serial/pl2303.h ++++ b/drivers/usb/serial/pl2303.h +@@ -121,8 +121,11 @@ + #define SUPERIAL_VENDOR_ID 0x5372 + #define SUPERIAL_PRODUCT_ID 0x2303 + +-/* Hewlett-Packard LD220-HP POS Pole Display */ ++/* Hewlett-Packard POS Pole Displays */ + #define HP_VENDOR_ID 0x03f0 ++#define HP_LD960_PRODUCT_ID 0x0b39 ++#define HP_LCM220_PRODUCT_ID 0x3139 ++#define HP_LCM960_PRODUCT_ID 0x3239 + #define HP_LD220_PRODUCT_ID 0x3524 + + /* Cressi Edy (diving computer) PC interface */ +diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c +index a7fa673..dbdfeb4 100644 +--- a/drivers/usb/serial/sierra.c ++++ b/drivers/usb/serial/sierra.c +@@ -305,7 +305,6 @@ static const struct usb_device_id id_table[] = { + { USB_DEVICE(0x0f3d, 0x68A3), /* Airprime/Sierra Wireless Direct IP modems */ + .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist + }, +- { USB_DEVICE(0x413C, 0x08133) }, /* Dell Computer Corp. Wireless 5720 VZW Mobile Broadband (EVDO Rev-A) Minicard GPS Port */ + + { } + }; +diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c +index 850faa4..8f76a2b 100644 +--- a/drivers/usb/serial/usb-serial.c ++++ b/drivers/usb/serial/usb-serial.c +@@ -1400,10 +1400,12 @@ void usb_serial_deregister(struct usb_serial_driver *device) + /* must be called with BKL held */ + printk(KERN_INFO "USB Serial deregistering driver %s\n", + device->description); ++ + mutex_lock(&table_lock); + list_del(&device->driver_list); +- usb_serial_bus_deregister(device); + mutex_unlock(&table_lock); ++ ++ usb_serial_bus_deregister(device); + } + EXPORT_SYMBOL_GPL(usb_serial_deregister); + +diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c +index f8962a9..a1fee6f 100644 +--- a/fs/btrfs/inode-map.c ++++ b/fs/btrfs/inode-map.c +@@ -207,24 +207,14 @@ again: + + void btrfs_return_ino(struct btrfs_root *root, u64 objectid) + { +- struct btrfs_free_space_ctl *ctl = root->free_ino_ctl; + struct btrfs_free_space_ctl *pinned = root->free_ino_pinned; + + if (!btrfs_test_opt(root, INODE_MAP_CACHE)) + return; +- + again: + if (root->cached == BTRFS_CACHE_FINISHED) { +- __btrfs_add_free_space(ctl, objectid, 1); ++ __btrfs_add_free_space(pinned, objectid, 1); + } else { +- /* +- * If we are in the process of caching free ino chunks, +- * to avoid adding the same inode number to the free_ino +- * tree twice due to cross transaction, we'll leave it +- * in the pinned tree until a transaction is committed +- * or the caching work is done. +- */ +- + mutex_lock(&root->fs_commit_mutex); + spin_lock(&root->cache_lock); + if (root->cached == BTRFS_CACHE_FINISHED) { +@@ -236,11 +226,7 @@ again: + + start_caching(root); + +- if (objectid <= root->cache_progress || +- objectid > root->highest_objectid) +- __btrfs_add_free_space(ctl, objectid, 1); +- else +- __btrfs_add_free_space(pinned, objectid, 1); ++ __btrfs_add_free_space(pinned, objectid, 1); + + mutex_unlock(&root->fs_commit_mutex); + } +diff --git a/fs/ext4/file.c b/fs/ext4/file.c +index cb70f18..6199922 100644 +--- a/fs/ext4/file.c ++++ b/fs/ext4/file.c +@@ -80,7 +80,7 @@ ext4_unaligned_aio(struct inode *inode, const struct iovec *iov, + size_t count = iov_length(iov, nr_segs); + loff_t final_size = pos + count; + +- if (pos >= inode->i_size) ++ if (pos >= i_size_read(inode)) + return 0; + + if ((pos & blockmask) || (final_size & blockmask)) +diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c +index dc9f0ec..55d4f46 100644 +--- a/fs/ext4/inode.c ++++ b/fs/ext4/inode.c +@@ -481,6 +481,11 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode, + ext_debug("ext4_map_blocks(): inode %lu, flag %d, max_blocks %u," + "logical block %lu\n", inode->i_ino, flags, map->m_len, + (unsigned long) map->m_lblk); ++ ++ /* We can handle the block number less than EXT_MAX_BLOCKS */ ++ if (unlikely(map->m_lblk >= EXT_MAX_BLOCKS)) ++ return -EIO; ++ + /* + * Try to see if we can get the block without requesting a new + * file system block. +diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c +index 54f566d..b46a675 100644 +--- a/fs/ext4/page-io.c ++++ b/fs/ext4/page-io.c +@@ -241,13 +241,14 @@ static void ext4_end_bio(struct bio *bio, int error) + + if (error) { + io_end->flag |= EXT4_IO_END_ERROR; +- ext4_warning(inode->i_sb, "I/O error writing to inode %lu " ++ ext4_warning(inode->i_sb, "I/O error %d writing to inode %lu " + "(offset %llu size %ld starting block %llu)", +- inode->i_ino, ++ error, inode->i_ino, + (unsigned long long) io_end->offset, + (long) io_end->size, + (unsigned long long) + bi_sector >> (inode->i_blkbits - 9)); ++ mapping_set_error(inode->i_mapping, error); + } + + if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) { +diff --git a/fs/locks.c b/fs/locks.c +index fcc50ab..d4f1d89 100644 +--- a/fs/locks.c ++++ b/fs/locks.c +@@ -1253,11 +1253,10 @@ int __break_lease(struct inode *inode, unsigned int mode) + + restart: + break_time = flock->fl_break_time; +- if (break_time != 0) { ++ if (break_time != 0) + break_time -= jiffies; +- if (break_time == 0) +- break_time++; +- } ++ if (break_time == 0) ++ break_time++; + locks_insert_block(flock, new_fl); + unlock_flocks(); + error = wait_event_interruptible_timeout(new_fl->fl_wait, +diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c +index 7748d6a..809a38a 100644 +--- a/fs/nfsd/nfs4callback.c ++++ b/fs/nfsd/nfs4callback.c +@@ -633,9 +633,11 @@ static int max_cb_time(void) + + static int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *conn, struct nfsd4_session *ses) + { ++ int maxtime = max_cb_time(); + struct rpc_timeout timeparms = { +- .to_initval = max_cb_time(), ++ .to_initval = maxtime, + .to_retries = 0, ++ .to_maxval = maxtime, + }; + struct rpc_create_args args = { + .net = &init_net, +diff --git a/include/linux/libata.h b/include/linux/libata.h +index b1fcdba..375dfdf 100644 +--- a/include/linux/libata.h ++++ b/include/linux/libata.h +@@ -763,6 +763,7 @@ struct ata_port { + unsigned long qc_allocated; + unsigned int qc_active; + int nr_active_links; /* #links with active qcs */ ++ unsigned int last_tag; /* track next tag hw expects */ + + struct ata_link link; /* host default link */ + struct ata_link *slave_link; /* see ata_slave_link_init() */ +diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h +index 468819c..226e0ff 100644 +--- a/include/linux/mod_devicetable.h ++++ b/include/linux/mod_devicetable.h +@@ -461,7 +461,8 @@ enum dmi_field { + }; + + struct dmi_strmatch { +- unsigned char slot; ++ unsigned char slot:7; ++ unsigned char exact_match:1; + char substr[79]; + }; + +@@ -489,7 +490,8 @@ struct dmi_system_id { + #define dmi_device_id dmi_system_id + #endif + +-#define DMI_MATCH(a, b) { a, b } ++#define DMI_MATCH(a, b) { .slot = a, .substr = b } ++#define DMI_EXACT_MATCH(a, b) { .slot = a, .substr = b, .exact_match = 1 } + + #define PLATFORM_NAME_SIZE 20 + #define PLATFORM_MODULE_PREFIX "platform:" +diff --git a/mm/hugetlb.c b/mm/hugetlb.c +index d399f5f..cac2441 100644 +--- a/mm/hugetlb.c ++++ b/mm/hugetlb.c +@@ -1078,6 +1078,7 @@ static void return_unused_surplus_pages(struct hstate *h, + while (nr_pages--) { + if (!free_pool_huge_page(h, &node_states[N_HIGH_MEMORY], 1)) + break; ++ cond_resched_lock(&hugetlb_lock); + } + } + +diff --git a/mm/memory.c b/mm/memory.c +index d5f913b..483e665 100644 +--- a/mm/memory.c ++++ b/mm/memory.c +@@ -1852,12 +1852,17 @@ int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm, + unsigned long address, unsigned int fault_flags) + { + struct vm_area_struct *vma; ++ vm_flags_t vm_flags; + int ret; + + vma = find_extend_vma(mm, address); + if (!vma || address < vma->vm_start) + return -EFAULT; + ++ vm_flags = (fault_flags & FAULT_FLAG_WRITE) ? VM_WRITE : VM_READ; ++ if (!(vm_flags & vma->vm_flags)) ++ return -EFAULT; ++ + ret = handle_mm_fault(mm, vma, address, fault_flags); + if (ret & VM_FAULT_ERROR) { + if (ret & VM_FAULT_OOM) |