openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6 

Conflicts:
	drivers/net/e1000e/netdev.c
This commit is contained in:
David S. Miller 2011-02-08 17:19:01 -08:00
parent 8d13a2a9fb c69b90920a
commit 263fb5b1bf
31 changed files with 306 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
drivers/net/benet/be_cmds.c
View File

@ -1786,6 +1786,10 @@ int be_cmd_get_seeprom_data(struct be_adapter *adapter,
spin_lock_bh(&adapter->mcc_lock); spin_lock_bh(&adapter->mcc_lock);
wrb = wrb_from_mccq(adapter); wrb = wrb_from_mccq(adapter);
if (!wrb) {
status = -EBUSY;
goto err;
}
req = nonemb_cmd->va; req = nonemb_cmd->va;
sge = nonembedded_sgl(wrb); sge = nonembedded_sgl(wrb);
@ -1801,6 +1805,7 @@ int be_cmd_get_seeprom_data(struct be_adapter *adapter,
status = be_mcc_notify_wait(adapter); status = be_mcc_notify_wait(adapter);
err:
spin_unlock_bh(&adapter->mcc_lock); spin_unlock_bh(&adapter->mcc_lock);
return status; return status;
} }

32
drivers/net/bnx2x/bnx2x_main.c
View File

@ -4300,9 +4300,12 @@ void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
def_q_filters |= BNX2X_ACCEPT_UNICAST | BNX2X_ACCEPT_BROADCAST | def_q_filters |= BNX2X_ACCEPT_UNICAST | BNX2X_ACCEPT_BROADCAST |
BNX2X_ACCEPT_MULTICAST; BNX2X_ACCEPT_MULTICAST;
#ifdef BCM_CNIC #ifdef BCM_CNIC
cl_id = bnx2x_fcoe(bp, cl_id); if (!NO_FCOE(bp)) {
bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_UNICAST | cl_id = bnx2x_fcoe(bp, cl_id);
BNX2X_ACCEPT_MULTICAST); bnx2x_rxq_set_mac_filters(bp, cl_id,
BNX2X_ACCEPT_UNICAST |
BNX2X_ACCEPT_MULTICAST);
}
#endif #endif
break; break;
@ -4310,18 +4313,29 @@ void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
def_q_filters |= BNX2X_ACCEPT_UNICAST | BNX2X_ACCEPT_BROADCAST | def_q_filters |= BNX2X_ACCEPT_UNICAST | BNX2X_ACCEPT_BROADCAST |
BNX2X_ACCEPT_ALL_MULTICAST; BNX2X_ACCEPT_ALL_MULTICAST;
#ifdef BCM_CNIC #ifdef BCM_CNIC
cl_id = bnx2x_fcoe(bp, cl_id); /*
bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_UNICAST | * Prevent duplication of multicast packets by configuring FCoE
BNX2X_ACCEPT_MULTICAST); * L2 Client to receive only matched unicast frames.
*/
if (!NO_FCOE(bp)) {
cl_id = bnx2x_fcoe(bp, cl_id);
bnx2x_rxq_set_mac_filters(bp, cl_id,
BNX2X_ACCEPT_UNICAST);
}
#endif #endif
break; break;
case BNX2X_RX_MODE_PROMISC: case BNX2X_RX_MODE_PROMISC:
def_q_filters |= BNX2X_PROMISCUOUS_MODE; def_q_filters |= BNX2X_PROMISCUOUS_MODE;
#ifdef BCM_CNIC #ifdef BCM_CNIC
cl_id = bnx2x_fcoe(bp, cl_id); /*
bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_UNICAST | * Prevent packets duplication by configuring DROP_ALL for FCoE
BNX2X_ACCEPT_MULTICAST); * L2 Client.
*/
if (!NO_FCOE(bp)) {
cl_id = bnx2x_fcoe(bp, cl_id);
bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_NONE);
}
#endif #endif
/* pass management unicast packets as well */ /* pass management unicast packets as well */
llh_mask |= NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_UNCST; llh_mask |= NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_UNCST;

5
drivers/net/can/pch_can.c
View File

@ -187,7 +187,7 @@ static struct can_bittiming_const pch_can_bittiming_const = {
.name = KBUILD_MODNAME, .name = KBUILD_MODNAME,
.tseg1_min = 1, .tseg1_min = 1,
.tseg1_max = 16, .tseg1_max = 16,
.tseg2_min = 1, .tseg2_min = 2,
.tseg2_max = 8, .tseg2_max = 8,
.sjw_max = 4, .sjw_max = 4,
.brp_min = 1, .brp_min = 1,
@ -959,13 +959,13 @@ static void __devexit pch_can_remove(struct pci_dev *pdev)
struct pch_can_priv *priv = netdev_priv(ndev); struct pch_can_priv *priv = netdev_priv(ndev);
unregister_candev(priv->ndev); unregister_candev(priv->ndev);
pci_iounmap(pdev, priv->regs);
if (priv->use_msi) if (priv->use_msi)
pci_disable_msi(priv->dev); pci_disable_msi(priv->dev);
pci_release_regions(pdev); pci_release_regions(pdev);
pci_disable_device(pdev); pci_disable_device(pdev);
pci_set_drvdata(pdev, NULL); pci_set_drvdata(pdev, NULL);
pch_can_reset(priv); pch_can_reset(priv);
pci_iounmap(pdev, priv->regs);
free_candev(priv->ndev); free_candev(priv->ndev);
} }
@ -1238,6 +1238,7 @@ static int __devinit pch_can_probe(struct pci_dev *pdev,
priv->use_msi = 0; priv->use_msi = 0;
} else { } else {
netdev_err(ndev, "PCH CAN opened with MSI\n"); netdev_err(ndev, "PCH CAN opened with MSI\n");
pci_set_master(pdev);
priv->use_msi = 1; priv->use_msi = 1;
} }

4
drivers/net/e1000/e1000_hw.c
View File

@ -124,6 +124,7 @@ static s32 e1000_set_phy_type(struct e1000_hw *hw)
case M88E1000_I_PHY_ID: case M88E1000_I_PHY_ID:
case M88E1011_I_PHY_ID: case M88E1011_I_PHY_ID:
case M88E1111_I_PHY_ID: case M88E1111_I_PHY_ID:
case M88E1118_E_PHY_ID:
hw->phy_type = e1000_phy_m88; hw->phy_type = e1000_phy_m88;
break; break;
case IGP01E1000_I_PHY_ID: case IGP01E1000_I_PHY_ID:
@ -3222,7 +3223,8 @@ static s32 e1000_detect_gig_phy(struct e1000_hw *hw)
break; break;
case e1000_ce4100: case e1000_ce4100:
if ((hw->phy_id == RTL8211B_PHY_ID) || if ((hw->phy_id == RTL8211B_PHY_ID) ||
(hw->phy_id == RTL8201N_PHY_ID)) (hw->phy_id == RTL8201N_PHY_ID) ||
(hw->phy_id == M88E1118_E_PHY_ID))
match = true; match = true;
break; break;
case e1000_82541: case e1000_82541:

1
drivers/net/e1000/e1000_hw.h
View File

@ -2917,6 +2917,7 @@ struct e1000_host_command_info {
#define M88E1000_14_PHY_ID M88E1000_E_PHY_ID #define M88E1000_14_PHY_ID M88E1000_E_PHY_ID
#define M88E1011_I_REV_4 0x04 #define M88E1011_I_REV_4 0x04
#define M88E1111_I_PHY_ID 0x01410CC0 #define M88E1111_I_PHY_ID 0x01410CC0
#define M88E1118_E_PHY_ID 0x01410E40
#define L1LXT971A_PHY_ID 0x001378E0 #define L1LXT971A_PHY_ID 0x001378E0
#define RTL8211B_PHY_ID 0x001CC910 #define RTL8211B_PHY_ID 0x001CC910

1
drivers/net/e1000e/netdev.c
View File

@ -4311,7 +4311,6 @@ static void e1000_watchdog_task(struct work_struct *work)
* to get done, so reset controller to flush Tx. * to get done, so reset controller to flush Tx.
* (Do the reset outside of interrupt context). * (Do the reset outside of interrupt context).
*/ */
adapter->tx_timeout_count++;
schedule_work(&adapter->reset_task); schedule_work(&adapter->reset_task);
/* return immediately since reset is imminent */ /* return immediately since reset is imminent */
return; return;

3
drivers/net/ixgbe/ixgbe_common.c
View File

@ -1370,6 +1370,9 @@ s32 ixgbe_init_rx_addrs_generic(struct ixgbe_hw *hw)
hw_dbg(hw, " New MAC Addr =%pM\n", hw->mac.addr); hw_dbg(hw, " New MAC Addr =%pM\n", hw->mac.addr);
hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
/* clear VMDq pool/queue selection for RAR 0 */
hw->mac.ops.clear_vmdq(hw, 0, IXGBE_CLEAR_VMDQ_ALL);
} }
hw->addr_ctrl.overflow_promisc = 0; hw->addr_ctrl.overflow_promisc = 0;

2
drivers/net/ixgbe/ixgbe_fcoe.c
View File

@ -165,7 +165,7 @@ int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
unsigned int thisoff = 0; unsigned int thisoff = 0;
unsigned int thislen = 0; unsigned int thislen = 0;
u32 fcbuff, fcdmarw, fcfltrw; u32 fcbuff, fcdmarw, fcfltrw;
dma_addr_t addr; dma_addr_t addr = 0;
if (!netdev || !sgl) if (!netdev || !sgl)
return 0; return 0;

16
drivers/net/ixgbe/ixgbe_main.c
View File

@ -52,7 +52,7 @@ char ixgbe_driver_name[] = "ixgbe";
static const char ixgbe_driver_string[] = static const char ixgbe_driver_string[] =
"Intel(R) 10 Gigabit PCI Express Network Driver"; "Intel(R) 10 Gigabit PCI Express Network Driver";
#define DRV_VERSION "3.0.12-k2" #define DRV_VERSION "3.2.9-k2"
const char ixgbe_driver_version[] = DRV_VERSION; const char ixgbe_driver_version[] = DRV_VERSION;
static char ixgbe_copyright[] = "Copyright (c) 1999-2010 Intel Corporation."; static char ixgbe_copyright[] = "Copyright (c) 1999-2010 Intel Corporation.";
@ -3176,9 +3176,16 @@ static void ixgbe_set_rx_buffer_len(struct ixgbe_adapter *adapter)
u32 mhadd, hlreg0; u32 mhadd, hlreg0;
/* Decide whether to use packet split mode or not */ /* Decide whether to use packet split mode or not */
/* On by default */
adapter->flags |= IXGBE_FLAG_RX_PS_ENABLED;
/* Do not use packet split if we're in SR-IOV Mode */ /* Do not use packet split if we're in SR-IOV Mode */
if (!adapter->num_vfs) if (adapter->num_vfs)
adapter->flags |= IXGBE_FLAG_RX_PS_ENABLED; adapter->flags &= ~IXGBE_FLAG_RX_PS_ENABLED;
/* Disable packet split due to 82599 erratum #45 */
if (hw->mac.type == ixgbe_mac_82599EB)
adapter->flags &= ~IXGBE_FLAG_RX_PS_ENABLED;
/* Set the RX buffer length according to the mode */ /* Set the RX buffer length according to the mode */
if (adapter->flags & IXGBE_FLAG_RX_PS_ENABLED) { if (adapter->flags & IXGBE_FLAG_RX_PS_ENABLED) {
@ -4863,16 +4870,13 @@ static int ixgbe_alloc_q_vectors(struct ixgbe_adapter *adapter)
{ {
int q_idx, num_q_vectors; int q_idx, num_q_vectors;
struct ixgbe_q_vector *q_vector; struct ixgbe_q_vector *q_vector;
int napi_vectors;
int (*poll)(struct napi_struct *, int); int (*poll)(struct napi_struct *, int);
if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) { if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
num_q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS; num_q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
napi_vectors = adapter->num_rx_queues;
poll = &ixgbe_clean_rxtx_many; poll = &ixgbe_clean_rxtx_many;
} else { } else {
num_q_vectors = 1; num_q_vectors = 1;
napi_vectors = 1;
poll = &ixgbe_poll; poll = &ixgbe_poll;
} }

2
drivers/net/ixgbe/ixgbe_sriov.c
View File

@ -110,12 +110,10 @@ static int ixgbe_set_vf_vlan(struct ixgbe_adapter *adapter, int add, int vid,
return adapter->hw.mac.ops.set_vfta(&adapter->hw, vid, vf, (bool)add); return adapter->hw.mac.ops.set_vfta(&adapter->hw, vid, vf, (bool)add);
} }
static void ixgbe_set_vmolr(struct ixgbe_hw *hw, u32 vf, bool aupe) static void ixgbe_set_vmolr(struct ixgbe_hw *hw, u32 vf, bool aupe)
{ {
u32 vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf)); u32 vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf));
vmolr |= (IXGBE_VMOLR_ROMPE | vmolr |= (IXGBE_VMOLR_ROMPE |
IXGBE_VMOLR_ROPE |
IXGBE_VMOLR_BAM); IXGBE_VMOLR_BAM);
if (aupe) if (aupe)
vmolr |= IXGBE_VMOLR_AUPE; vmolr |= IXGBE_VMOLR_AUPE;

6
drivers/net/ixgbe/ixgbe_x540.c
View File

@ -133,17 +133,17 @@ static s32 ixgbe_reset_hw_X540(struct ixgbe_hw *hw)
} }
ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL); ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);
IXGBE_WRITE_REG(hw, IXGBE_CTRL, (ctrl | IXGBE_CTRL_RST)); IXGBE_WRITE_REG(hw, IXGBE_CTRL, (ctrl | reset_bit));
IXGBE_WRITE_FLUSH(hw); IXGBE_WRITE_FLUSH(hw);
/* Poll for reset bit to self-clear indicating reset is complete */ /* Poll for reset bit to self-clear indicating reset is complete */
for (i = 0; i < 10; i++) { for (i = 0; i < 10; i++) {
udelay(1); udelay(1);
ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL); ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);
if (!(ctrl & IXGBE_CTRL_RST)) if (!(ctrl & reset_bit))
break; break;
} }
if (ctrl & IXGBE_CTRL_RST) { if (ctrl & reset_bit) {
status = IXGBE_ERR_RESET_FAILED; status = IXGBE_ERR_RESET_FAILED;
hw_dbg(hw, "Reset polling failed to complete.\n"); hw_dbg(hw, "Reset polling failed to complete.\n");
} }

1
drivers/net/sis900.c
View File

@ -1777,6 +1777,7 @@ static int sis900_rx(struct net_device *net_dev)
"cur_rx:%4.4d, dirty_rx:%4.4d\n", "cur_rx:%4.4d, dirty_rx:%4.4d\n",
net_dev->name, sis_priv->cur_rx, net_dev->name, sis_priv->cur_rx,
sis_priv->dirty_rx); sis_priv->dirty_rx);
dev_kfree_skb(skb);
break; break;
} }

225
drivers/net/usb/cdc_ncm.c
View File

@ -1,7 +1,7 @@
/* /*
* cdc_ncm.c * cdc_ncm.c
* *
* Copyright (C) ST-Ericsson 2010 * Copyright (C) ST-Ericsson 2010-2011
* Contact: Alexey Orishko <alexey.orishko@stericsson.com> * Contact: Alexey Orishko <alexey.orishko@stericsson.com>
* Original author: Hans Petter Selasky <hans.petter.selasky@stericsson.com> * Original author: Hans Petter Selasky <hans.petter.selasky@stericsson.com>
* *
@ -54,7 +54,7 @@
#include <linux/usb/usbnet.h> #include <linux/usb/usbnet.h>
#include <linux/usb/cdc.h> #include <linux/usb/cdc.h>
#define DRIVER_VERSION "17-Jan-2011" #define DRIVER_VERSION "7-Feb-2011"
/* CDC NCM subclass 3.2.1 */ /* CDC NCM subclass 3.2.1 */
#define USB_CDC_NCM_NDP16_LENGTH_MIN 0x10 #define USB_CDC_NCM_NDP16_LENGTH_MIN 0x10
@ -77,6 +77,9 @@
*/ */
#define CDC_NCM_DPT_DATAGRAMS_MAX 32 #define CDC_NCM_DPT_DATAGRAMS_MAX 32
/* Maximum amount of IN datagrams in NTB */
#define CDC_NCM_DPT_DATAGRAMS_IN_MAX 0 /* unlimited */
/* Restart the timer, if amount of datagrams is less than given value */ /* Restart the timer, if amount of datagrams is less than given value */
#define CDC_NCM_RESTART_TIMER_DATAGRAM_CNT 3 #define CDC_NCM_RESTART_TIMER_DATAGRAM_CNT 3
@ -85,11 +88,6 @@
(sizeof(struct usb_cdc_ncm_nth16) + sizeof(struct usb_cdc_ncm_ndp16) + \ (sizeof(struct usb_cdc_ncm_nth16) + sizeof(struct usb_cdc_ncm_ndp16) + \
(CDC_NCM_DPT_DATAGRAMS_MAX + 1) * sizeof(struct usb_cdc_ncm_dpe16)) (CDC_NCM_DPT_DATAGRAMS_MAX + 1) * sizeof(struct usb_cdc_ncm_dpe16))
struct connection_speed_change {
__le32 USBitRate; /* holds 3GPP downlink value, bits per second */
__le32 DSBitRate; /* holds 3GPP uplink value, bits per second */
} __attribute__ ((packed));
struct cdc_ncm_data { struct cdc_ncm_data {
struct usb_cdc_ncm_nth16 nth16; struct usb_cdc_ncm_nth16 nth16;
struct usb_cdc_ncm_ndp16 ndp16; struct usb_cdc_ncm_ndp16 ndp16;
@ -198,10 +196,10 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
{ {
struct usb_cdc_notification req; struct usb_cdc_notification req;
u32 val; u32 val;
__le16 max_datagram_size;
u8 flags; u8 flags;
u8 iface_no; u8 iface_no;
int err; int err;
u16 ntb_fmt_supported;
iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber; iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber;
@ -223,6 +221,9 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder); ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder);
ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor); ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor);
ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment); ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment);
/* devices prior to NCM Errata shall set this field to zero */
ctx->tx_max_datagrams = le16_to_cpu(ctx->ncm_parm.wNtbOutMaxDatagrams);
ntb_fmt_supported = le16_to_cpu(ctx->ncm_parm.bmNtbFormatsSupported);
if (ctx->func_desc != NULL) if (ctx->func_desc != NULL)
flags = ctx->func_desc->bmNetworkCapabilities; flags = ctx->func_desc->bmNetworkCapabilities;
@ -231,22 +232,58 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
pr_debug("dwNtbInMaxSize=%u dwNtbOutMaxSize=%u " pr_debug("dwNtbInMaxSize=%u dwNtbOutMaxSize=%u "
"wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u " "wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u "
"wNdpOutAlignment=%u flags=0x%x\n", "wNdpOutAlignment=%u wNtbOutMaxDatagrams=%u flags=0x%x\n",
ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus, ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus,
ctx->tx_ndp_modulus, flags); ctx->tx_ndp_modulus, ctx->tx_max_datagrams, flags);
/* max count of tx datagrams without terminating NULL entry */ /* max count of tx datagrams */
ctx->tx_max_datagrams = CDC_NCM_DPT_DATAGRAMS_MAX; if ((ctx->tx_max_datagrams == 0) ||
(ctx->tx_max_datagrams > CDC_NCM_DPT_DATAGRAMS_MAX))
ctx->tx_max_datagrams = CDC_NCM_DPT_DATAGRAMS_MAX;
/* verify maximum size of received NTB in bytes */ /* verify maximum size of received NTB in bytes */
if ((ctx->rx_max < if (ctx->rx_max < USB_CDC_NCM_NTB_MIN_IN_SIZE) {
(CDC_NCM_MIN_HDR_SIZE + CDC_NCM_MIN_DATAGRAM_SIZE)) || pr_debug("Using min receive length=%d\n",
(ctx->rx_max > CDC_NCM_NTB_MAX_SIZE_RX)) { USB_CDC_NCM_NTB_MIN_IN_SIZE);
ctx->rx_max = USB_CDC_NCM_NTB_MIN_IN_SIZE;
}
if (ctx->rx_max > CDC_NCM_NTB_MAX_SIZE_RX) {
pr_debug("Using default maximum receive length=%d\n", pr_debug("Using default maximum receive length=%d\n",
CDC_NCM_NTB_MAX_SIZE_RX); CDC_NCM_NTB_MAX_SIZE_RX);
ctx->rx_max = CDC_NCM_NTB_MAX_SIZE_RX; ctx->rx_max = CDC_NCM_NTB_MAX_SIZE_RX;
} }
/* inform device about NTB input size changes */
if (ctx->rx_max != le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)) {
req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
USB_RECIP_INTERFACE;
req.bNotificationType = USB_CDC_SET_NTB_INPUT_SIZE;
req.wValue = 0;
req.wIndex = cpu_to_le16(iface_no);
if (flags & USB_CDC_NCM_NCAP_NTB_INPUT_SIZE) {
struct usb_cdc_ncm_ndp_input_size ndp_in_sz;
req.wLength = 8;
ndp_in_sz.dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
ndp_in_sz.wNtbInMaxDatagrams =
cpu_to_le16(CDC_NCM_DPT_DATAGRAMS_MAX);
ndp_in_sz.wReserved = 0;
err = cdc_ncm_do_request(ctx, &req, &ndp_in_sz, 0, NULL,
1000);
} else {
__le32 dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
req.wLength = 4;
err = cdc_ncm_do_request(ctx, &req, &dwNtbInMaxSize, 0,
NULL, 1000);
}
if (err)
pr_debug("Setting NTB Input Size failed\n");
}
/* verify maximum size of transmitted NTB in bytes */ /* verify maximum size of transmitted NTB in bytes */
if ((ctx->tx_max < if ((ctx->tx_max <
(CDC_NCM_MIN_HDR_SIZE + CDC_NCM_MIN_DATAGRAM_SIZE)) || (CDC_NCM_MIN_HDR_SIZE + CDC_NCM_MIN_DATAGRAM_SIZE)) ||
@ -297,47 +334,84 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
/* additional configuration */ /* additional configuration */
/* set CRC Mode */ /* set CRC Mode */
req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE; if (flags & USB_CDC_NCM_NCAP_CRC_MODE) {
req.bNotificationType = USB_CDC_SET_CRC_MODE; req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
req.wValue = cpu_to_le16(USB_CDC_NCM_CRC_NOT_APPENDED); USB_RECIP_INTERFACE;
req.wIndex = cpu_to_le16(iface_no); req.bNotificationType = USB_CDC_SET_CRC_MODE;
req.wLength = 0; req.wValue = cpu_to_le16(USB_CDC_NCM_CRC_NOT_APPENDED);
req.wIndex = cpu_to_le16(iface_no);
req.wLength = 0;
err = cdc_ncm_do_request(ctx, &req, NULL, 0, NULL, 1000); err = cdc_ncm_do_request(ctx, &req, NULL, 0, NULL, 1000);
if (err) if (err)
pr_debug("Setting CRC mode off failed\n"); pr_debug("Setting CRC mode off failed\n");
}
/* set NTB format */ /* set NTB format, if both formats are supported */
req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE; if (ntb_fmt_supported & USB_CDC_NCM_NTH32_SIGN) {
req.bNotificationType = USB_CDC_SET_NTB_FORMAT; req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
req.wValue = cpu_to_le16(USB_CDC_NCM_NTB16_FORMAT); USB_RECIP_INTERFACE;
req.wIndex = cpu_to_le16(iface_no); req.bNotificationType = USB_CDC_SET_NTB_FORMAT;
req.wLength = 0; req.wValue = cpu_to_le16(USB_CDC_NCM_NTB16_FORMAT);
req.wIndex = cpu_to_le16(iface_no);
req.wLength = 0;
err = cdc_ncm_do_request(ctx, &req, NULL, 0, NULL, 1000); err = cdc_ncm_do_request(ctx, &req, NULL, 0, NULL, 1000);
if (err) if (err)
pr_debug("Setting NTB format to 16-bit failed\n"); pr_debug("Setting NTB format to 16-bit failed\n");
}
ctx->max_datagram_size = CDC_NCM_MIN_DATAGRAM_SIZE;
/* set Max Datagram Size (MTU) */ /* set Max Datagram Size (MTU) */
req.bmRequestType = USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE; if (flags & USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE) {
req.bNotificationType = USB_CDC_GET_MAX_DATAGRAM_SIZE; __le16 max_datagram_size;
req.wValue = 0; u16 eth_max_sz = le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
req.wIndex = cpu_to_le16(iface_no);
req.wLength = cpu_to_le16(2);
err = cdc_ncm_do_request(ctx, &req, &max_datagram_size, 0, NULL, 1000); req.bmRequestType = USB_TYPE_CLASS | USB_DIR_IN |
if (err) { USB_RECIP_INTERFACE;
pr_debug(" GET_MAX_DATAGRAM_SIZE failed, using size=%u\n", req.bNotificationType = USB_CDC_GET_MAX_DATAGRAM_SIZE;
CDC_NCM_MIN_DATAGRAM_SIZE); req.wValue = 0;
/* use default */ req.wIndex = cpu_to_le16(iface_no);
ctx->max_datagram_size = CDC_NCM_MIN_DATAGRAM_SIZE; req.wLength = cpu_to_le16(2);
} else {
ctx->max_datagram_size = le16_to_cpu(max_datagram_size); err = cdc_ncm_do_request(ctx, &req, &max_datagram_size, 0, NULL,
1000);
if (err) {
pr_debug("GET_MAX_DATAGRAM_SIZE failed, use size=%u\n",
CDC_NCM_MIN_DATAGRAM_SIZE);
} else {
ctx->max_datagram_size = le16_to_cpu(max_datagram_size);
/* Check Eth descriptor value */
if (eth_max_sz < CDC_NCM_MAX_DATAGRAM_SIZE) {
if (ctx->max_datagram_size > eth_max_sz)
ctx->max_datagram_size = eth_max_sz;
} else {
if (ctx->max_datagram_size >
CDC_NCM_MAX_DATAGRAM_SIZE)
ctx->max_datagram_size =
CDC_NCM_MAX_DATAGRAM_SIZE;
}
if (ctx->max_datagram_size < CDC_NCM_MIN_DATAGRAM_SIZE)
ctx->max_datagram_size =
CDC_NCM_MIN_DATAGRAM_SIZE;
/* if value changed, update device */
req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
USB_RECIP_INTERFACE;
req.bNotificationType = USB_CDC_SET_MAX_DATAGRAM_SIZE;
req.wValue = 0;
req.wIndex = cpu_to_le16(iface_no);
req.wLength = 2;
max_datagram_size = cpu_to_le16(ctx->max_datagram_size);
err = cdc_ncm_do_request(ctx, &req, &max_datagram_size,
0, NULL, 1000);
if (err)
pr_debug("SET_MAX_DATAGRAM_SIZE failed\n");
}
if (ctx->max_datagram_size < CDC_NCM_MIN_DATAGRAM_SIZE)
ctx->max_datagram_size = CDC_NCM_MIN_DATAGRAM_SIZE;
else if (ctx->max_datagram_size > CDC_NCM_MAX_DATAGRAM_SIZE)
ctx->max_datagram_size = CDC_NCM_MAX_DATAGRAM_SIZE;
} }
if (ctx->netdev->mtu != (ctx->max_datagram_size - ETH_HLEN)) if (ctx->netdev->mtu != (ctx->max_datagram_size - ETH_HLEN))
@ -466,19 +540,13 @@ static int cdc_ncm_bind(struct usbnet *dev, struct usb_interface *intf)
ctx->ether_desc = ctx->ether_desc =
(const struct usb_cdc_ether_desc *)buf; (const struct usb_cdc_ether_desc *)buf;
dev->hard_mtu = dev->hard_mtu =
le16_to_cpu(ctx->ether_desc->wMaxSegmentSize); le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
if (dev->hard_mtu < if (dev->hard_mtu < CDC_NCM_MIN_DATAGRAM_SIZE)
(CDC_NCM_MIN_DATAGRAM_SIZE - ETH_HLEN)) dev->hard_mtu = CDC_NCM_MIN_DATAGRAM_SIZE;
dev->hard_mtu = else if (dev->hard_mtu > CDC_NCM_MAX_DATAGRAM_SIZE)
CDC_NCM_MIN_DATAGRAM_SIZE - ETH_HLEN; dev->hard_mtu = CDC_NCM_MAX_DATAGRAM_SIZE;
else if (dev->hard_mtu >
(CDC_NCM_MAX_DATAGRAM_SIZE - ETH_HLEN))
dev->hard_mtu =
CDC_NCM_MAX_DATAGRAM_SIZE - ETH_HLEN;
break; break;
case USB_CDC_NCM_TYPE: case USB_CDC_NCM_TYPE:
@ -628,13 +696,13 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
u32 offset; u32 offset;
u32 last_offset; u32 last_offset;
u16 n = 0; u16 n = 0;
u8 timeout = 0; u8 ready2send = 0;
/* if there is a remaining skb, it gets priority */ /* if there is a remaining skb, it gets priority */
if (skb != NULL) if (skb != NULL)
swap(skb, ctx->tx_rem_skb); swap(skb, ctx->tx_rem_skb);
else else
timeout = 1; ready2send = 1;
/* /*
* +----------------+ * +----------------+
@ -682,9 +750,10 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
for (; n < ctx->tx_max_datagrams; n++) { for (; n < ctx->tx_max_datagrams; n++) {
/* check if end of transmit buffer is reached */ /* check if end of transmit buffer is reached */
if (offset >= ctx->tx_max) if (offset >= ctx->tx_max) {
ready2send = 1;
break; break;
}
/* compute maximum buffer size */ /* compute maximum buffer size */
rem = ctx->tx_max - offset; rem = ctx->tx_max - offset;
@ -711,9 +780,7 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
} }
ctx->tx_rem_skb = skb; ctx->tx_rem_skb = skb;
skb = NULL; skb = NULL;
ready2send = 1;
/* loop one more time */
timeout = 1;
} }
break; break;
} }
@ -756,7 +823,7 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
ctx->tx_curr_last_offset = last_offset; ctx->tx_curr_last_offset = last_offset;
goto exit_no_skb; goto exit_no_skb;
} else if ((n < ctx->tx_max_datagrams) && (timeout == 0)) { } else if ((n < ctx->tx_max_datagrams) && (ready2send == 0)) {
/* wait for more frames */ /* wait for more frames */
/* push variables */ /* push variables */
ctx->tx_curr_skb = skb_out; ctx->tx_curr_skb = skb_out;
@ -813,7 +880,7 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
cpu_to_le16(sizeof(ctx->tx_ncm.nth16)); cpu_to_le16(sizeof(ctx->tx_ncm.nth16));
ctx->tx_ncm.nth16.wSequence = cpu_to_le16(ctx->tx_seq); ctx->tx_ncm.nth16.wSequence = cpu_to_le16(ctx->tx_seq);
ctx->tx_ncm.nth16.wBlockLength = cpu_to_le16(last_offset); ctx->tx_ncm.nth16.wBlockLength = cpu_to_le16(last_offset);
ctx->tx_ncm.nth16.wFpIndex = ALIGN(sizeof(struct usb_cdc_ncm_nth16), ctx->tx_ncm.nth16.wNdpIndex = ALIGN(sizeof(struct usb_cdc_ncm_nth16),
ctx->tx_ndp_modulus); ctx->tx_ndp_modulus);
memcpy(skb_out->data, &(ctx->tx_ncm.nth16), sizeof(ctx->tx_ncm.nth16)); memcpy(skb_out->data, &(ctx->tx_ncm.nth16), sizeof(ctx->tx_ncm.nth16));
@ -825,13 +892,13 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
rem = sizeof(ctx->tx_ncm.ndp16) + ((ctx->tx_curr_frame_num + 1) * rem = sizeof(ctx->tx_ncm.ndp16) + ((ctx->tx_curr_frame_num + 1) *
sizeof(struct usb_cdc_ncm_dpe16)); sizeof(struct usb_cdc_ncm_dpe16));
ctx->tx_ncm.ndp16.wLength = cpu_to_le16(rem); ctx->tx_ncm.ndp16.wLength = cpu_to_le16(rem);
ctx->tx_ncm.ndp16.wNextFpIndex = 0; /* reserved */ ctx->tx_ncm.ndp16.wNextNdpIndex = 0; /* reserved */
memcpy(((u8 *)skb_out->data) + ctx->tx_ncm.nth16.wFpIndex, memcpy(((u8 *)skb_out->data) + ctx->tx_ncm.nth16.wNdpIndex,
&(ctx->tx_ncm.ndp16), &(ctx->tx_ncm.ndp16),
sizeof(ctx->tx_ncm.ndp16)); sizeof(ctx->tx_ncm.ndp16));
memcpy(((u8 *)skb_out->data) + ctx->tx_ncm.nth16.wFpIndex + memcpy(((u8 *)skb_out->data) + ctx->tx_ncm.nth16.wNdpIndex +
sizeof(ctx->tx_ncm.ndp16), sizeof(ctx->tx_ncm.ndp16),
&(ctx->tx_ncm.dpe16), &(ctx->tx_ncm.dpe16),
(ctx->tx_curr_frame_num + 1) * (ctx->tx_curr_frame_num + 1) *
@ -961,7 +1028,7 @@ static int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in)
goto error; goto error;
} }
temp = le16_to_cpu(ctx->rx_ncm.nth16.wFpIndex); temp = le16_to_cpu(ctx->rx_ncm.nth16.wNdpIndex);
if ((temp + sizeof(ctx->rx_ncm.ndp16)) > actlen) { if ((temp + sizeof(ctx->rx_ncm.ndp16)) > actlen) {
pr_debug("invalid DPT16 index\n"); pr_debug("invalid DPT16 index\n");
goto error; goto error;
@ -1048,10 +1115,10 @@ static int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in)
static void static void
cdc_ncm_speed_change(struct cdc_ncm_ctx *ctx, cdc_ncm_speed_change(struct cdc_ncm_ctx *ctx,
struct connection_speed_change *data) struct usb_cdc_speed_change *data)
{ {
uint32_t rx_speed = le32_to_cpu(data->USBitRate); uint32_t rx_speed = le32_to_cpu(data->DLBitRRate);
uint32_t tx_speed = le32_to_cpu(data->DSBitRate); uint32_t tx_speed = le32_to_cpu(data->ULBitRate);
/* /*
* Currently the USB-NET API does not support reporting the actual * Currently the USB-NET API does not support reporting the actual
@ -1092,7 +1159,7 @@ static void cdc_ncm_status(struct usbnet *dev, struct urb *urb)
/* test for split data in 8-byte chunks */ /* test for split data in 8-byte chunks */
if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) { if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) {
cdc_ncm_speed_change(ctx, cdc_ncm_speed_change(ctx,
(struct connection_speed_change *)urb->transfer_buffer); (struct usb_cdc_speed_change *)urb->transfer_buffer);
return; return;
} }
@ -1120,12 +1187,12 @@ static void cdc_ncm_status(struct usbnet *dev, struct urb *urb)
break; break;
case USB_CDC_NOTIFY_SPEED_CHANGE: case USB_CDC_NOTIFY_SPEED_CHANGE:
if (urb->actual_length < if (urb->actual_length < (sizeof(*event) +
(sizeof(*event) + sizeof(struct connection_speed_change))) sizeof(struct usb_cdc_speed_change)))
set_bit(EVENT_STS_SPLIT, &dev->flags); set_bit(EVENT_STS_SPLIT, &dev->flags);
else else
cdc_ncm_speed_change(ctx, cdc_ncm_speed_change(ctx,
(struct connection_speed_change *) &event[1]); (struct usb_cdc_speed_change *) &event[1]);
break; break;
default: default:

2
drivers/net/wireless/ath/ath9k/ath9k.h
View File

@ -218,6 +218,7 @@ struct ath_frame_info {
struct ath_buf_state { struct ath_buf_state {
u8 bf_type; u8 bf_type;
u8 bfs_paprd; u8 bfs_paprd;
unsigned long bfs_paprd_timestamp;
enum ath9k_internal_frame_type bfs_ftype; enum ath9k_internal_frame_type bfs_ftype;
}; };
@ -600,7 +601,6 @@ struct ath_softc {
struct work_struct paprd_work; struct work_struct paprd_work;
struct work_struct hw_check_work; struct work_struct hw_check_work;
struct completion paprd_complete; struct completion paprd_complete;
bool paprd_pending;
unsigned int hw_busy_count; unsigned int hw_busy_count;

2
drivers/net/wireless/ath/ath9k/main.c
View File

@ -342,7 +342,6 @@ static bool ath_paprd_send_frame(struct ath_softc *sc, struct sk_buff *skb, int
tx_info->control.rates[1].idx = -1; tx_info->control.rates[1].idx = -1;
init_completion(&sc->paprd_complete); init_completion(&sc->paprd_complete);
sc->paprd_pending = true;
txctl.paprd = BIT(chain); txctl.paprd = BIT(chain);
if (ath_tx_start(hw, skb, &txctl) != 0) { if (ath_tx_start(hw, skb, &txctl) != 0) {
@ -353,7 +352,6 @@ static bool ath_paprd_send_frame(struct ath_softc *sc, struct sk_buff *skb, int
time_left = wait_for_completion_timeout(&sc->paprd_complete, time_left = wait_for_completion_timeout(&sc->paprd_complete,
msecs_to_jiffies(ATH_PAPRD_TIMEOUT)); msecs_to_jiffies(ATH_PAPRD_TIMEOUT));
sc->paprd_pending = false;
if (!time_left) if (!time_left)
ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CALIBRATE, ath_dbg(ath9k_hw_common(sc->sc_ah), ATH_DBG_CALIBRATE,

7
drivers/net/wireless/ath/ath9k/xmit.c
View File

@ -1752,6 +1752,9 @@ static void ath_tx_start_dma(struct ath_softc *sc, struct ath_buf *bf,
ar9003_hw_set_paprd_txdesc(sc->sc_ah, bf->bf_desc, ar9003_hw_set_paprd_txdesc(sc->sc_ah, bf->bf_desc,
bf->bf_state.bfs_paprd); bf->bf_state.bfs_paprd);
if (txctl->paprd)
bf->bf_state.bfs_paprd_timestamp = jiffies;
ath_tx_send_normal(sc, txctl->txq, tid, &bf_head); ath_tx_send_normal(sc, txctl->txq, tid, &bf_head);
} }
@ -1909,7 +1912,9 @@ static void ath_tx_complete_buf(struct ath_softc *sc, struct ath_buf *bf,
bf->bf_buf_addr = 0; bf->bf_buf_addr = 0;
if (bf->bf_state.bfs_paprd) { if (bf->bf_state.bfs_paprd) {
if (!sc->paprd_pending) if (time_after(jiffies,
bf->bf_state.bfs_paprd_timestamp +
msecs_to_jiffies(ATH_PAPRD_TIMEOUT)))
dev_kfree_skb_any(skb); dev_kfree_skb_any(skb);
else else
complete(&sc->paprd_complete); complete(&sc->paprd_complete);

2
drivers/net/wireless/ath/carl9170/rx.c
View File

@ -564,7 +564,7 @@ static void carl9170_ps_beacon(struct ar9170 *ar, void *data, unsigned int len)
cam = ieee80211_check_tim(tim_ie, tim_len, ar->common.curaid); cam = ieee80211_check_tim(tim_ie, tim_len, ar->common.curaid);
/* 2. Maybe the AP wants to send multicast/broadcast data? */ /* 2. Maybe the AP wants to send multicast/broadcast data? */
cam = !!(tim_ie->bitmap_ctrl & 0x01); cam |= !!(tim_ie->bitmap_ctrl & 0x01);
if (!cam) { if (!cam) {
/* back to low-power land. */ /* back to low-power land. */

2
drivers/net/wireless/iwlwifi/iwl-6000.c
View File

@ -678,6 +678,8 @@ struct iwl_cfg iwl6000i_2bg_cfg = {
.fw_name_pre = IWL6050_FW_PRE, \ .fw_name_pre = IWL6050_FW_PRE, \
.ucode_api_max = IWL6050_UCODE_API_MAX, \ .ucode_api_max = IWL6050_UCODE_API_MAX, \
.ucode_api_min = IWL6050_UCODE_API_MIN, \ .ucode_api_min = IWL6050_UCODE_API_MIN, \
.valid_tx_ant = ANT_AB, /* .cfg overwrite */ \
.valid_rx_ant = ANT_AB, /* .cfg overwrite */ \
.ops = &iwl6050_ops, \ .ops = &iwl6050_ops, \
.eeprom_ver = EEPROM_6050_EEPROM_VERSION, \ .eeprom_ver = EEPROM_6050_EEPROM_VERSION, \
.eeprom_calib_ver = EEPROM_6050_TX_POWER_VERSION, \ .eeprom_calib_ver = EEPROM_6050_TX_POWER_VERSION, \

6
drivers/net/wireless/iwlwifi/iwl-agn.c
View File

@ -1183,6 +1183,9 @@ static void iwl_irq_tasklet_legacy(struct iwl_priv *priv)
/* only Re-enable if disabled by irq */ /* only Re-enable if disabled by irq */
if (test_bit(STATUS_INT_ENABLED, &priv->status)) if (test_bit(STATUS_INT_ENABLED, &priv->status))
iwl_enable_interrupts(priv); iwl_enable_interrupts(priv);
/* Re-enable RF_KILL if it occurred */
else if (handled & CSR_INT_BIT_RF_KILL)
iwl_enable_rfkill_int(priv);
#ifdef CONFIG_IWLWIFI_DEBUG #ifdef CONFIG_IWLWIFI_DEBUG
if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) { if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
@ -1397,6 +1400,9 @@ static void iwl_irq_tasklet(struct iwl_priv *priv)
/* only Re-enable if disabled by irq */ /* only Re-enable if disabled by irq */
if (test_bit(STATUS_INT_ENABLED, &priv->status)) if (test_bit(STATUS_INT_ENABLED, &priv->status))
iwl_enable_interrupts(priv); iwl_enable_interrupts(priv);
/* Re-enable RF_KILL if it occurred */
else if (handled & CSR_INT_BIT_RF_KILL)
iwl_enable_rfkill_int(priv);
} }
/* the threshold ratio of actual_ack_cnt to expected_ack_cnt in percent */ /* the threshold ratio of actual_ack_cnt to expected_ack_cnt in percent */

3
drivers/net/wireless/wl1251/main.c
View File

@ -1050,6 +1050,9 @@ static void wl1251_op_bss_info_changed(struct ieee80211_hw *hw,
if (changed & BSS_CHANGED_BEACON) { if (changed & BSS_CHANGED_BEACON) {
beacon = ieee80211_beacon_get(hw, vif); beacon = ieee80211_beacon_get(hw, vif);
if (!beacon)
goto out_sleep;
ret = wl1251_cmd_template_set(wl, CMD_BEACON, beacon->data, ret = wl1251_cmd_template_set(wl, CMD_BEACON, beacon->data,
beacon->len); beacon->len);

2
drivers/ssb/pcmcia.c
View File

@ -733,7 +733,7 @@ int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
/* Fetch the vendor specific tuples. */ /* Fetch the vendor specific tuples. */
res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS, res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS,
ssb_pcmcia_do_get_invariants, sprom); ssb_pcmcia_do_get_invariants, iv);
if ((res == 0) || (res == -ENOSPC)) if ((res == 0) || (res == -ENOSPC))
return 0; return 0;

23
include/linux/usb/cdc.h
View File

@ -89,7 +89,7 @@ struct usb_cdc_acm_descriptor {
#define USB_CDC_COMM_FEATURE 0x01 #define USB_CDC_COMM_FEATURE 0x01
#define USB_CDC_CAP_LINE 0x02 #define USB_CDC_CAP_LINE 0x02
#define USB_CDC_CAP_BRK 0x04 #define USB_CDC_CAP_BRK 0x04
#define USB_CDC_CAP_NOTIFY 0x08 #define USB_CDC_CAP_NOTIFY 0x08
/* "Union Functional Descriptor" from CDC spec 5.2.3.8 */ /* "Union Functional Descriptor" from CDC spec 5.2.3.8 */
@ -271,6 +271,11 @@ struct usb_cdc_notification {
__le16 wLength; __le16 wLength;
} __attribute__ ((packed)); } __attribute__ ((packed));
struct usb_cdc_speed_change {
__le32 DLBitRRate; /* contains the downlink bit rate (IN pipe) */
__le32 ULBitRate; /* contains the uplink bit rate (OUT pipe) */
} __attribute__ ((packed));
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/* /*
@ -292,7 +297,7 @@ struct usb_cdc_ncm_ntb_parameters {
__le16 wNdpOutDivisor; __le16 wNdpOutDivisor;
__le16 wNdpOutPayloadRemainder; __le16 wNdpOutPayloadRemainder;
__le16 wNdpOutAlignment; __le16 wNdpOutAlignment;
__le16 wPadding2; __le16 wNtbOutMaxDatagrams;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* /*
@ -307,7 +312,7 @@ struct usb_cdc_ncm_nth16 {
__le16 wHeaderLength; __le16 wHeaderLength;
__le16 wSequence; __le16 wSequence;
__le16 wBlockLength; __le16 wBlockLength;
__le16 wFpIndex; __le16 wNdpIndex;
} __attribute__ ((packed)); } __attribute__ ((packed));
struct usb_cdc_ncm_nth32 { struct usb_cdc_ncm_nth32 {
@ -315,7 +320,7 @@ struct usb_cdc_ncm_nth32 {
__le16 wHeaderLength; __le16 wHeaderLength;
__le16 wSequence; __le16 wSequence;
__le32 dwBlockLength; __le32 dwBlockLength;
__le32 dwFpIndex; __le32 dwNdpIndex;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* /*
@ -337,7 +342,7 @@ struct usb_cdc_ncm_dpe16 {
struct usb_cdc_ncm_ndp16 { struct usb_cdc_ncm_ndp16 {
__le32 dwSignature; __le32 dwSignature;
__le16 wLength; __le16 wLength;
__le16 wNextFpIndex; __le16 wNextNdpIndex;
struct usb_cdc_ncm_dpe16 dpe16[0]; struct usb_cdc_ncm_dpe16 dpe16[0];
} __attribute__ ((packed)); } __attribute__ ((packed));
@ -375,6 +380,7 @@ struct usb_cdc_ncm_ndp32 {
#define USB_CDC_NCM_NCAP_ENCAP_COMMAND (1 << 2) #define USB_CDC_NCM_NCAP_ENCAP_COMMAND (1 << 2)
#define USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE (1 << 3) #define USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE (1 << 3)
#define USB_CDC_NCM_NCAP_CRC_MODE (1 << 4) #define USB_CDC_NCM_NCAP_CRC_MODE (1 << 4)
#define USB_CDC_NCM_NCAP_NTB_INPUT_SIZE (1 << 5)
/* CDC NCM subclass Table 6-3: NTB Parameter Structure */ /* CDC NCM subclass Table 6-3: NTB Parameter Structure */
#define USB_CDC_NCM_NTB16_SUPPORTED (1 << 0) #define USB_CDC_NCM_NTB16_SUPPORTED (1 << 0)
@ -392,6 +398,13 @@ struct usb_cdc_ncm_ndp32 {
#define USB_CDC_NCM_NTB_MIN_IN_SIZE 2048 #define USB_CDC_NCM_NTB_MIN_IN_SIZE 2048
#define USB_CDC_NCM_NTB_MIN_OUT_SIZE 2048 #define USB_CDC_NCM_NTB_MIN_OUT_SIZE 2048
/* NTB Input Size Structure */
struct usb_cdc_ncm_ndp_input_size {
__le32 dwNtbInMaxSize;
__le16 wNtbInMaxDatagrams;
__le16 wReserved;
} __attribute__ ((packed));
/* CDC NCM subclass 6.2.11 SetCrcMode */ /* CDC NCM subclass 6.2.11 SetCrcMode */
#define USB_CDC_NCM_CRC_NOT_APPENDED 0x00 #define USB_CDC_NCM_CRC_NOT_APPENDED 0x00
#define USB_CDC_NCM_CRC_APPENDED 0x01 #define USB_CDC_NCM_CRC_APPENDED 0x01

15
net/batman-adv/unicast.c
View File

@ -50,12 +50,12 @@ static struct sk_buff *frag_merge_packet(struct list_head *head,
skb = tfp->skb; skb = tfp->skb;
} }
if (skb_linearize(skb) < 0 || skb_linearize(tmp_skb) < 0)
goto err;
skb_pull(tmp_skb, sizeof(struct unicast_frag_packet)); skb_pull(tmp_skb, sizeof(struct unicast_frag_packet));
if (pskb_expand_head(skb, 0, tmp_skb->len, GFP_ATOMIC) < 0) { if (pskb_expand_head(skb, 0, tmp_skb->len, GFP_ATOMIC) < 0)
/* free buffered skb, skb will be freed later */ goto err;
kfree_skb(tfp->skb);
return NULL;
}
/* move free entry to end */ /* move free entry to end */
tfp->skb = NULL; tfp->skb = NULL;
@ -70,6 +70,11 @@ static struct sk_buff *frag_merge_packet(struct list_head *head,
unicast_packet->packet_type = BAT_UNICAST; unicast_packet->packet_type = BAT_UNICAST;
return skb; return skb;
err:
/* free buffered skb, skb will be freed later */
kfree_skb(tfp->skb);
return NULL;
} }
static void frag_create_entry(struct list_head *head, struct sk_buff *skb) static void frag_create_entry(struct list_head *head, struct sk_buff *skb)

4
net/caif/chnl_net.c
View File

@ -394,9 +394,7 @@ static void ipcaif_net_setup(struct net_device *dev)
priv->conn_req.sockaddr.u.dgm.connection_id = -1; priv->conn_req.sockaddr.u.dgm.connection_id = -1;
priv->flowenabled = false; priv->flowenabled = false;
ASSERT_RTNL();
init_waitqueue_head(&priv->netmgmt_wq); init_waitqueue_head(&priv->netmgmt_wq);
list_add(&priv->list_field, &chnl_net_list);
} }
@ -453,6 +451,8 @@ static int ipcaif_newlink(struct net *src_net, struct net_device *dev,
ret = register_netdevice(dev); ret = register_netdevice(dev);
if (ret) if (ret)
pr_warn("device rtml registration failed\n"); pr_warn("device rtml registration failed\n");
else
list_add(&caifdev->list_field, &chnl_net_list);
return ret; return ret;
} }

29
net/core/dev.c
View File

@ -5807,18 +5807,6 @@ struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
dev_net_set(dev, &init_net); dev_net_set(dev, &init_net);
dev->num_tx_queues = txqs;
dev->real_num_tx_queues = txqs;
if (netif_alloc_netdev_queues(dev))
goto free_pcpu;
#ifdef CONFIG_RPS
dev->num_rx_queues = rxqs;
dev->real_num_rx_queues = rxqs;
if (netif_alloc_rx_queues(dev))
goto free_pcpu;
#endif
dev->gso_max_size = GSO_MAX_SIZE; dev->gso_max_size = GSO_MAX_SIZE;
INIT_LIST_HEAD(&dev->ethtool_ntuple_list.list); INIT_LIST_HEAD(&dev->ethtool_ntuple_list.list);
@ -5828,10 +5816,27 @@ struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
INIT_LIST_HEAD(&dev->link_watch_list); INIT_LIST_HEAD(&dev->link_watch_list);
dev->priv_flags = IFF_XMIT_DST_RELEASE; dev->priv_flags = IFF_XMIT_DST_RELEASE;
setup(dev); setup(dev);
dev->num_tx_queues = txqs;
dev->real_num_tx_queues = txqs;
if (netif_alloc_netdev_queues(dev))
goto free_all;
#ifdef CONFIG_RPS
dev->num_rx_queues = rxqs;
dev->real_num_rx_queues = rxqs;
if (netif_alloc_rx_queues(dev))
goto free_all;
#endif
strcpy(dev->name, name); strcpy(dev->name, name);
dev->group = INIT_NETDEV_GROUP; dev->group = INIT_NETDEV_GROUP;
return dev; return dev;
free_all:
free_netdev(dev);
return NULL;
free_pcpu: free_pcpu:
free_percpu(dev->pcpu_refcnt); free_percpu(dev->pcpu_refcnt);
kfree(dev->_tx); kfree(dev->_tx);

2
net/mac80211/cfg.c
View File

@ -1838,6 +1838,7 @@ static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct net_device *dev,
*cookie ^= 2; *cookie ^= 2;
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN; IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN;
local->hw_roc_skb = skb; local->hw_roc_skb = skb;
local->hw_roc_skb_for_status = skb;
mutex_unlock(&local->mtx); mutex_unlock(&local->mtx);
return 0; return 0;
@ -1891,6 +1892,7 @@ static int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
if (ret == 0) { if (ret == 0) {
kfree_skb(local->hw_roc_skb); kfree_skb(local->hw_roc_skb);
local->hw_roc_skb = NULL; local->hw_roc_skb = NULL;
local->hw_roc_skb_for_status = NULL;
} }
mutex_unlock(&local->mtx); mutex_unlock(&local->mtx);

2
net/mac80211/ieee80211_i.h
View File

@ -951,7 +951,7 @@ struct ieee80211_local {
struct ieee80211_channel *hw_roc_channel; struct ieee80211_channel *hw_roc_channel;
struct net_device *hw_roc_dev; struct net_device *hw_roc_dev;
struct sk_buff *hw_roc_skb; struct sk_buff *hw_roc_skb, *hw_roc_skb_for_status;
struct work_struct hw_roc_start, hw_roc_done; struct work_struct hw_roc_start, hw_roc_done;
enum nl80211_channel_type hw_roc_channel_type; enum nl80211_channel_type hw_roc_channel_type;
unsigned int hw_roc_duration; unsigned int hw_roc_duration;

7
net/mac80211/status.c
View File

@ -327,6 +327,7 @@ void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
if (info->flags & IEEE80211_TX_INTFL_NL80211_FRAME_TX) { if (info->flags & IEEE80211_TX_INTFL_NL80211_FRAME_TX) {
struct ieee80211_work *wk; struct ieee80211_work *wk;
u64 cookie = (unsigned long)skb;
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(wk, &local->work_list, list) { list_for_each_entry_rcu(wk, &local->work_list, list) {
@ -338,8 +339,12 @@ void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
break; break;
} }
rcu_read_unlock(); rcu_read_unlock();
if (local->hw_roc_skb_for_status == skb) {
cookie = local->hw_roc_cookie ^ 2;
local->hw_roc_skb_for_status = NULL;
}
cfg80211_mgmt_tx_status( cfg80211_mgmt_tx_status(
skb->dev, (unsigned long) skb, skb->data, skb->len, skb->dev, cookie, skb->data, skb->len,
!!(info->flags & IEEE80211_TX_STAT_ACK), GFP_ATOMIC); !!(info->flags & IEEE80211_TX_STAT_ACK), GFP_ATOMIC);
} }

2
net/mac80211/tx.c
View File

@ -1549,7 +1549,7 @@ static int ieee80211_skb_resize(struct ieee80211_local *local,
skb_orphan(skb); skb_orphan(skb);
} }
if (skb_header_cloned(skb)) if (skb_cloned(skb))
I802_DEBUG_INC(local->tx_expand_skb_head_cloned); I802_DEBUG_INC(local->tx_expand_skb_head_cloned);
else if (head_need || tail_need) else if (head_need || tail_need)
I802_DEBUG_INC(local->tx_expand_skb_head); I802_DEBUG_INC(local->tx_expand_skb_head);

28
net/x25/x25_facilities.c
View File

@ -27,9 +27,19 @@
#include <net/sock.h> #include <net/sock.h>
#include <net/x25.h> #include <net/x25.h>
/* /**
* Parse a set of facilities into the facilities structures. Unrecognised * x25_parse_facilities - Parse facilities from skb into the facilities structs
* facilities are written to the debug log file. *
* @skb: sk_buff to parse
* @facilities: Regular facilites, updated as facilities are found
* @dte_facs: ITU DTE facilities, updated as DTE facilities are found
* @vc_fac_mask: mask is updated with all facilities found
*
* Return codes:
* -1 - Parsing error, caller should drop call and clean up
* 0 - Parse OK, this skb has no facilities
* >0 - Parse OK, returns the length of the facilities header
*
*/ */
int x25_parse_facilities(struct sk_buff *skb, struct x25_facilities *facilities, int x25_parse_facilities(struct sk_buff *skb, struct x25_facilities *facilities,
struct x25_dte_facilities *dte_facs, unsigned long *vc_fac_mask) struct x25_dte_facilities *dte_facs, unsigned long *vc_fac_mask)
@ -62,7 +72,7 @@ int x25_parse_facilities(struct sk_buff *skb, struct x25_facilities *facilities,
switch (*p & X25_FAC_CLASS_MASK) { switch (*p & X25_FAC_CLASS_MASK) {
case X25_FAC_CLASS_A: case X25_FAC_CLASS_A:
if (len < 2) if (len < 2)
return 0; return -1;
switch (*p) { switch (*p) {
case X25_FAC_REVERSE: case X25_FAC_REVERSE:
if((p[1] & 0x81) == 0x81) { if((p[1] & 0x81) == 0x81) {
@ -107,7 +117,7 @@ int x25_parse_facilities(struct sk_buff *skb, struct x25_facilities *facilities,
break; break;
case X25_FAC_CLASS_B: case X25_FAC_CLASS_B:
if (len < 3) if (len < 3)
return 0; return -1;
switch (*p) { switch (*p) {
case X25_FAC_PACKET_SIZE: case X25_FAC_PACKET_SIZE:
facilities->pacsize_in = p[1]; facilities->pacsize_in = p[1];
@ -130,7 +140,7 @@ int x25_parse_facilities(struct sk_buff *skb, struct x25_facilities *facilities,
break; break;
case X25_FAC_CLASS_C: case X25_FAC_CLASS_C:
if (len < 4) if (len < 4)
return 0; return -1;
printk(KERN_DEBUG "X.25: unknown facility %02X, " printk(KERN_DEBUG "X.25: unknown facility %02X, "
"values %02X, %02X, %02X\n", "values %02X, %02X, %02X\n",
p[0], p[1], p[2], p[3]); p[0], p[1], p[2], p[3]);
@ -139,18 +149,18 @@ int x25_parse_facilities(struct sk_buff *skb, struct x25_facilities *facilities,
break; break;
case X25_FAC_CLASS_D: case X25_FAC_CLASS_D:
if (len < p[1] + 2) if (len < p[1] + 2)
return 0; return -1;
switch (*p) { switch (*p) {
case X25_FAC_CALLING_AE: case X25_FAC_CALLING_AE:
if (p[1] > X25_MAX_DTE_FACIL_LEN || p[1] <= 1) if (p[1] > X25_MAX_DTE_FACIL_LEN || p[1] <= 1)
return 0; return -1;
dte_facs->calling_len = p[2]; dte_facs->calling_len = p[2];
memcpy(dte_facs->calling_ae, &p[3], p[1] - 1); memcpy(dte_facs->calling_ae, &p[3], p[1] - 1);
*vc_fac_mask |= X25_MASK_CALLING_AE; *vc_fac_mask |= X25_MASK_CALLING_AE;
break; break;
case X25_FAC_CALLED_AE: case X25_FAC_CALLED_AE:
if (p[1] > X25_MAX_DTE_FACIL_LEN || p[1] <= 1) if (p[1] > X25_MAX_DTE_FACIL_LEN || p[1] <= 1)
return 0; return -1;
dte_facs->called_len = p[2]; dte_facs->called_len = p[2];
memcpy(dte_facs->called_ae, &p[3], p[1] - 1); memcpy(dte_facs->called_ae, &p[3], p[1] - 1);
*vc_fac_mask |= X25_MASK_CALLED_AE; *vc_fac_mask |= X25_MASK_CALLED_AE;

14
net/x25/x25_in.c
View File

@ -91,10 +91,10 @@ static int x25_state1_machine(struct sock *sk, struct sk_buff *skb, int frametyp
{ {
struct x25_address source_addr, dest_addr; struct x25_address source_addr, dest_addr;
int len; int len;
struct x25_sock *x25 = x25_sk(sk);
switch (frametype) { switch (frametype) {
case X25_CALL_ACCEPTED: { case X25_CALL_ACCEPTED: {
struct x25_sock *x25 = x25_sk(sk);
x25_stop_timer(sk); x25_stop_timer(sk);
x25->condition = 0x00; x25->condition = 0x00;
@ -113,14 +113,16 @@ static int x25_state1_machine(struct sock *sk, struct sk_buff *skb, int frametyp
&dest_addr); &dest_addr);
if (len > 0) if (len > 0)
skb_pull(skb, len); skb_pull(skb, len);
else if (len < 0)
goto out_clear;
len = x25_parse_facilities(skb, &x25->facilities, len = x25_parse_facilities(skb, &x25->facilities,
&x25->dte_facilities, &x25->dte_facilities,
&x25->vc_facil_mask); &x25->vc_facil_mask);
if (len > 0) if (len > 0)
skb_pull(skb, len); skb_pull(skb, len);
else else if (len < 0)
return -1; goto out_clear;
/* /*
* Copy any Call User Data. * Copy any Call User Data.
*/ */
@ -144,6 +146,12 @@ static int x25_state1_machine(struct sock *sk, struct sk_buff *skb, int frametyp
} }
return 0; return 0;
out_clear:
x25_write_internal(sk, X25_CLEAR_REQUEST);
x25->state = X25_STATE_2;
x25_start_t23timer(sk);
return 0;
} }
/* /*