mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-27 04:47:05 +00:00
net/usb/r8152: support aggregation
Enable the tx/rx aggregation which could contain one or more packets for each bulk in/out. This could reduce the loading of the host controller by sending less bulk transfer. The rx packets in the bulk in buffer should be 8-byte aligned, and the tx packets in the bulk out buffer should be 4-byte aligned. Signed-off-by: Hayes Wang <hayeswang@realtek.com> Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
hayeswang
David S. Miller
parent
fce9b9be89
commit
ebc2ec484d
1 changed files with 495 additions and 170 deletions
|
|
@ -19,9 +19,10 @@
|
|||
#include <linux/crc32.h>
|
||||
#include <linux/if_vlan.h>
|
||||
#include <linux/uaccess.h>
|
||||
#include <linux/list.h>
|
||||
|
||||
/* Version Information */
|
||||
#define DRIVER_VERSION "v1.0.0 (2013/05/03)"
|
||||
#define DRIVER_VERSION "v1.01.0 (2013/08/12)"
|
||||
#define DRIVER_AUTHOR "Realtek linux nic maintainers <nic_swsd@realtek.com>"
|
||||
#define DRIVER_DESC "Realtek RTL8152 Based USB 2.0 Ethernet Adapters"
|
||||
#define MODULENAME "r8152"
|
||||
|
|
@ -267,6 +268,9 @@ enum rtl_register_content {
|
|||
FULL_DUP = 0x01,
|
||||
};
|
||||
|
||||
#define RTL8152_MAX_TX 10
|
||||
#define RTL8152_MAX_RX 10
|
||||
|
||||
#define RTL8152_REQT_READ 0xc0
|
||||
#define RTL8152_REQT_WRITE 0x40
|
||||
#define RTL8152_REQ_GET_REGS 0x05
|
||||
|
|
@ -285,7 +289,6 @@ enum rtl_register_content {
|
|||
/* rtl8152 flags */
|
||||
enum rtl8152_flags {
|
||||
RTL8152_UNPLUG = 0,
|
||||
RX_URB_FAIL,
|
||||
RTL8152_SET_RX_MODE,
|
||||
WORK_ENABLE
|
||||
};
|
||||
|
|
@ -315,13 +318,34 @@ struct tx_desc {
|
|||
u32 opts2;
|
||||
};
|
||||
|
||||
struct rx_agg {
|
||||
struct list_head list;
|
||||
struct urb *urb;
|
||||
void *context;
|
||||
void *buffer;
|
||||
void *head;
|
||||
};
|
||||
|
||||
struct tx_agg {
|
||||
struct list_head list;
|
||||
struct urb *urb;
|
||||
void *context;
|
||||
void *buffer;
|
||||
void *head;
|
||||
u32 skb_num;
|
||||
u32 skb_len;
|
||||
};
|
||||
|
||||
struct r8152 {
|
||||
unsigned long flags;
|
||||
struct usb_device *udev;
|
||||
struct tasklet_struct tl;
|
||||
struct net_device *netdev;
|
||||
struct urb *rx_urb, *tx_urb;
|
||||
struct sk_buff *tx_skb, *rx_skb;
|
||||
struct tx_agg tx_info[RTL8152_MAX_TX];
|
||||
struct rx_agg rx_info[RTL8152_MAX_RX];
|
||||
struct list_head rx_done, tx_free;
|
||||
struct sk_buff_head tx_queue;
|
||||
spinlock_t rx_lock, tx_lock;
|
||||
struct delayed_work schedule;
|
||||
struct mii_if_info mii;
|
||||
u32 msg_enable;
|
||||
|
|
@ -340,6 +364,7 @@ enum rtl_version {
|
|||
* The RTL chips use a 64 element hash table based on the Ethernet CRC.
|
||||
*/
|
||||
static const int multicast_filter_limit = 32;
|
||||
static unsigned int rx_buf_sz = 16384;
|
||||
|
||||
static
|
||||
int get_registers(struct r8152 *tp, u16 value, u16 index, u16 size, void *data)
|
||||
|
|
@ -686,6 +711,9 @@ static void ocp_reg_write(struct r8152 *tp, u16 addr, u16 data)
|
|||
ocp_write_word(tp, MCU_TYPE_PLA, ocp_index, data);
|
||||
}
|
||||
|
||||
static
|
||||
int r8152_submit_rx(struct r8152 *tp, struct rx_agg *agg, gfp_t mem_flags);
|
||||
|
||||
static inline void set_ethernet_addr(struct r8152 *tp)
|
||||
{
|
||||
struct net_device *dev = tp->netdev;
|
||||
|
|
@ -716,26 +744,6 @@ static int rtl8152_set_mac_address(struct net_device *netdev, void *p)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int alloc_all_urbs(struct r8152 *tp)
|
||||
{
|
||||
tp->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
|
||||
if (!tp->rx_urb)
|
||||
return 0;
|
||||
tp->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
|
||||
if (!tp->tx_urb) {
|
||||
usb_free_urb(tp->rx_urb);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void free_all_urbs(struct r8152 *tp)
|
||||
{
|
||||
usb_free_urb(tp->rx_urb);
|
||||
usb_free_urb(tp->tx_urb);
|
||||
}
|
||||
|
||||
static struct net_device_stats *rtl8152_get_stats(struct net_device *dev)
|
||||
{
|
||||
return &dev->stats;
|
||||
|
|
@ -743,129 +751,425 @@ static struct net_device_stats *rtl8152_get_stats(struct net_device *dev)
|
|||
|
||||
static void read_bulk_callback(struct urb *urb)
|
||||
{
|
||||
struct r8152 *tp;
|
||||
unsigned pkt_len;
|
||||
struct sk_buff *skb;
|
||||
struct net_device *netdev;
|
||||
struct net_device_stats *stats;
|
||||
unsigned long lockflags;
|
||||
int status = urb->status;
|
||||
struct rx_agg *agg;
|
||||
struct r8152 *tp;
|
||||
int result;
|
||||
struct rx_desc *rx_desc;
|
||||
|
||||
tp = urb->context;
|
||||
agg = urb->context;
|
||||
if (!agg)
|
||||
return;
|
||||
|
||||
tp = agg->context;
|
||||
if (!tp)
|
||||
return;
|
||||
|
||||
if (test_bit(RTL8152_UNPLUG, &tp->flags))
|
||||
return;
|
||||
netdev = tp->netdev;
|
||||
if (!netif_device_present(netdev))
|
||||
|
||||
if (!test_bit(WORK_ENABLE, &tp->flags))
|
||||
return;
|
||||
|
||||
netdev = tp->netdev;
|
||||
if (!netif_carrier_ok(netdev))
|
||||
return;
|
||||
|
||||
stats = rtl8152_get_stats(netdev);
|
||||
switch (status) {
|
||||
case 0:
|
||||
break;
|
||||
if (urb->actual_length < ETH_ZLEN)
|
||||
break;
|
||||
|
||||
spin_lock_irqsave(&tp->rx_lock, lockflags);
|
||||
list_add_tail(&agg->list, &tp->rx_done);
|
||||
spin_unlock_irqrestore(&tp->rx_lock, lockflags);
|
||||
tasklet_schedule(&tp->tl);
|
||||
return;
|
||||
case -ESHUTDOWN:
|
||||
set_bit(RTL8152_UNPLUG, &tp->flags);
|
||||
netif_device_detach(tp->netdev);
|
||||
return;
|
||||
case -ENOENT:
|
||||
return; /* the urb is in unlink state */
|
||||
case -ETIME:
|
||||
pr_warn_ratelimited("may be reset is needed?..\n");
|
||||
goto goon;
|
||||
break;
|
||||
default:
|
||||
pr_warn_ratelimited("Rx status %d\n", status);
|
||||
goto goon;
|
||||
break;
|
||||
}
|
||||
|
||||
/* protect against short packets (tell me why we got some?!?) */
|
||||
if (urb->actual_length < sizeof(*rx_desc))
|
||||
goto goon;
|
||||
|
||||
|
||||
rx_desc = (struct rx_desc *)urb->transfer_buffer;
|
||||
pkt_len = le32_to_cpu(rx_desc->opts1) & RX_LEN_MASK;
|
||||
if (urb->actual_length < sizeof(struct rx_desc) + pkt_len)
|
||||
goto goon;
|
||||
|
||||
skb = netdev_alloc_skb_ip_align(netdev, pkt_len);
|
||||
if (!skb)
|
||||
goto goon;
|
||||
|
||||
memcpy(skb->data, tp->rx_skb->data + sizeof(struct rx_desc), pkt_len);
|
||||
skb_put(skb, pkt_len);
|
||||
skb->protocol = eth_type_trans(skb, netdev);
|
||||
netif_rx(skb);
|
||||
stats->rx_packets++;
|
||||
stats->rx_bytes += pkt_len;
|
||||
goon:
|
||||
usb_fill_bulk_urb(tp->rx_urb, tp->udev, usb_rcvbulkpipe(tp->udev, 1),
|
||||
tp->rx_skb->data, RTL8152_RMS + sizeof(struct rx_desc),
|
||||
(usb_complete_t)read_bulk_callback, tp);
|
||||
result = usb_submit_urb(tp->rx_urb, GFP_ATOMIC);
|
||||
result = r8152_submit_rx(tp, agg, GFP_ATOMIC);
|
||||
if (result == -ENODEV) {
|
||||
netif_device_detach(tp->netdev);
|
||||
} else if (result) {
|
||||
set_bit(RX_URB_FAIL, &tp->flags);
|
||||
goto resched;
|
||||
} else {
|
||||
clear_bit(RX_URB_FAIL, &tp->flags);
|
||||
spin_lock_irqsave(&tp->rx_lock, lockflags);
|
||||
list_add_tail(&agg->list, &tp->rx_done);
|
||||
spin_unlock_irqrestore(&tp->rx_lock, lockflags);
|
||||
tasklet_schedule(&tp->tl);
|
||||
}
|
||||
|
||||
return;
|
||||
resched:
|
||||
tasklet_schedule(&tp->tl);
|
||||
}
|
||||
|
||||
static void rx_fixup(unsigned long data)
|
||||
{
|
||||
struct r8152 *tp;
|
||||
int status;
|
||||
|
||||
tp = (struct r8152 *)data;
|
||||
if (!test_bit(WORK_ENABLE, &tp->flags))
|
||||
return;
|
||||
|
||||
status = usb_submit_urb(tp->rx_urb, GFP_ATOMIC);
|
||||
if (status == -ENODEV) {
|
||||
netif_device_detach(tp->netdev);
|
||||
} else if (status) {
|
||||
set_bit(RX_URB_FAIL, &tp->flags);
|
||||
goto tlsched;
|
||||
} else {
|
||||
clear_bit(RX_URB_FAIL, &tp->flags);
|
||||
}
|
||||
|
||||
return;
|
||||
tlsched:
|
||||
tasklet_schedule(&tp->tl);
|
||||
}
|
||||
|
||||
static void write_bulk_callback(struct urb *urb)
|
||||
{
|
||||
struct net_device_stats *stats;
|
||||
unsigned long lockflags;
|
||||
struct tx_agg *agg;
|
||||
struct r8152 *tp;
|
||||
int status = urb->status;
|
||||
|
||||
tp = urb->context;
|
||||
agg = urb->context;
|
||||
if (!agg)
|
||||
return;
|
||||
|
||||
tp = agg->context;
|
||||
if (!tp)
|
||||
return;
|
||||
dev_kfree_skb_irq(tp->tx_skb);
|
||||
if (!netif_device_present(tp->netdev))
|
||||
|
||||
stats = rtl8152_get_stats(tp->netdev);
|
||||
if (status) {
|
||||
pr_warn_ratelimited("Tx status %d\n", status);
|
||||
stats->tx_errors += agg->skb_num;
|
||||
} else {
|
||||
stats->tx_packets += agg->skb_num;
|
||||
stats->tx_bytes += agg->skb_len;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&tp->tx_lock, lockflags);
|
||||
list_add_tail(&agg->list, &tp->tx_free);
|
||||
spin_unlock_irqrestore(&tp->tx_lock, lockflags);
|
||||
|
||||
if (!netif_carrier_ok(tp->netdev))
|
||||
return;
|
||||
if (status)
|
||||
dev_info(&urb->dev->dev, "%s: Tx status %d\n",
|
||||
tp->netdev->name, status);
|
||||
tp->netdev->trans_start = jiffies;
|
||||
netif_wake_queue(tp->netdev);
|
||||
|
||||
if (!test_bit(WORK_ENABLE, &tp->flags))
|
||||
return;
|
||||
|
||||
if (test_bit(RTL8152_UNPLUG, &tp->flags))
|
||||
return;
|
||||
|
||||
if (!skb_queue_empty(&tp->tx_queue))
|
||||
tasklet_schedule(&tp->tl);
|
||||
}
|
||||
|
||||
static inline void *rx_agg_align(void *data)
|
||||
{
|
||||
return (void *)ALIGN((uintptr_t)data, 8);
|
||||
}
|
||||
|
||||
static inline void *tx_agg_align(void *data)
|
||||
{
|
||||
return (void *)ALIGN((uintptr_t)data, 4);
|
||||
}
|
||||
|
||||
static void free_all_mem(struct r8152 *tp)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < RTL8152_MAX_RX; i++) {
|
||||
if (tp->rx_info[i].urb) {
|
||||
usb_free_urb(tp->rx_info[i].urb);
|
||||
tp->rx_info[i].urb = NULL;
|
||||
}
|
||||
|
||||
if (tp->rx_info[i].buffer) {
|
||||
kfree(tp->rx_info[i].buffer);
|
||||
tp->rx_info[i].buffer = NULL;
|
||||
tp->rx_info[i].head = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < RTL8152_MAX_TX; i++) {
|
||||
if (tp->tx_info[i].urb) {
|
||||
usb_free_urb(tp->tx_info[i].urb);
|
||||
tp->tx_info[i].urb = NULL;
|
||||
}
|
||||
|
||||
if (tp->tx_info[i].buffer) {
|
||||
kfree(tp->tx_info[i].buffer);
|
||||
tp->tx_info[i].buffer = NULL;
|
||||
tp->tx_info[i].head = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int alloc_all_mem(struct r8152 *tp)
|
||||
{
|
||||
struct net_device *netdev = tp->netdev;
|
||||
struct urb *urb;
|
||||
int node, i;
|
||||
u8 *buf;
|
||||
|
||||
node = netdev->dev.parent ? dev_to_node(netdev->dev.parent) : -1;
|
||||
|
||||
spin_lock_init(&tp->rx_lock);
|
||||
spin_lock_init(&tp->tx_lock);
|
||||
INIT_LIST_HEAD(&tp->rx_done);
|
||||
INIT_LIST_HEAD(&tp->tx_free);
|
||||
skb_queue_head_init(&tp->tx_queue);
|
||||
|
||||
for (i = 0; i < RTL8152_MAX_RX; i++) {
|
||||
buf = kmalloc_node(rx_buf_sz, GFP_KERNEL, node);
|
||||
if (!buf)
|
||||
goto err1;
|
||||
|
||||
if (buf != rx_agg_align(buf)) {
|
||||
kfree(buf);
|
||||
buf = kmalloc_node(rx_buf_sz + 8, GFP_KERNEL, node);
|
||||
if (!buf)
|
||||
goto err1;
|
||||
}
|
||||
|
||||
urb = usb_alloc_urb(0, GFP_KERNEL);
|
||||
if (!urb) {
|
||||
kfree(buf);
|
||||
goto err1;
|
||||
}
|
||||
|
||||
INIT_LIST_HEAD(&tp->rx_info[i].list);
|
||||
tp->rx_info[i].context = tp;
|
||||
tp->rx_info[i].urb = urb;
|
||||
tp->rx_info[i].buffer = buf;
|
||||
tp->rx_info[i].head = rx_agg_align(buf);
|
||||
}
|
||||
|
||||
for (i = 0; i < RTL8152_MAX_TX; i++) {
|
||||
buf = kmalloc_node(rx_buf_sz, GFP_KERNEL, node);
|
||||
if (!buf)
|
||||
goto err1;
|
||||
|
||||
if (buf != tx_agg_align(buf)) {
|
||||
kfree(buf);
|
||||
buf = kmalloc_node(rx_buf_sz + 4, GFP_KERNEL, node);
|
||||
if (!buf)
|
||||
goto err1;
|
||||
}
|
||||
|
||||
urb = usb_alloc_urb(0, GFP_KERNEL);
|
||||
if (!urb) {
|
||||
kfree(buf);
|
||||
goto err1;
|
||||
}
|
||||
|
||||
INIT_LIST_HEAD(&tp->tx_info[i].list);
|
||||
tp->tx_info[i].context = tp;
|
||||
tp->tx_info[i].urb = urb;
|
||||
tp->tx_info[i].buffer = buf;
|
||||
tp->tx_info[i].head = tx_agg_align(buf);
|
||||
|
||||
list_add_tail(&tp->tx_info[i].list, &tp->tx_free);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err1:
|
||||
free_all_mem(tp);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
static void rx_bottom(struct r8152 *tp)
|
||||
{
|
||||
struct net_device_stats *stats;
|
||||
struct net_device *netdev;
|
||||
struct rx_agg *agg;
|
||||
struct rx_desc *rx_desc;
|
||||
unsigned long lockflags;
|
||||
struct list_head *cursor, *next;
|
||||
struct sk_buff *skb;
|
||||
struct urb *urb;
|
||||
unsigned pkt_len;
|
||||
int len_used;
|
||||
u8 *rx_data;
|
||||
int ret;
|
||||
|
||||
netdev = tp->netdev;
|
||||
|
||||
stats = rtl8152_get_stats(netdev);
|
||||
|
||||
spin_lock_irqsave(&tp->rx_lock, lockflags);
|
||||
list_for_each_safe(cursor, next, &tp->rx_done) {
|
||||
list_del_init(cursor);
|
||||
spin_unlock_irqrestore(&tp->rx_lock, lockflags);
|
||||
|
||||
agg = list_entry(cursor, struct rx_agg, list);
|
||||
urb = agg->urb;
|
||||
if (urb->actual_length < ETH_ZLEN) {
|
||||
ret = r8152_submit_rx(tp, agg, GFP_ATOMIC);
|
||||
spin_lock_irqsave(&tp->rx_lock, lockflags);
|
||||
if (ret && ret != -ENODEV) {
|
||||
list_add_tail(&agg->list, next);
|
||||
tasklet_schedule(&tp->tl);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
len_used = 0;
|
||||
rx_desc = agg->head;
|
||||
rx_data = agg->head;
|
||||
pkt_len = le32_to_cpu(rx_desc->opts1) & RX_LEN_MASK;
|
||||
len_used += sizeof(struct rx_desc) + pkt_len;
|
||||
|
||||
while (urb->actual_length >= len_used) {
|
||||
if (pkt_len < ETH_ZLEN)
|
||||
break;
|
||||
|
||||
pkt_len -= 4; /* CRC */
|
||||
rx_data += sizeof(struct rx_desc);
|
||||
|
||||
skb = netdev_alloc_skb_ip_align(netdev, pkt_len);
|
||||
if (!skb) {
|
||||
stats->rx_dropped++;
|
||||
break;
|
||||
}
|
||||
memcpy(skb->data, rx_data, pkt_len);
|
||||
skb_put(skb, pkt_len);
|
||||
skb->protocol = eth_type_trans(skb, netdev);
|
||||
netif_rx(skb);
|
||||
stats->rx_packets++;
|
||||
stats->rx_bytes += pkt_len;
|
||||
|
||||
rx_data = rx_agg_align(rx_data + pkt_len + 4);
|
||||
rx_desc = (struct rx_desc *)rx_data;
|
||||
pkt_len = le32_to_cpu(rx_desc->opts1) & RX_LEN_MASK;
|
||||
len_used = (int)(rx_data - (u8 *)agg->head);
|
||||
len_used += sizeof(struct rx_desc) + pkt_len;
|
||||
}
|
||||
|
||||
ret = r8152_submit_rx(tp, agg, GFP_ATOMIC);
|
||||
spin_lock_irqsave(&tp->rx_lock, lockflags);
|
||||
if (ret && ret != -ENODEV) {
|
||||
list_add_tail(&agg->list, next);
|
||||
tasklet_schedule(&tp->tl);
|
||||
}
|
||||
}
|
||||
spin_unlock_irqrestore(&tp->rx_lock, lockflags);
|
||||
}
|
||||
|
||||
static void tx_bottom(struct r8152 *tp)
|
||||
{
|
||||
struct net_device_stats *stats;
|
||||
struct net_device *netdev;
|
||||
struct tx_agg *agg;
|
||||
unsigned long lockflags;
|
||||
u32 remain, total;
|
||||
u8 *tx_data;
|
||||
int res;
|
||||
|
||||
netdev = tp->netdev;
|
||||
|
||||
next_agg:
|
||||
agg = NULL;
|
||||
spin_lock_irqsave(&tp->tx_lock, lockflags);
|
||||
if (!skb_queue_empty(&tp->tx_queue) && !list_empty(&tp->tx_free)) {
|
||||
struct list_head *cursor;
|
||||
|
||||
cursor = tp->tx_free.next;
|
||||
list_del_init(cursor);
|
||||
agg = list_entry(cursor, struct tx_agg, list);
|
||||
}
|
||||
spin_unlock_irqrestore(&tp->tx_lock, lockflags);
|
||||
|
||||
if (!agg)
|
||||
return;
|
||||
|
||||
tx_data = agg->head;
|
||||
agg->skb_num = agg->skb_len = 0;
|
||||
remain = rx_buf_sz - sizeof(struct tx_desc);
|
||||
total = 0;
|
||||
|
||||
while (remain >= ETH_ZLEN) {
|
||||
struct tx_desc *tx_desc;
|
||||
struct sk_buff *skb;
|
||||
unsigned int len;
|
||||
|
||||
skb = skb_dequeue(&tp->tx_queue);
|
||||
if (!skb)
|
||||
break;
|
||||
|
||||
len = skb->len;
|
||||
if (remain < len) {
|
||||
skb_queue_head(&tp->tx_queue, skb);
|
||||
break;
|
||||
}
|
||||
|
||||
tx_data = tx_agg_align(tx_data);
|
||||
tx_desc = (struct tx_desc *)tx_data;
|
||||
tx_data += sizeof(*tx_desc);
|
||||
|
||||
tx_desc->opts1 = cpu_to_le32((skb->len & TX_LEN_MASK) | TX_FS |
|
||||
TX_LS);
|
||||
memcpy(tx_data, skb->data, len);
|
||||
agg->skb_num++;
|
||||
agg->skb_len += len;
|
||||
dev_kfree_skb_any(skb);
|
||||
|
||||
tx_data += len;
|
||||
remain = rx_buf_sz - sizeof(*tx_desc) -
|
||||
(u32)(tx_agg_align(tx_data) - agg->head);
|
||||
}
|
||||
|
||||
usb_fill_bulk_urb(agg->urb, tp->udev, usb_sndbulkpipe(tp->udev, 2),
|
||||
agg->head, (int)(tx_data - (u8 *)agg->head),
|
||||
(usb_complete_t)write_bulk_callback, agg);
|
||||
res = usb_submit_urb(agg->urb, GFP_ATOMIC);
|
||||
|
||||
stats = rtl8152_get_stats(netdev);
|
||||
|
||||
if (res) {
|
||||
/* Can we get/handle EPIPE here? */
|
||||
if (res == -ENODEV) {
|
||||
netif_device_detach(netdev);
|
||||
} else {
|
||||
netif_warn(tp, tx_err, netdev,
|
||||
"failed tx_urb %d\n", res);
|
||||
stats->tx_dropped += agg->skb_num;
|
||||
spin_lock_irqsave(&tp->tx_lock, lockflags);
|
||||
list_add_tail(&agg->list, &tp->tx_free);
|
||||
spin_unlock_irqrestore(&tp->tx_lock, lockflags);
|
||||
}
|
||||
return;
|
||||
}
|
||||
goto next_agg;
|
||||
}
|
||||
|
||||
static void bottom_half(unsigned long data)
|
||||
{
|
||||
struct r8152 *tp;
|
||||
|
||||
tp = (struct r8152 *)data;
|
||||
|
||||
if (test_bit(RTL8152_UNPLUG, &tp->flags))
|
||||
return;
|
||||
|
||||
if (!test_bit(WORK_ENABLE, &tp->flags))
|
||||
return;
|
||||
|
||||
if (!netif_carrier_ok(tp->netdev))
|
||||
return;
|
||||
|
||||
rx_bottom(tp);
|
||||
tx_bottom(tp);
|
||||
}
|
||||
|
||||
static
|
||||
int r8152_submit_rx(struct r8152 *tp, struct rx_agg *agg, gfp_t mem_flags)
|
||||
{
|
||||
usb_fill_bulk_urb(agg->urb, tp->udev, usb_rcvbulkpipe(tp->udev, 1),
|
||||
agg->head, rx_buf_sz,
|
||||
(usb_complete_t)read_bulk_callback, agg);
|
||||
|
||||
return usb_submit_urb(agg->urb, mem_flags);
|
||||
}
|
||||
|
||||
static void rtl8152_tx_timeout(struct net_device *netdev)
|
||||
{
|
||||
struct r8152 *tp = netdev_priv(netdev);
|
||||
struct net_device_stats *stats = rtl8152_get_stats(netdev);
|
||||
int i;
|
||||
|
||||
netif_warn(tp, tx_err, netdev, "Tx timeout.\n");
|
||||
usb_unlink_urb(tp->tx_urb);
|
||||
stats->tx_errors++;
|
||||
for (i = 0; i < RTL8152_MAX_TX; i++)
|
||||
usb_unlink_urb(tp->tx_info[i].urb);
|
||||
}
|
||||
|
||||
static void rtl8152_set_rx_mode(struct net_device *netdev)
|
||||
|
|
@ -923,33 +1227,44 @@ static netdev_tx_t rtl8152_start_xmit(struct sk_buff *skb,
|
|||
{
|
||||
struct r8152 *tp = netdev_priv(netdev);
|
||||
struct net_device_stats *stats = rtl8152_get_stats(netdev);
|
||||
unsigned long lockflags;
|
||||
struct tx_agg *agg = NULL;
|
||||
struct tx_desc *tx_desc;
|
||||
unsigned int len;
|
||||
u8 *tx_data;
|
||||
int res;
|
||||
|
||||
netif_stop_queue(netdev);
|
||||
len = skb->len;
|
||||
if (skb_header_cloned(skb) || skb_headroom(skb) < sizeof(*tx_desc)) {
|
||||
struct sk_buff *tx_skb;
|
||||
|
||||
tx_skb = skb_copy_expand(skb, sizeof(*tx_desc), 0, GFP_ATOMIC);
|
||||
dev_kfree_skb_any(skb);
|
||||
if (!tx_skb) {
|
||||
stats->tx_dropped++;
|
||||
netif_wake_queue(netdev);
|
||||
return NETDEV_TX_OK;
|
||||
}
|
||||
skb = tx_skb;
|
||||
}
|
||||
tx_desc = (struct tx_desc *)skb_push(skb, sizeof(*tx_desc));
|
||||
memset(tx_desc, 0, sizeof(*tx_desc));
|
||||
tx_desc->opts1 = cpu_to_le32((len & TX_LEN_MASK) | TX_FS | TX_LS);
|
||||
tp->tx_skb = skb;
|
||||
skb_tx_timestamp(skb);
|
||||
usb_fill_bulk_urb(tp->tx_urb, tp->udev, usb_sndbulkpipe(tp->udev, 2),
|
||||
skb->data, skb->len,
|
||||
(usb_complete_t)write_bulk_callback, tp);
|
||||
res = usb_submit_urb(tp->tx_urb, GFP_ATOMIC);
|
||||
|
||||
spin_lock_irqsave(&tp->tx_lock, lockflags);
|
||||
if (!list_empty(&tp->tx_free) && skb_queue_empty(&tp->tx_queue)) {
|
||||
struct list_head *cursor;
|
||||
|
||||
cursor = tp->tx_free.next;
|
||||
list_del_init(cursor);
|
||||
agg = list_entry(cursor, struct tx_agg, list);
|
||||
}
|
||||
spin_unlock_irqrestore(&tp->tx_lock, lockflags);
|
||||
|
||||
if (!agg) {
|
||||
skb_queue_tail(&tp->tx_queue, skb);
|
||||
return NETDEV_TX_OK;
|
||||
}
|
||||
|
||||
tx_desc = (struct tx_desc *)agg->head;
|
||||
tx_data = agg->head + sizeof(*tx_desc);
|
||||
agg->skb_num = agg->skb_len = 0;
|
||||
|
||||
len = skb->len;
|
||||
tx_desc->opts1 = cpu_to_le32((skb->len & TX_LEN_MASK) | TX_FS | TX_LS);
|
||||
memcpy(tx_data, skb->data, len);
|
||||
dev_kfree_skb_any(skb);
|
||||
agg->skb_num++;
|
||||
agg->skb_len += len;
|
||||
usb_fill_bulk_urb(agg->urb, tp->udev, usb_sndbulkpipe(tp->udev, 2),
|
||||
agg->head, len + sizeof(*tx_desc),
|
||||
(usb_complete_t)write_bulk_callback, agg);
|
||||
res = usb_submit_urb(agg->urb, GFP_ATOMIC);
|
||||
if (res) {
|
||||
/* Can we get/handle EPIPE here? */
|
||||
if (res == -ENODEV) {
|
||||
|
|
@ -957,12 +1272,11 @@ static netdev_tx_t rtl8152_start_xmit(struct sk_buff *skb,
|
|||
} else {
|
||||
netif_warn(tp, tx_err, netdev,
|
||||
"failed tx_urb %d\n", res);
|
||||
stats->tx_errors++;
|
||||
netif_start_queue(netdev);
|
||||
stats->tx_dropped++;
|
||||
spin_lock_irqsave(&tp->tx_lock, lockflags);
|
||||
list_add_tail(&agg->list, &tp->tx_free);
|
||||
spin_unlock_irqrestore(&tp->tx_lock, lockflags);
|
||||
}
|
||||
} else {
|
||||
stats->tx_packets++;
|
||||
stats->tx_bytes += skb->len;
|
||||
}
|
||||
|
||||
return NETDEV_TX_OK;
|
||||
|
|
@ -999,17 +1313,18 @@ static inline u8 rtl8152_get_speed(struct r8152 *tp)
|
|||
|
||||
static int rtl8152_enable(struct r8152 *tp)
|
||||
{
|
||||
u32 ocp_data;
|
||||
u32 ocp_data;
|
||||
int i, ret;
|
||||
u8 speed;
|
||||
|
||||
speed = rtl8152_get_speed(tp);
|
||||
if (speed & _100bps) {
|
||||
if (speed & _10bps) {
|
||||
ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR);
|
||||
ocp_data &= ~EEEP_CR_EEEP_TX;
|
||||
ocp_data |= EEEP_CR_EEEP_TX;
|
||||
ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR, ocp_data);
|
||||
} else {
|
||||
ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR);
|
||||
ocp_data |= EEEP_CR_EEEP_TX;
|
||||
ocp_data &= ~EEEP_CR_EEEP_TX;
|
||||
ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR, ocp_data);
|
||||
}
|
||||
|
||||
|
|
@ -1023,23 +1338,34 @@ static int rtl8152_enable(struct r8152 *tp)
|
|||
ocp_data &= ~RXDY_GATED_EN;
|
||||
ocp_write_word(tp, MCU_TYPE_PLA, PLA_MISC_1, ocp_data);
|
||||
|
||||
usb_fill_bulk_urb(tp->rx_urb, tp->udev, usb_rcvbulkpipe(tp->udev, 1),
|
||||
tp->rx_skb->data, RTL8152_RMS + sizeof(struct rx_desc),
|
||||
(usb_complete_t)read_bulk_callback, tp);
|
||||
INIT_LIST_HEAD(&tp->rx_done);
|
||||
ret = 0;
|
||||
for (i = 0; i < RTL8152_MAX_RX; i++) {
|
||||
INIT_LIST_HEAD(&tp->rx_info[i].list);
|
||||
ret |= r8152_submit_rx(tp, &tp->rx_info[i], GFP_KERNEL);
|
||||
}
|
||||
|
||||
return usb_submit_urb(tp->rx_urb, GFP_KERNEL);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void rtl8152_disable(struct r8152 *tp)
|
||||
{
|
||||
u32 ocp_data;
|
||||
int i;
|
||||
struct net_device_stats *stats = rtl8152_get_stats(tp->netdev);
|
||||
struct sk_buff *skb;
|
||||
u32 ocp_data;
|
||||
int i;
|
||||
|
||||
ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
|
||||
ocp_data &= ~RCR_ACPT_ALL;
|
||||
ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
|
||||
|
||||
usb_kill_urb(tp->tx_urb);
|
||||
while ((skb = skb_dequeue(&tp->tx_queue))) {
|
||||
dev_kfree_skb(skb);
|
||||
stats->tx_dropped++;
|
||||
}
|
||||
|
||||
for (i = 0; i < RTL8152_MAX_TX; i++)
|
||||
usb_kill_urb(tp->tx_info[i].urb);
|
||||
|
||||
ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MISC_1);
|
||||
ocp_data |= RXDY_GATED_EN;
|
||||
|
|
@ -1058,7 +1384,8 @@ static void rtl8152_disable(struct r8152 *tp)
|
|||
mdelay(1);
|
||||
}
|
||||
|
||||
usb_kill_urb(tp->rx_urb);
|
||||
for (i = 0; i < RTL8152_MAX_RX; i++)
|
||||
usb_kill_urb(tp->rx_info[i].urb);
|
||||
|
||||
rtl8152_nic_reset(tp);
|
||||
}
|
||||
|
|
@ -1303,7 +1630,9 @@ static void set_carrier(struct r8152 *tp)
|
|||
} else {
|
||||
if (tp->speed & LINK_STATUS) {
|
||||
netif_carrier_off(netdev);
|
||||
tasklet_disable(&tp->tl);
|
||||
rtl8152_disable(tp);
|
||||
tasklet_enable(&tp->tl);
|
||||
}
|
||||
}
|
||||
tp->speed = speed;
|
||||
|
|
@ -1369,7 +1698,9 @@ static int rtl8152_close(struct net_device *netdev)
|
|||
clear_bit(WORK_ENABLE, &tp->flags);
|
||||
cancel_delayed_work_sync(&tp->schedule);
|
||||
netif_stop_queue(netdev);
|
||||
tasklet_disable(&tp->tl);
|
||||
rtl8152_disable(tp);
|
||||
tasklet_enable(&tp->tl);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
|
@ -1429,8 +1760,8 @@ static void r8152b_hw_phy_cfg(struct r8152 *tp)
|
|||
|
||||
static void r8152b_init(struct r8152 *tp)
|
||||
{
|
||||
u32 ocp_data;
|
||||
int i;
|
||||
u32 ocp_data;
|
||||
int i;
|
||||
|
||||
rtl_clear_bp(tp);
|
||||
|
||||
|
|
@ -1475,9 +1806,9 @@ static void r8152b_init(struct r8152 *tp)
|
|||
break;
|
||||
}
|
||||
|
||||
/* disable rx aggregation */
|
||||
/* enable rx aggregation */
|
||||
ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
|
||||
ocp_data |= RX_AGG_DISABLE;
|
||||
ocp_data &= ~RX_AGG_DISABLE;
|
||||
ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
|
||||
}
|
||||
|
||||
|
|
@ -1490,6 +1821,7 @@ static int rtl8152_suspend(struct usb_interface *intf, pm_message_t message)
|
|||
if (netif_running(tp->netdev)) {
|
||||
clear_bit(WORK_ENABLE, &tp->flags);
|
||||
cancel_delayed_work_sync(&tp->schedule);
|
||||
tasklet_disable(&tp->tl);
|
||||
}
|
||||
|
||||
rtl8152_down(tp);
|
||||
|
|
@ -1508,6 +1840,7 @@ static int rtl8152_resume(struct usb_interface *intf)
|
|||
set_bit(WORK_ENABLE, &tp->flags);
|
||||
set_bit(RTL8152_SET_RX_MODE, &tp->flags);
|
||||
schedule_delayed_work(&tp->schedule, 0);
|
||||
tasklet_enable(&tp->tl);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
@ -1619,6 +1952,7 @@ static int rtl8152_probe(struct usb_interface *intf,
|
|||
struct usb_device *udev = interface_to_usbdev(intf);
|
||||
struct r8152 *tp;
|
||||
struct net_device *netdev;
|
||||
int ret;
|
||||
|
||||
if (udev->actconfig->desc.bConfigurationValue != 1) {
|
||||
usb_driver_set_configuration(udev, 1);
|
||||
|
|
@ -1631,10 +1965,12 @@ static int rtl8152_probe(struct usb_interface *intf,
|
|||
return -ENOMEM;
|
||||
}
|
||||
|
||||
SET_NETDEV_DEV(netdev, &intf->dev);
|
||||
tp = netdev_priv(netdev);
|
||||
memset(tp, 0, sizeof(*tp));
|
||||
tp->msg_enable = 0x7FFF;
|
||||
|
||||
tasklet_init(&tp->tl, rx_fixup, (unsigned long)tp);
|
||||
tasklet_init(&tp->tl, bottom_half, (unsigned long)tp);
|
||||
INIT_DELAYED_WORK(&tp->schedule, rtl_work_func_t);
|
||||
|
||||
tp->udev = udev;
|
||||
|
|
@ -1657,37 +1993,27 @@ static int rtl8152_probe(struct usb_interface *intf,
|
|||
r8152b_init(tp);
|
||||
set_ethernet_addr(tp);
|
||||
|
||||
if (!alloc_all_urbs(tp)) {
|
||||
netif_err(tp, probe, netdev, "out of memory");
|
||||
ret = alloc_all_mem(tp);
|
||||
if (ret)
|
||||
goto out;
|
||||
}
|
||||
|
||||
tp->rx_skb = netdev_alloc_skb(netdev,
|
||||
RTL8152_RMS + sizeof(struct rx_desc));
|
||||
if (!tp->rx_skb)
|
||||
goto out1;
|
||||
|
||||
usb_set_intfdata(intf, tp);
|
||||
SET_NETDEV_DEV(netdev, &intf->dev);
|
||||
|
||||
|
||||
if (register_netdev(netdev) != 0) {
|
||||
ret = register_netdev(netdev);
|
||||
if (ret != 0) {
|
||||
netif_err(tp, probe, netdev, "couldn't register the device");
|
||||
goto out2;
|
||||
goto out1;
|
||||
}
|
||||
|
||||
netif_info(tp, probe, netdev, "%s", DRIVER_VERSION);
|
||||
|
||||
return 0;
|
||||
|
||||
out2:
|
||||
usb_set_intfdata(intf, NULL);
|
||||
dev_kfree_skb(tp->rx_skb);
|
||||
out1:
|
||||
free_all_urbs(tp);
|
||||
usb_set_intfdata(intf, NULL);
|
||||
out:
|
||||
free_netdev(netdev);
|
||||
return -EIO;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void rtl8152_unload(struct r8152 *tp)
|
||||
|
|
@ -1715,9 +2041,7 @@ static void rtl8152_disconnect(struct usb_interface *intf)
|
|||
tasklet_kill(&tp->tl);
|
||||
unregister_netdev(tp->netdev);
|
||||
rtl8152_unload(tp);
|
||||
free_all_urbs(tp);
|
||||
if (tp->rx_skb)
|
||||
dev_kfree_skb(tp->rx_skb);
|
||||
free_all_mem(tp);
|
||||
free_netdev(tp->netdev);
|
||||
}
|
||||
}
|
||||
|
|
@ -1732,11 +2056,12 @@ MODULE_DEVICE_TABLE(usb, rtl8152_table);
|
|||
|
||||
static struct usb_driver rtl8152_driver = {
|
||||
.name = MODULENAME,
|
||||
.id_table = rtl8152_table,
|
||||
.probe = rtl8152_probe,
|
||||
.disconnect = rtl8152_disconnect,
|
||||
.id_table = rtl8152_table,
|
||||
.suspend = rtl8152_suspend,
|
||||
.resume = rtl8152_resume
|
||||
.resume = rtl8152_resume,
|
||||
.reset_resume = rtl8152_resume,
|
||||
};
|
||||
|
||||
module_usb_driver(rtl8152_driver);
|
||||
|
|
|
|||
Loading…
Reference in a new issue