diff --git a/drivers/net/usb/compatibility.h b/drivers/net/usb/compatibility.h new file mode 100644 index 000000000000..66d6eef2e6ed --- /dev/null +++ b/drivers/net/usb/compatibility.h @@ -0,0 +1,471 @@ +#ifndef LINUX_COMPATIBILITY_H +#define LINUX_COMPATIBILITY_H + +/* + * Definition and macro + */ + +#include +#include +#include + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31) + #include +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0) + #include +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0) */ +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31) */ + +#if LINUX_VERSION_CODE < KERNEL_VERSION(4,5,0) + #define NETIF_F_CSUM_MASK NETIF_F_ALL_CSUM +#if LINUX_VERSION_CODE < KERNEL_VERSION(4,0,0) + #define skb_vlan_tag_present(__skb) vlan_tx_tag_present(__skb) + #define skb_vlan_tag_get(__skb) vlan_tx_tag_get(__skb) + #define skb_vlan_tag_get_id(__skb) vlan_tx_tag_get_id(__skb) +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,19,0) + #define napi_alloc_skb(napi, length) netdev_alloc_skb_ip_align(netdev,length) +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0) + #define ether_addr_copy(dst, src) memcpy(dst, src, ETH_ALEN) +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,13,0) + #define BIT(nr) (1UL << (nr)) + #define BIT_ULL(nr) (1ULL << (nr)) + #define BITS_PER_BYTE 8 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0) + #define NETIF_F_HW_VLAN_CTAG_RX NETIF_F_HW_VLAN_RX + #define NETIF_F_HW_VLAN_CTAG_TX NETIF_F_HW_VLAN_TX +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0) + #define USB_DEVICE_INTERFACE_CLASS(vend, prod, iclass) \ + USB_DEVICE_AND_INTERFACE_INFO(vend, prod, iclass, 0xff, 0) + + static inline __sum16 tcp_v6_check(int len, + const struct in6_addr *saddr, + const struct in6_addr *daddr, + __wsum base) + { + return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base); + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0) + #define eth_random_addr(addr) random_ether_addr(addr) + #define MDIO_EEE_100TX MDIO_AN_EEE_ADV_100TX /* 100TX EEE cap */ + #define MDIO_EEE_1000T MDIO_AN_EEE_ADV_1000T /* 1000T EEE cap */ +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0) + #define ETH_MDIO_SUPPORTS_C22 MDIO_SUPPORTS_C22 + + static inline void eth_hw_addr_random(struct net_device *dev) + { + random_ether_addr(dev->dev_addr); + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0) + #define module_usb_driver(__driver) \ + static int __init __driver##_init(void) \ + { \ + return usb_register(&(__driver)); \ + } \ + module_init(__driver##_init); \ + static void __exit __driver##_exit(void) \ + { \ + usb_deregister(&(__driver)); \ + } \ + module_exit(__driver##_exit); + + #define netdev_features_t u32 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0) + #define PMSG_IS_AUTO(msg) (((msg).event & PM_EVENT_AUTO) != 0) + + static inline struct page *skb_frag_page(const skb_frag_t *frag) + { + return frag->page; + } + + static inline void *skb_frag_address(const skb_frag_t *frag) + { + return page_address(skb_frag_page(frag)) + frag->page_offset; + } + + static inline unsigned int skb_frag_size(const skb_frag_t *frag) + { + return frag->size; + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0) + #define ndo_set_rx_mode ndo_set_multicast_list +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39) + #define NETIF_F_RXCSUM (1 << 29) /* Receive checksumming offload */ +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38) + #define MDIO_AN_EEE_ADV 60 /* EEE advertisement */ + #define MDIO_AN_EEE_ADV_100TX 0x0002 /* Advertise 100TX EEE cap */ + #define MDIO_AN_EEE_ADV_1000T 0x0004 /* Advertise 1000T EEE cap */ +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37) + #define skb_checksum_none_assert(skb_ptr) (skb_ptr)->ip_summed = CHECKSUM_NONE + + static inline __be16 vlan_get_protocol(const struct sk_buff *skb) + { + __be16 protocol = 0; + + if (vlan_tx_tag_present(skb) || + skb->protocol != cpu_to_be16(ETH_P_8021Q)) + protocol = skb->protocol; + else { + __be16 proto, *protop; + protop = skb_header_pointer(skb, offsetof(struct vlan_ethhdr, + h_vlan_encapsulated_proto), + sizeof(proto), &proto); + if (likely(protop)) + protocol = *protop; + } + + return protocol; + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36) + #define skb_tx_timestamp(skb) + + #define queue_delayed_work(long_wq, work, delay) schedule_delayed_work(work, delay) + + static inline void usleep_range(unsigned long min, unsigned long max) + { + unsigned long ms = min / 1000; + + if (ms) + mdelay(ms); + + udelay(min % 1000); + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) + static inline bool pci_dev_run_wake(struct pci_dev *dev) + { + return 1; + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34) + #define netdev_mc_count(netdev) ((netdev)->mc_count) + #define netdev_mc_empty(netdev) (netdev_mc_count(netdev) == 0) + + #define netif_printk(priv, type, level, netdev, fmt, args...) \ + do { \ + if (netif_msg_##type(priv)) \ + printk(level "%s: " fmt,(netdev)->name , ##args); \ + } while (0) + + #define netif_emerg(priv, type, netdev, fmt, args...) \ + netif_printk(priv, type, KERN_EMERG, netdev, fmt, ##args) + #define netif_alert(priv, type, netdev, fmt, args...) \ + netif_printk(priv, type, KERN_ALERT, netdev, fmt, ##args) + #define netif_crit(priv, type, netdev, fmt, args...) \ + netif_printk(priv, type, KERN_CRIT, netdev, fmt, ##args) + #define netif_err(priv, type, netdev, fmt, args...) \ + netif_printk(priv, type, KERN_ERR, netdev, fmt, ##args) + #define netif_warn(priv, type, netdev, fmt, args...) \ + netif_printk(priv, type, KERN_WARNING, netdev, fmt, ##args) + #define netif_notice(priv, type, netdev, fmt, args...) \ + netif_printk(priv, type, KERN_NOTICE, netdev, fmt, ##args) + #define netif_info(priv, type, netdev, fmt, args...) \ + netif_printk(priv, type, KERN_INFO, (netdev), fmt, ##args) + + static inline int usb_enable_autosuspend(struct usb_device *udev) + { return 0; } + static inline int usb_disable_autosuspend(struct usb_device *udev) + { return 0; } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33) + #define get_sset_count get_stats_count + + static inline + struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev, + unsigned int length) + { + struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN); + + if (NET_IP_ALIGN && skb) + skb_reserve(skb, NET_IP_ALIGN); + return skb; + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32) + #define pm_request_resume(para) + #define pm_runtime_set_suspended(para) + #define pm_schedule_suspend(para1, para2) + #define pm_runtime_get_sync(para) + #define pm_runtime_put_sync(para) + #define pm_runtime_put_noidle(para) + #define pm_runtime_idle(para) + #define pm_runtime_set_active(para) + #define pm_runtime_enable(para) + #define pm_runtime_disable(para) + typedef int netdev_tx_t; +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31) + #define USB_SPEED_SUPER (USB_SPEED_VARIABLE + 1) + #define MDIO_MMD_AN 7 /* Auto-Negotiation */ +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) + #define napi_gro_receive(napi, skb) netif_receive_skb(skb) + #define vlan_gro_receive(napi, grp, vlan_tci, skb) \ + vlan_hwaccel_receive_skb(skb, grp, vlan_tci) + + static inline void usb_autopm_put_interface_async(struct usb_interface *intf) + { + struct usb_device *udev = interface_to_usbdev(intf); + int status = 0; + + if (intf->condition == USB_INTERFACE_UNBOUND) { + status = -ENODEV; + } else { + udev->last_busy = jiffies; + --intf->pm_usage_cnt; + if (udev->autosuspend_disabled || udev->autosuspend_delay < 0) + status = -EPERM; + } + } + + static inline int usb_autopm_get_interface_async(struct usb_interface *intf) + { + struct usb_device *udev = interface_to_usbdev(intf); + int status = 0; + + if (intf->condition == USB_INTERFACE_UNBOUND) + status = -ENODEV; + else if (udev->autoresume_disabled) + status = -EPERM; + else + ++intf->pm_usage_cnt; + return status; + } + + static inline int eth_change_mtu(struct net_device *dev, int new_mtu) + { + if (new_mtu < 68 || new_mtu > ETH_DATA_LEN) + return -EINVAL; + dev->mtu = new_mtu; + return 0; + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28) + static inline void __skb_queue_splice(const struct sk_buff_head *list, + struct sk_buff *prev, + struct sk_buff *next) + { + struct sk_buff *first = list->next; + struct sk_buff *last = list->prev; + + first->prev = prev; + prev->next = first; + + last->next = next; + next->prev = last; + } + + static inline void skb_queue_splice(const struct sk_buff_head *list, + struct sk_buff_head *head) + { + if (!skb_queue_empty(list)) { + __skb_queue_splice(list, (struct sk_buff *) head, head->next); + head->qlen += list->qlen; + } + } + + static inline void __skb_queue_head_init(struct sk_buff_head *list) + { + list->prev = list->next = (struct sk_buff *)list; + list->qlen = 0; + } + + static inline void skb_queue_splice_init(struct sk_buff_head *list, + struct sk_buff_head *head) + { + if (!skb_queue_empty(list)) { + __skb_queue_splice(list, (struct sk_buff *) head, head->next); + head->qlen += list->qlen; + __skb_queue_head_init(list); + } + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27) + #define PM_EVENT_AUTO 0x0400 + + static inline void __list_splice2(const struct list_head *list, + struct list_head *prev, + struct list_head *next) + { + struct list_head *first = list->next; + struct list_head *last = list->prev; + + first->prev = prev; + prev->next = first; + + last->next = next; + next->prev = last; + } + + static inline void list_splice_tail(struct list_head *list, + struct list_head *head) + { + if (!list_empty(list)) + __list_splice2(list, head->prev, head); + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) + struct napi_struct { + struct list_head poll_list; + unsigned long state; + int weight; + int (*poll)(struct napi_struct *, int); + #ifdef CONFIG_NETPOLL + spinlock_t poll_lock; + int poll_owner; + struct net_device *dev; + struct list_head dev_list; + #endif + }; + + #define napi_enable(napi_ptr) netif_poll_enable(container_of(napi_ptr, struct r8152, napi)->netdev) + #define napi_disable(napi_ptr) netif_poll_disable(container_of(napi_ptr, struct r8152, napi)->netdev) + #define napi_schedule(napi_ptr) netif_rx_schedule(container_of(napi_ptr, struct r8152, napi)->netdev) + #define napi_complete(napi_ptr) netif_rx_complete(container_of(napi_ptr, struct r8152, napi)->netdev) + #define netif_napi_add(ndev, napi_ptr, function, weight_t) \ + ndev->poll = function; \ + ndev->weight = weight_t; + typedef unsigned long uintptr_t; + #define DMA_BIT_MASK(value) \ + (value < 64 ? ((1ULL << value) - 1) : 0xFFFFFFFFFFFFFFFFULL) +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) + #define NETIF_F_IPV6_CSUM 16 + #define cancel_delayed_work_sync cancel_delayed_work + + static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom) + { + int delta = 0; + + if (headroom > skb_headroom(skb)) + delta = headroom - skb_headroom(skb); + + if (delta || skb_header_cloned(skb)) + return pskb_expand_head(skb, ALIGN(delta, NET_SKB_PAD), + 0, GFP_ATOMIC); + return 0; + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) + #define ip_hdr(skb_ptr) (skb_ptr)->nh.iph + #define ipv6hdr(skb_ptr) (skb_ptr)->nh.ipv6h + + static inline void skb_copy_from_linear_data(const struct sk_buff *skb, + void *to, + const unsigned int len) + { + memcpy(to, skb->data, len); + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21) + #define vlan_group_set_device(vlgrp, vid, value) \ + if (vlgrp) \ + (vlgrp)->vlan_devices[vid] = value; +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) + #define delayed_work work_struct + #define INIT_DELAYED_WORK(a,b) INIT_WORK(a,b,tp) +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) + #define CHECKSUM_PARTIAL CHECKSUM_HW + + static inline void *kmemdup(const void *src, size_t len, gfp_t gfp) + { + void *p; + + p = kmalloc_track_caller(len, gfp); + if (p) + memcpy(p, src, len); + return p; + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18) + #define skb_is_gso(skb_ptr) skb_shinfo(skb_ptr)->tso_size + #define netdev_alloc_skb(dev, len) dev_alloc_skb(len) + #define IRQF_SHARED SA_SHIRQ + + static inline struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features) + { + return NULL; + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16) + #ifndef __LINUX_MUTEX_H + #define mutex semaphore + #define mutex_lock down + #define mutex_unlock up + #define mutex_trylock down_trylock + #define mutex_lock_interruptible down_interruptible + #define mutex_init init_MUTEX + #endif +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) + #define ADVERTISED_Pause (1 << 13) + #define ADVERTISED_Asym_Pause (1 << 14) +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12) + #define skb_header_cloned(skb) skb_cloned(skb) +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) */ + static inline void netif_napi_del(struct napi_struct *napi) + { + #ifdef CONFIG_NETPOLL + list_del(&napi->dev_list); + #endif + } +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,13,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,19,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(4,0,0) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(4,5,0) */ + +#ifndef FALSE + #define TRUE 1 + #define FALSE 0 +#endif + +enum rtl_cmd { + RTLTOOL_PLA_OCP_READ_DWORD = 0, + RTLTOOL_PLA_OCP_WRITE_DWORD, + RTLTOOL_USB_OCP_READ_DWORD, + RTLTOOL_USB_OCP_WRITE_DWORD, + RTLTOOL_PLA_OCP_READ, + RTLTOOL_PLA_OCP_WRITE, + RTLTOOL_USB_OCP_READ, + RTLTOOL_USB_OCP_WRITE, + RTLTOOL_USB_INFO, + RTL_ENABLE_USB_DIAG, + RTL_DISABLE_USB_DIAG, + + RTLTOOL_INVALID +}; + +struct usb_device_info { + __u16 idVendor; + __u16 idProduct; + __u16 bcdDevice; + __u8 dev_addr[8]; + char devpath[16]; +}; + +struct rtltool_cmd { + __u32 cmd; + __u32 offset; + __u32 byteen; + __u32 data; + void *buf; + struct usb_device_info nic_info; + struct sockaddr ifru_addr; + struct sockaddr ifru_netmask; + struct sockaddr ifru_hwaddr; +}; + +#endif /* LINUX_COMPATIBILITY_H */ diff --git a/drivers/net/usb/r8152.c b/drivers/net/usb/r8152.c index 90b426c5ffce..74362d18de9b 100644 --- a/drivers/net/usb/r8152.c +++ b/drivers/net/usb/r8152.c @@ -1,10 +1,12 @@ /* - * Copyright (c) 2014 Realtek Semiconductor Corp. All rights reserved. + * Copyright (c) 2016 Realtek Semiconductor Corp. All rights reserved. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * version 2 as published by the Free Software Foundation. * + * This product is covered by one or more of the following patents: + * US6,570,884, US6,115,776, and US6,327,625. */ #include @@ -22,23 +24,21 @@ #include #include #include -#include -#include #include #include -#include -/* Information for net-next */ -#define NETNEXT_VERSION "08" +#include "compatibility.h" -/* Information for net */ -#define NET_VERSION "7" - -#define DRIVER_VERSION "v1." NETNEXT_VERSION "." NET_VERSION -#define DRIVER_AUTHOR "Realtek linux nic maintainers " +/* Version Information */ +#define DRIVER_VERSION "v2.08.0 (2016/12/09)" +#define DRIVER_AUTHOR "Realtek nic sw " #define DRIVER_DESC "Realtek RTL8152/RTL8153 Based USB Ethernet Adapters" #define MODULENAME "r8152" +#define PATENTS "This product is covered by one or more of the " \ + "following patents:\n" \ + "\t\tUS6,570,884, US6,115,776, and US6,327,625.\n" + #define R8152_PHY_ID 32 #define PLA_IDR 0xc000 @@ -51,11 +51,14 @@ #define PLA_FMC 0xc0b4 #define PLA_CFG_WOL 0xc0b6 #define PLA_TEREDO_CFG 0xc0bc +#define PLA_TEREDO_WAKE_BASE 0xc0c4 #define PLA_MAR 0xcd00 #define PLA_BACKUP 0xd000 #define PAL_BDC_CR 0xd1a0 #define PLA_TEREDO_TIMER 0xd2cc #define PLA_REALWOW_TIMER 0xd2e8 +#define PLA_EFUSE_DATA 0xdd00 +#define PLA_EFUSE_CMD 0xdd02 #define PLA_LEDSEL 0xdd90 #define PLA_LED_FEATURE 0xdd92 #define PLA_PHYAR 0xde00 @@ -105,7 +108,9 @@ #define USB_CSR_DUMMY2 0xb466 #define USB_DEV_STAT 0xb808 #define USB_CONNECT_TIMER 0xcbf8 +#define USB_MSC_TIMER 0xcbfc #define USB_BURST_SIZE 0xcfc0 +#define USB_LPM_CONFIG 0xcfd8 #define USB_USB_CTRL 0xd406 #define USB_PHY_CTRL 0xd408 #define USB_TX_AGG 0xd40a @@ -113,15 +118,20 @@ #define USB_USB_TIMER 0xd428 #define USB_RX_EARLY_TIMEOUT 0xd42c #define USB_RX_EARLY_SIZE 0xd42e -#define USB_PM_CTRL_STATUS 0xd432 +#define USB_PM_CTRL_STATUS 0xd432 /* RTL8153A */ +#define USB_RX_EXTRA_AGGR_TMR 0xd432 /* RTL8153B */ #define USB_TX_DMA 0xd434 +#define USB_UPT_RXDMA_OWN 0xd437 #define USB_TOLERANCE 0xd490 #define USB_LPM_CTRL 0xd41a #define USB_BMU_RESET 0xd4b0 +#define USB_U1U2_TIMER 0xd4da #define USB_UPS_CTRL 0xd800 -#define USB_MISC_0 0xd81a #define USB_POWER_CUT 0xd80a +#define USB_MISC_0 0xd81a #define USB_AFE_CTRL2 0xd824 +#define USB_UPS_CFG 0xd842 +#define USB_UPS_FLAGS 0xd848 #define USB_WDT11_CTRL 0xe43c #define USB_BP_BA 0xfc26 #define USB_BP_0 0xfc28 @@ -133,6 +143,15 @@ #define USB_BP_6 0xfc34 #define USB_BP_7 0xfc36 #define USB_BP_EN 0xfc38 +#define USB_BP_8 0xfc38 +#define USB_BP_9 0xfc3a +#define USB_BP_10 0xfc3c +#define USB_BP_11 0xfc3e +#define USB_BP_12 0xfc40 +#define USB_BP_13 0xfc42 +#define USB_BP_14 0xfc44 +#define USB_BP_15 0xfc46 +#define USB_BP2_EN 0xfc48 /* OCP Registers */ #define OCP_ALDPS_CONFIG 0x2010 @@ -143,6 +162,7 @@ #define OCP_EEE_AR 0xa41a #define OCP_EEE_DATA 0xa41c #define OCP_PHY_STATUS 0xa420 +#define OCP_NCTL_CFG 0xa42c #define OCP_POWER_CFG 0xa430 #define OCP_EEE_CFG 0xa432 #define OCP_SRAM_ADDR 0xa436 @@ -152,9 +172,14 @@ #define OCP_EEE_ADV 0xa5d0 #define OCP_EEE_LPABLE 0xa5d2 #define OCP_PHY_STATE 0xa708 /* nway state for 8153 */ +#define OCP_PHY_PATCH_STAT 0xb800 +#define OCP_PHY_PATCH_CMD 0xb820 +#define OCP_ADC_IOFFSET 0xbcfc #define OCP_ADC_CFG 0xbc06 +#define OCP_SYSCLK_CFG 0xc416 /* SRAM Register */ +#define SRAM_GREEN_CFG 0x8011 #define SRAM_LPF_CFG 0x8012 #define SRAM_10M_AMP1 0x8080 #define SRAM_10M_AMP2 0x8082 @@ -252,6 +277,10 @@ /* PAL_BDC_CR */ #define ALDPS_PROXY_MODE 0x0001 +/* PLA_EFUSE_CMD */ +#define EFUSE_READ_CMD BIT(15) +#define EFUSE_DATA_BIT16 BIT(7) + /* PLA_CONFIG34 */ #define LINK_ON_WAKE_EN 0x0010 #define LINK_OFF_WAKE_EN 0x0008 @@ -277,6 +306,7 @@ /* PLA_MAC_PWR_CTRL2 */ #define EEE_SPDWN_RATIO 0x8007 +#define MAC_CLK_SPDWN_EN BIT(15) /* PLA_MAC_PWR_CTRL3 */ #define PKT_AVAIL_SPDWN_EN 0x0100 @@ -328,6 +358,9 @@ #define STAT_SPEED_HIGH 0x0000 #define STAT_SPEED_FULL 0x0002 +/* USB_LPM_CONFIG */ +#define LPM_U1U2_EN BIT(0) + /* USB_TX_AGG */ #define TX_AGG_MAX_THRESHOLD 0x03 @@ -335,6 +368,7 @@ #define RX_THR_SUPPER 0x0c350180 #define RX_THR_HIGH 0x7a120180 #define RX_THR_SLOW 0xffff0180 +#define RX_THR_B 0x00010001 /* USB_TX_DMA */ #define TEST_MODE_DISABLE 0x00000001 @@ -344,6 +378,10 @@ #define BMU_RESET_EP_IN 0x01 #define BMU_RESET_EP_OUT 0x02 +/* USB_UPT_RXDMA_OWN */ +#define OWN_UPDATE BIT(0) +#define OWN_CLEAR BIT(1) + /* USB_UPS_CTRL */ #define POWER_CUT 0x0100 @@ -360,6 +398,8 @@ /* USB_POWER_CUT */ #define PWR_EN 0x0001 #define PHASE2_EN 0x0008 +#define UPS_EN BIT(4) +#define USP_PREWAKE BIT(5) /* USB_MISC_0 */ #define PCUT_STATUS 0x0001 @@ -386,6 +426,37 @@ #define SEN_VAL_NORMAL 0xa000 #define SEL_RXIDLE 0x0100 +/* USB_UPS_CFG */ +#define SAW_CNT_1MS_MASK 0x0fff + +/* USB_UPS_FLAGS */ +#define UPS_FLAGS_R_TUNE BIT(0) +#define UPS_FLAGS_EN_10M_CKDIV BIT(1) +#define UPS_FLAGS_250M_CKDIV BIT(2) +#define UPS_FLAGS_EN_ALDPS BIT(3) +#define UPS_FLAGS_CTAP_SHORT_DIS BIT(4) +#define UPS_FLAGS_SPEED_MASK (0xf << 16) +#define ups_flags_speed(x) ((x) << 16) +#define UPS_FLAGS_EN_EEE BIT(20) +#define UPS_FLAGS_EN_500M_EEE BIT(21) +#define UPS_FLAGS_EN_EEE_CKDIV BIT(22) +#define UPS_FLAGS_EEE_PLLOFF_GIGA BIT(24) +#define UPS_FLAGS_EEE_CMOD_LV_EN BIT(25) +#define UPS_FLAGS_EN_GREEN BIT(26) +#define UPS_FLAGS_EN_FLOW_CTR BIT(27) + +enum spd_duplex { + NWAY_10M_HALF = 1, + NWAY_10M_FULL, + NWAY_100M_HALF, + NWAY_100M_FULL, + NWAY_1000M_FULL, + FORCE_10M_HALF, + FORCE_10M_FULL, + FORCE_100M_HALF, + FORCE_100M_FULL, +}; + /* OCP_ALDPS_CONFIG */ #define ENPWRSAVE 0x8000 #define ENPDNPS 0x0200 @@ -397,6 +468,9 @@ #define PHY_STAT_LAN_ON 3 #define PHY_STAT_PWRDN 5 +/* OCP_NCTL_CFG */ +#define PGA_RETURN_EN BIT(1) + /* OCP_POWER_CFG */ #define EEE_CLKDIV_EN 0x8000 #define EN_ALDPS 0x0004 @@ -438,17 +512,34 @@ #define EEE10_EN 0x0010 /* OCP_DOWN_SPEED */ +#define EN_EEE_CMODE BIT(14) +#define EN_EEE_1000 BIT(13) +#define EN_EEE_100 BIT(12) +#define EN_10M_CLKDIV BIT(11) #define EN_10M_BGOFF 0x0080 /* OCP_PHY_STATE */ #define TXDIS_STATE 0x01 #define ABD_STATE 0x02 +/* OCP_PHY_PATCH_STAT */ +#define PATCH_READY BIT(6) + +/* OCP_PHY_PATCH_CMD */ +#define PATCH_REQUEST BIT(4) + /* OCP_ADC_CFG */ #define CKADSEL_L 0x0100 #define ADC_EN 0x0080 #define EN_EMI_L 0x0040 +/* OCP_SYSCLK_CFG */ +#define clk_div_expo(x) (min(x, 5) << 8) + +/* SRAM_GREEN_CFG */ +#define GREEN_ETH_EN BIT(15) +#define R_TUNE_EN BIT(11) + /* SRAM_LPF_CFG */ #define LPF_AUTO_TUNE 0x8000 @@ -461,11 +552,6 @@ /* SRAM_IMPEDANCE */ #define RX_DRIVING_MASK 0x6000 -/* MAC PASSTHRU */ -#define AD_MASK 0xfee0 -#define EFUSE 0xcfdb -#define PASS_THRU_MASK 0x1 - enum rtl_register_content { _1000bps = 0x10, _100bps = 0x08, @@ -496,11 +582,13 @@ enum rtl_register_content { #define BYTE_EN_END_MASK 0xf0 #define RTL8153_MAX_PACKET 9216 /* 9K */ -#define RTL8153_MAX_MTU (RTL8153_MAX_PACKET - VLAN_ETH_HLEN - VLAN_HLEN) -#define RTL8152_RMS (VLAN_ETH_FRAME_LEN + VLAN_HLEN) +#define RTL8153_MAX_MTU (RTL8153_MAX_PACKET - VLAN_ETH_HLEN - CRC_SIZE) +#define RTL8152_RMS (VLAN_ETH_FRAME_LEN + CRC_SIZE) #define RTL8153_RMS RTL8153_MAX_PACKET #define RTL8152_TX_TIMEOUT (5 * HZ) #define RTL8152_NAPI_WEIGHT 64 +#define rx_reserved_size(x) ((x) + VLAN_ETH_HLEN + CRC_SIZE + \ + sizeof(struct rx_desc) + RX_ALIGN) /* rtl8152 flags */ enum rtl8152_flags { @@ -517,6 +605,7 @@ enum rtl8152_flags { #define VENDOR_ID_REALTEK 0x0bda #define VENDOR_ID_SAMSUNG 0x04e8 #define VENDOR_ID_LENOVO 0x17ef +#define VENDOR_ID_TPLINK 0x2357 #define VENDOR_ID_NVIDIA 0x0955 #define MCU_TYPE_PLA 0x0100 @@ -540,6 +629,7 @@ struct tally_counter { struct rx_desc { __le32 opts1; +#define RD_CRC BIT(15) #define RX_LEN_MASK 0x7fff __le32 opts2; @@ -563,6 +653,7 @@ struct tx_desc { __le32 opts1; #define TX_FS BIT(31) /* First segment of a packet */ #define TX_LS BIT(30) /* Final segment of a packet */ +#define LGSEND BIT(29) #define GTSENDV4 BIT(28) #define GTSENDV6 BIT(27) #define GTTCPHO_SHIFT 18 @@ -616,7 +707,13 @@ struct r8152 { struct delayed_work schedule, hw_phy_work; struct mii_if_info mii; struct mutex control; /* use for hw setting */ -#ifdef CONFIG_PM_SLEEP +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) + struct vlan_group *vlgrp; +#endif +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) + struct net_device_stats stats; +#endif +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23) && defined(CONFIG_PM_SLEEP) struct notifier_block pm_notifier; #endif @@ -627,10 +724,16 @@ struct r8152 { void (*up)(struct r8152 *); void (*down)(struct r8152 *); void (*unload)(struct r8152 *); +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) int (*eee_get)(struct r8152 *, struct ethtool_eee *); int (*eee_set)(struct r8152 *, struct ethtool_eee *); +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */ bool (*in_nway)(struct r8152 *); void (*hw_phy_cfg)(struct r8152 *); + void (*aldps_enable)(struct r8152 *tp, bool enable); + void (*u1u2_enable)(struct r8152 *tp, bool enable); + void (*u2p3_enable)(struct r8152 *tp, bool enable); + void (*power_cut_en)(struct r8152 *tp, bool enable); void (*autosuspend_en)(struct r8152 *tp, bool enable); } rtl_ops; @@ -643,6 +746,7 @@ struct r8152 { u16 speed; u8 *intr_buff; u8 version; + u8 rtk_enable_diag; u8 duplex; u8 autoneg; }; @@ -655,6 +759,9 @@ enum rtl_version { RTL_VER_04, RTL_VER_05, RTL_VER_06, + RTL_VER_07, + RTL_VER_08, + RTL_VER_09, RTL_VER_MAX }; @@ -671,7 +778,7 @@ static const int multicast_filter_limit = 32; static unsigned int agg_buf_sz = 16384; #define RTL_LIMITED_TSO_SIZE (agg_buf_sz - sizeof(struct tx_desc) - \ - VLAN_ETH_HLEN - VLAN_HLEN) + VLAN_ETH_HLEN - CRC_SIZE) static int get_registers(struct r8152 *tp, u16 value, u16 index, u16 size, void *data) @@ -686,8 +793,11 @@ int get_registers(struct r8152 *tp, u16 value, u16 index, u16 size, void *data) ret = usb_control_msg(tp->udev, usb_rcvctrlpipe(tp->udev, 0), RTL8152_REQ_GET_REGS, RTL8152_REQT_READ, value, index, tmp, size, 500); + if (ret < 0) + memset(data, 0xff, size); + else + memcpy(data, tmp, size); - memcpy(data, tmp, size); kfree(tmp); return ret; @@ -869,11 +979,13 @@ static u16 ocp_read_word(struct r8152 *tp, u16 type, u16 index) { u32 data; __le32 tmp; + u16 byen = BYTE_EN_WORD; u8 shift = index & 2; index &= ~3; + byen <<= shift; - generic_ocp_read(tp, index, sizeof(tmp), &tmp, type); + generic_ocp_read(tp, index, sizeof(tmp), &tmp, type | byen); data = __le32_to_cpu(tmp); data >>= (shift * 8); @@ -985,6 +1097,12 @@ static void sram_write(struct r8152 *tp, u16 addr, u16 data) ocp_reg_write(tp, OCP_SRAM_DATA, data); } +static u16 sram_read(struct r8152 *tp, u16 addr) +{ + ocp_reg_write(tp, OCP_SRAM_ADDR, addr); + return ocp_reg_read(tp, OCP_SRAM_DATA); +} + static int read_mii_word(struct net_device *netdev, int phy_id, int reg) { struct r8152 *tp = netdev_priv(netdev); @@ -1024,6 +1142,9 @@ static int rtl8152_set_mac_address(struct net_device *netdev, void *p) struct sockaddr *addr = p; int ret = -EADDRNOTAVAIL; + if (unlikely(tp->rtk_enable_diag)) + return -EBUSY; + if (!is_valid_ether_addr(addr->sa_data)) goto out1; @@ -1046,81 +1167,16 @@ out1: return ret; } -/* Devices containing RTL8153-AD can support a persistent - * host system provided MAC address. - * Examples of this are Dell TB15 and Dell WD15 docks - */ -static int vendor_mac_passthru_addr_read(struct r8152 *tp, struct sockaddr *sa) -{ - acpi_status status; - struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; - union acpi_object *obj; - int ret = -EINVAL; - u32 ocp_data; - unsigned char buf[6]; - - /* test for -AD variant of RTL8153 */ - ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0); - if ((ocp_data & AD_MASK) != 0x1000) - return -ENODEV; - - /* test for MAC address pass-through bit */ - ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, EFUSE); - if ((ocp_data & PASS_THRU_MASK) != 1) - return -ENODEV; - - /* returns _AUXMAC_#AABBCCDDEEFF# */ - status = acpi_evaluate_object(NULL, "\\_SB.AMAC", NULL, &buffer); - obj = (union acpi_object *)buffer.pointer; - if (!ACPI_SUCCESS(status)) - return -ENODEV; - if (obj->type != ACPI_TYPE_BUFFER || obj->string.length != 0x17) { - netif_warn(tp, probe, tp->netdev, - "Invalid buffer for pass-thru MAC addr: (%d, %d)\n", - obj->type, obj->string.length); - goto amacout; - } - if (strncmp(obj->string.pointer, "_AUXMAC_#", 9) != 0 || - strncmp(obj->string.pointer + 0x15, "#", 1) != 0) { - netif_warn(tp, probe, tp->netdev, - "Invalid header when reading pass-thru MAC addr\n"); - goto amacout; - } - ret = hex2bin(buf, obj->string.pointer + 9, 6); - if (!(ret == 0 && is_valid_ether_addr(buf))) { - netif_warn(tp, probe, tp->netdev, - "Invalid MAC for pass-thru MAC addr: %d, %pM\n", - ret, buf); - ret = -EINVAL; - goto amacout; - } - memcpy(sa->sa_data, buf, 6); - ether_addr_copy(tp->netdev->dev_addr, sa->sa_data); - netif_info(tp, probe, tp->netdev, - "Using pass-thru MAC addr %pM\n", sa->sa_data); - -amacout: - kfree(obj); - return ret; -} - static int set_ethernet_addr(struct r8152 *tp) { struct net_device *dev = tp->netdev; struct sockaddr sa; int ret; - if (tp->version == RTL_VER_01) { + if (tp->version == RTL_VER_01) ret = pla_ocp_read(tp, PLA_IDR, 8, sa.sa_data); - } else { - /* if this is not an RTL8153-AD, no eFuse mac pass thru set, - * or system doesn't provide valid _SB.AMAC this will be - * be expected to non-zero - */ - ret = vendor_mac_passthru_addr_read(tp, &sa); - if (ret < 0) - ret = pla_ocp_read(tp, PLA_BACKUP, 8, sa.sa_data); - } + else + ret = pla_ocp_read(tp, PLA_BACKUP, 8, sa.sa_data); if (ret < 0) { netif_err(tp, probe, dev, "Get ether addr fail\n"); @@ -1142,6 +1198,17 @@ static int set_ethernet_addr(struct r8152 *tp) return ret; } +static inline struct net_device_stats *rtl8152_get_stats(struct net_device *dev) +{ +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) + struct rtl8152 *tp = netdev_priv(dev); + + return (struct net_device_stats *)&tp->stats; +#else + return &dev->stats; +#endif +} + static void read_bulk_callback(struct urb *urb) { struct net_device *netdev; @@ -1190,11 +1257,13 @@ static void read_bulk_callback(struct urb *urb) return; /* the urb is in unlink state */ case -ETIME: if (net_ratelimit()) - netdev_warn(netdev, "maybe reset is needed?\n"); + netif_warn(tp, rx_err, netdev, + "maybe reset is needed?\n"); break; default: if (net_ratelimit()) - netdev_warn(netdev, "Rx status %d\n", status); + netif_warn(tp, rx_err, netdev, + "Rx status %d\n", status); break; } @@ -1218,10 +1287,11 @@ static void write_bulk_callback(struct urb *urb) return; netdev = tp->netdev; - stats = &netdev->stats; + stats = rtl8152_get_stats(netdev); if (status) { if (net_ratelimit()) - netdev_warn(netdev, "Tx status %d\n", status); + netif_warn(tp, tx_err, netdev, + "Tx status %d\n", status); stats->tx_errors += agg->skb_num; } else { stats->tx_packets += agg->skb_num; @@ -1497,7 +1567,7 @@ static void r8152_csum_workaround(struct r8152 *tp, struct sk_buff *skb, struct net_device_stats *stats; drop: - stats = &tp->netdev->stats; + stats = rtl8152_get_stats(tp->netdev); stats->tx_dropped++; dev_kfree_skb(skb); } @@ -1536,15 +1606,62 @@ static inline void rtl_tx_vlan_tag(struct tx_desc *desc, struct sk_buff *skb) } } +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) + +static inline bool +rtl_rx_vlan_tag(struct r8152 *tp, struct rx_desc *desc, struct sk_buff *skb) +{ + u32 opts2 = le32_to_cpu(desc->opts2); + + if (tp->vlgrp && (opts2 & RX_VLAN_TAG)) { + vlan_gro_receive(&tp->napi, tp->vlgrp, swab16(opts2 & 0xffff), + skb); + return true; + } + + return false; +} + +static inline void +rtl_vlan_put_tag(struct r8152 *tp, struct rx_desc *desc, struct sk_buff *skb) +{ + u32 opts2 = le32_to_cpu(desc->opts2); + + if (tp->vlgrp && (opts2 & RX_VLAN_TAG)) + __vlan_hwaccel_put_tag(skb, swab16(opts2 & 0xffff)); +} + +static inline __u16 +rtl_vlan_get_tag(struct sk_buff *skb) +{ + __u16 tag; + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27) + __vlan_hwaccel_get_tag(skb, &tag); +#else + tag = skb->vlan_tci; +#endif + + return tag; +} + +#else + static inline void rtl_rx_vlan_tag(struct rx_desc *desc, struct sk_buff *skb) { u32 opts2 = le32_to_cpu(desc->opts2); if (opts2 & RX_VLAN_TAG) +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0) + __vlan_hwaccel_put_tag(skb, swab16(opts2 & 0xffff)); +#else __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), swab16(opts2 & 0xffff)); +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0) */ } +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) */ + static int r8152_tx_csum(struct r8152 *tp, struct tx_desc *desc, struct sk_buff *skb, u32 len, u32 transport_offset) { @@ -1730,7 +1847,7 @@ static u8 r8152_rx_csum(struct r8152 *tp, struct rx_desc *rx_desc) u8 checksum = CHECKSUM_NONE; u32 opts2, opts3; - if (!(tp->netdev->features & NETIF_F_RXCSUM)) + if (tp->version == RTL_VER_01) goto return_result; opts2 = le32_to_cpu(rx_desc->opts2); @@ -1745,7 +1862,7 @@ static u8 r8152_rx_csum(struct r8152 *tp, struct rx_desc *rx_desc) checksum = CHECKSUM_NONE; else checksum = CHECKSUM_UNNECESSARY; - } else if (opts2 & RD_IPV6_CS) { + } else if (RD_IPV6_CS) { if ((opts2 & RD_UDP_CS) && !(opts3 & UDPF)) checksum = CHECKSUM_UNNECESSARY; else if ((opts2 & RD_TCP_CS) && !(opts3 & TCPF)) @@ -1766,15 +1883,34 @@ static int rx_bottom(struct r8152 *tp, int budget) while (work_done < budget) { struct sk_buff *skb = __skb_dequeue(&tp->rx_queue); struct net_device *netdev = tp->netdev; - struct net_device_stats *stats = &netdev->stats; + struct net_device_stats *stats; unsigned int pkt_len; +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) + u16 vlan_tci; +#endif if (!skb) break; pkt_len = skb->len; + stats = rtl8152_get_stats(netdev); +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) + vlan_tci = rtl_vlan_get_tag(skb); + + if (vlan_tci) + vlan_gro_receive(&tp->napi, tp->vlgrp, vlan_tci, + skb); + else + napi_gro_receive(&tp->napi, skb); +#else napi_gro_receive(&tp->napi, skb); +#endif + work_done++; + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) + netdev->last_rx = jiffies; +#endif stats->rx_packets++; stats->rx_bytes += pkt_len; } @@ -1808,7 +1944,7 @@ static int rx_bottom(struct r8152 *tp, int budget) while (urb->actual_length > len_used) { struct net_device *netdev = tp->netdev; - struct net_device_stats *stats = &netdev->stats; + struct net_device_stats *stats; unsigned int pkt_len; struct sk_buff *skb; @@ -1820,6 +1956,8 @@ static int rx_bottom(struct r8152 *tp, int budget) if (urb->actual_length < len_used) break; + stats = rtl8152_get_stats(netdev); + pkt_len -= CRC_SIZE; rx_data += sizeof(struct rx_desc); @@ -1832,7 +1970,26 @@ static int rx_bottom(struct r8152 *tp, int budget) skb->ip_summed = r8152_rx_csum(tp, rx_desc); memcpy(skb->data, rx_data, pkt_len); skb_put(skb, pkt_len); +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) + skb->dev = netdev; +#endif skb->protocol = eth_type_trans(skb, netdev); + +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) + if (work_done < budget) { + if (!rtl_rx_vlan_tag(tp, rx_desc, skb)) + napi_gro_receive(&tp->napi, skb); +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) + netdev->last_rx = jiffies; +#endif + work_done++; + stats->rx_packets++; + stats->rx_bytes += pkt_len; + } else { + rtl_vlan_put_tag(tp, rx_desc, skb); + __skb_queue_tail(&tp->rx_queue, skb); + } +#else rtl_rx_vlan_tag(rx_desc, skb); if (work_done < budget) { napi_gro_receive(&tp->napi, skb); @@ -1842,6 +1999,7 @@ static int rx_bottom(struct r8152 *tp, int budget) } else { __skb_queue_tail(&tp->rx_queue, skb); } +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) */ find_next_rx: rx_data = rx_agg_align(rx_data + pkt_len + CRC_SIZE); @@ -1891,9 +2049,10 @@ static void tx_bottom(struct r8152 *tp) set_bit(RTL8152_UNPLUG, &tp->flags); netif_device_detach(netdev); } else { - struct net_device_stats *stats = &netdev->stats; + struct net_device_stats *stats; unsigned long flags; + stats = rtl8152_get_stats(netdev); netif_warn(tp, tx_err, netdev, "failed tx_urb %d\n", res); stats->tx_dropped += agg->skb_num; @@ -1924,9 +2083,9 @@ static void bottom_half(struct r8152 *tp) tx_bottom(tp); } -static int r8152_poll(struct napi_struct *napi, int budget) +static inline int __r8152_poll(struct r8152 *tp, int budget) { - struct r8152 *tp = container_of(napi, struct r8152, napi); + struct napi_struct *napi = &tp->napi; int work_done; work_done = rx_bottom(tp, budget); @@ -1941,6 +2100,33 @@ static int r8152_poll(struct napi_struct *napi, int budget) return work_done; } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) + +static int r8152_poll(struct net_device *dev, int *budget) +{ + struct r8152 *tp = netdev_priv(dev); + int quota = min(dev->quota, *budget); + int work_done; + + work_done = __r8152_poll(tp, quota); + + *budget -= work_done; + dev->quota -= work_done; + + return (work_done >= quota); +} + +#else + +static int r8152_poll(struct napi_struct *napi, int budget) +{ + struct r8152 *tp = container_of(napi, struct r8152, napi); + + return __r8152_poll(tp, budget); +} + +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) */ + static int r8152_submit_rx(struct r8152 *tp, struct rx_agg *agg, gfp_t mem_flags) { @@ -1979,7 +2165,7 @@ int r8152_submit_rx(struct r8152 *tp, struct rx_agg *agg, gfp_t mem_flags) static void rtl_drop_queued_tx(struct r8152 *tp) { - struct net_device_stats *stats = &tp->netdev->stats; + struct net_device_stats *stats = rtl8152_get_stats(tp->netdev); struct sk_buff_head skb_head, *tx_queue = &tp->tx_queue; struct sk_buff *skb; @@ -2000,29 +2186,40 @@ static void rtl_drop_queued_tx(struct r8152 *tp) static void rtl8152_tx_timeout(struct net_device *netdev) { struct r8152 *tp = netdev_priv(netdev); +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) + int i; +#endif netif_warn(tp, tx_err, netdev, "Tx timeout\n"); +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) + for (i = 0; i < RTL8152_MAX_TX; i++) + usb_unlink_urb(tp->tx_info[i].urb); +#else usb_queue_reset_device(tp->intf); +#endif } static void rtl8152_set_rx_mode(struct net_device *netdev) -{ - struct r8152 *tp = netdev_priv(netdev); - - if (netif_carrier_ok(netdev)) { - set_bit(RTL8152_SET_RX_MODE, &tp->flags); - schedule_delayed_work(&tp->schedule, 0); - } -} - -static void _rtl8152_set_rx_mode(struct net_device *netdev) { struct r8152 *tp = netdev_priv(netdev); u32 mc_filter[2]; /* Multicast hash filter */ __le32 tmp[2]; u32 ocp_data; + if (in_atomic()) { + if (netif_carrier_ok(netdev)) { + set_bit(RTL8152_SET_RX_MODE, &tp->flags); + schedule_delayed_work(&tp->schedule, 0); + } + return; + } + + clear_bit(RTL8152_SET_RX_MODE, &tp->flags); + + if (!netif_carrier_ok(netdev)) + return; + netif_stop_queue(netdev); ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR); ocp_data &= ~RCR_ACPT_ALL; @@ -2041,6 +2238,21 @@ static void _rtl8152_set_rx_mode(struct net_device *netdev) mc_filter[1] = 0xffffffff; mc_filter[0] = 0xffffffff; } else { +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) + struct dev_mc_list *mclist; + unsigned int i; + + mc_filter[1] = mc_filter[0] = 0; + for (i = 0, mclist = netdev->mc_list; + mclist && i < netdev->mc_count; + i++, mclist = mclist->next) { + int bit_nr; + + bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26; + mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31); + ocp_data |= RCR_AM; + } +#else struct netdev_hw_addr *ha; mc_filter[1] = 0; @@ -2051,6 +2263,7 @@ static void _rtl8152_set_rx_mode(struct net_device *netdev) mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31); ocp_data |= RCR_AM; } +#endif } tmp[0] = __cpu_to_le32(swab32(mc_filter[1])); @@ -2061,6 +2274,7 @@ static void _rtl8152_set_rx_mode(struct net_device *netdev) netif_wake_queue(netdev); } +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,18,4) static netdev_features_t rtl8152_features_check(struct sk_buff *skb, struct net_device *dev, netdev_features_t features) @@ -2076,12 +2290,40 @@ rtl8152_features_check(struct sk_buff *skb, struct net_device *dev, return features; } +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,18,4) */ static netdev_tx_t rtl8152_start_xmit(struct sk_buff *skb, struct net_device *netdev) { struct r8152 *tp = netdev_priv(netdev); +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,4) + if (unlikely((skb->len + sizeof(struct tx_desc)) > agg_buf_sz)) { + netdev_features_t features = netdev->features; + struct sk_buff *segs, *nskb; + + features &= ~(NETIF_F_TSO | NETIF_F_TSO6); + segs = skb_gso_segment(skb, features); + if (IS_ERR(segs) || !segs) + goto free_skb; + + do { + nskb = segs; + segs = segs->next; + nskb->next = NULL; + rtl8152_start_xmit(nskb, netdev); + } while (segs); + +free_skb: + dev_kfree_skb_any(skb); + + return NETDEV_TX_OK; + } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31) + netdev->trans_start = jiffies +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31) */ +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,18,4) */ + skb_tx_timestamp(skb); skb_queue_tail(&tp->tx_queue, skb); @@ -2129,7 +2371,7 @@ static void set_tx_qlen(struct r8152 *tp) { struct net_device *netdev = tp->netdev; - tp->tx_qlen = agg_buf_sz / (netdev->mtu + VLAN_ETH_HLEN + VLAN_HLEN + + tp->tx_qlen = agg_buf_sz / (netdev->mtu + VLAN_ETH_HLEN + CRC_SIZE + sizeof(struct tx_desc)); } @@ -2167,6 +2409,30 @@ static void rxdy_gated_en(struct r8152 *tp, bool enable) ocp_write_word(tp, MCU_TYPE_PLA, PLA_MISC_1, ocp_data); } +#if defined(RTL8152_S5_WOL) && defined(CONFIG_PM) +static int rtl_s5_wol(struct r8152 *tp) +{ + struct usb_device *udev = tp->udev; + + if (!tp->saved_wolopts) + return 0; + + /* usb_enable_remote_wakeup */ + if (udev->speed < USB_SPEED_SUPER) + return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), + USB_REQ_SET_FEATURE, USB_RECIP_DEVICE, + USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0, + USB_CTRL_SET_TIMEOUT); + else + return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), + USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE, + USB_INTRF_FUNC_SUSPEND, + USB_INTRF_FUNC_SUSPEND_RW | + USB_INTRF_FUNC_SUSPEND_LP, + NULL, 0, USB_CTRL_SET_TIMEOUT); +} +#endif + static int rtl_start_rx(struct r8152 *tp) { int i, ret = 0; @@ -2240,19 +2506,57 @@ static int rtl8152_enable(struct r8152 *tp) return rtl_enable(tp); } +static inline void r8153b_rx_agg_chg_indicate(struct r8152 *tp) +{ + ocp_write_byte(tp, MCU_TYPE_USB, USB_UPT_RXDMA_OWN, + OWN_UPDATE | OWN_CLEAR); +} + static void r8153_set_rx_early_timeout(struct r8152 *tp) { u32 ocp_data = tp->coalesce / 8; - ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_TIMEOUT, ocp_data); + switch (tp->version) { + case RTL_VER_03: + case RTL_VER_04: + case RTL_VER_05: + case RTL_VER_06: + ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_TIMEOUT, + ocp_data); + break; + + case RTL_VER_08: + case RTL_VER_09: + /* The RTL8153B uses USB_RX_EXTRA_AGGR_TMR for rx timeout + * primarily. For USB_RX_EARLY_TIMEOUT, we fix it to 128ns. + */ + ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_TIMEOUT, + 128 / 8); + ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EXTRA_AGGR_TMR, + ocp_data); + r8153b_rx_agg_chg_indicate(tp); + break; + + default: + break; + } } static void r8153_set_rx_early_size(struct r8152 *tp) { u32 mtu = tp->netdev->mtu; - u32 ocp_data = (agg_buf_sz - mtu - VLAN_ETH_HLEN - VLAN_HLEN) / 8; + u32 ocp_data = (agg_buf_sz - rx_reserved_size(mtu)) / 8; ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_SIZE, ocp_data); + + switch (tp->version) { + case RTL_VER_08: + case RTL_VER_09: + r8153b_rx_agg_chg_indicate(tp); + break; + default: + break; + } } static int rtl8153_enable(struct r8152 *tp) @@ -2336,6 +2640,43 @@ static void rtl_rx_vlan_en(struct r8152 *tp, bool enable) ocp_write_word(tp, MCU_TYPE_PLA, PLA_CPCR, ocp_data); } +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) + +static void +rtl8152_vlan_rx_register(struct net_device *dev, struct vlan_group *grp) +{ + struct r8152 *tp = netdev_priv(dev); + + if (unlikely(tp->rtk_enable_diag)) + return; + + if (usb_autopm_get_interface(tp->intf) < 0) + return; + + mutex_lock(&tp->control); + + tp->vlgrp = grp; + if (tp->vlgrp) + rtl_rx_vlan_en(tp, true); + else + rtl_rx_vlan_en(tp, false); + + mutex_unlock(&tp->control); +} + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) + +static void rtl8152_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid) +{ + struct r8152 *tp = netdev_priv(dev); + + vlan_group_set_device(tp->vlgrp, vid, NULL); +} + +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) */ + +#else + static int rtl8152_set_features(struct net_device *dev, netdev_features_t features) { @@ -2343,6 +2684,9 @@ static int rtl8152_set_features(struct net_device *dev, struct r8152 *tp = netdev_priv(dev); int ret; + if (unlikely(tp->rtk_enable_diag)) + return -EBUSY; + ret = usb_autopm_get_interface(tp->intf); if (ret < 0) goto out; @@ -2364,6 +2708,8 @@ out: return ret; } +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) */ + #define WAKE_ANY (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_BCAST | WAKE_MCAST) static u32 __rtl_get_wol(struct r8152 *tp) @@ -2438,6 +2784,19 @@ static void r8153_u1u2en(struct r8152 *tp, bool enable) usb_ocp_write(tp, USB_TOLERANCE, BYTE_EN_SIX_BYTES, sizeof(u1u2), u1u2); } +static void r8153b_u1u2en(struct r8152 *tp, bool enable) +{ + u32 ocp_data; + + ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_LPM_CONFIG); + if (enable) + ocp_data |= LPM_U1U2_EN; + else + ocp_data &= ~LPM_U1U2_EN; + + ocp_write_word(tp, MCU_TYPE_USB, USB_LPM_CONFIG, ocp_data); +} + static void r8153_u2p3en(struct r8152 *tp, bool enable) { u32 ocp_data; @@ -2450,6 +2809,32 @@ static void r8153_u2p3en(struct r8152 *tp, bool enable) ocp_write_word(tp, MCU_TYPE_USB, USB_U2P3_CTRL, ocp_data); } +static void r8153b_ups_en(struct r8152 *tp, bool enable) +{ + u32 ocp_data; + + ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_POWER_CUT); + if (enable) { + ocp_data |= UPS_EN | PHASE2_EN; + ocp_write_byte(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data); + + ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, 0xcfff); + ocp_data |= BIT(0); + ocp_write_byte(tp, MCU_TYPE_USB, 0xcfff, ocp_data); + } else { + ocp_data &= ~UPS_EN; + ocp_write_byte(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data); + + ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, 0xcfff); + ocp_data &= ~BIT(0); + ocp_write_byte(tp, MCU_TYPE_USB, 0xcfff, ocp_data); + + ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0); + ocp_data &= ~PCUT_STATUS; + ocp_write_word(tp, MCU_TYPE_USB, USB_MISC_0, ocp_data); + } +} + static void r8153_power_cut_en(struct r8152 *tp, bool enable) { u32 ocp_data; @@ -2466,6 +2851,38 @@ static void r8153_power_cut_en(struct r8152 *tp, bool enable) ocp_write_word(tp, MCU_TYPE_USB, USB_MISC_0, ocp_data); } +static void r8153B_power_cut_en(struct r8152 *tp, bool enable) +{ + u32 ocp_data; + + ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_POWER_CUT); + if (enable) + ocp_data |= PWR_EN | PHASE2_EN; + else + ocp_data &= ~PWR_EN; + ocp_write_word(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data); + + ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0); + ocp_data &= ~PCUT_STATUS; + ocp_write_word(tp, MCU_TYPE_USB, USB_MISC_0, ocp_data); +} + +static void r8153b_queue_wake(struct r8152 *tp, bool enable) +{ + u32 ocp_data; + + ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, 0xd38a); + if (enable) + ocp_data |= BIT(0); + else + ocp_data &= ~BIT(0); + ocp_write_byte(tp, MCU_TYPE_PLA, 0xd38a, ocp_data); + + ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, 0xd38c); + ocp_data &= ~BIT(0); + ocp_write_byte(tp, MCU_TYPE_PLA, 0xd38c, ocp_data); +} + static bool rtl_can_wakeup(struct r8152 *tp) { struct usb_device *udev = tp->udev; @@ -2505,23 +2922,67 @@ static void rtl_runtime_suspend_enable(struct r8152 *tp, bool enable) static void rtl8153_runtime_enable(struct r8152 *tp, bool enable) { rtl_runtime_suspend_enable(tp, enable); - - if (enable) { - r8153_u1u2en(tp, false); - r8153_u2p3en(tp, false); - } else { - r8153_u2p3en(tp, true); - r8153_u1u2en(tp, true); - } + tp->rtl_ops.u1u2_enable(tp, !enable); + tp->rtl_ops.u2p3_enable(tp, !enable); } +static void rtl8153b_runtime_enable(struct r8152 *tp, bool enable) +{ + r8153b_queue_wake(tp, enable); + rtl_runtime_suspend_enable(tp, enable); + tp->rtl_ops.u1u2_enable(tp, !enable); + r8153b_ups_en(tp, enable); +} + +#if !defined(CONFIG_MII) && !defined(CONFIG_MII_MODULE) +int mii_nway_restart (struct mii_if_info *mii) +{ + struct r8152 *tp = netdev_priv(mii->dev); + int r = -EINVAL; + int bmcr; + + /* if autoneg is off, it's an error */ + bmcr = r8152_mdio_read(tp, MII_BMCR); + + if (bmcr & BMCR_ANENABLE) { + bmcr |= BMCR_ANRESTART; + r8152_mdio_write(tp, MII_BMCR, bmcr); + r = 0; + } + + return r; +} +#endif + static void r8153_teredo_off(struct r8152 *tp) { u32 ocp_data; - ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG); - ocp_data &= ~(TEREDO_SEL | TEREDO_RS_EVENT_MASK | OOB_TEREDO_EN); - ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, ocp_data); + switch (tp->version) { + case RTL_VER_01: + case RTL_VER_02: + case RTL_VER_03: + case RTL_VER_04: + case RTL_VER_05: + case RTL_VER_06: + case RTL_VER_07: + ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG); + ocp_data &= ~(TEREDO_SEL | TEREDO_RS_EVENT_MASK | + OOB_TEREDO_EN); + ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, ocp_data); + break; + + case RTL_VER_08: + case RTL_VER_09: + /* The bit 0 ~ 7 are relative with teredo settings. They are + * W1C (write 1 to clear), so set all 1 to disable it. + */ + ocp_write_byte(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, 0xff); + break; + + default: + break; + } ocp_write_word(tp, MCU_TYPE_PLA, PLA_WDT6_CTRL, WDT6_SET_MODE); ocp_write_word(tp, MCU_TYPE_PLA, PLA_REALWOW_TIMER, 0); @@ -2539,6 +3000,663 @@ static void rtl_reset_bmu(struct r8152 *tp) ocp_write_byte(tp, MCU_TYPE_USB, USB_BMU_RESET, ocp_data); } +static void rtl_clear_bp(struct r8152 *tp) +{ + ocp_write_dword(tp, MCU_TYPE_PLA, PLA_BP_0, 0); + ocp_write_dword(tp, MCU_TYPE_PLA, PLA_BP_2, 0); + ocp_write_dword(tp, MCU_TYPE_PLA, PLA_BP_4, 0); + ocp_write_dword(tp, MCU_TYPE_PLA, PLA_BP_6, 0); + ocp_write_dword(tp, MCU_TYPE_USB, USB_BP_0, 0); + ocp_write_dword(tp, MCU_TYPE_USB, USB_BP_2, 0); + ocp_write_dword(tp, MCU_TYPE_USB, USB_BP_4, 0); + ocp_write_dword(tp, MCU_TYPE_USB, USB_BP_6, 0); + usleep_range(3000, 6000); + ocp_write_word(tp, MCU_TYPE_PLA, PLA_BP_BA, 0); + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_BA, 0); +} + +static void r8153_clear_bp(struct r8152 *tp) +{ + ocp_write_byte(tp, MCU_TYPE_PLA, PLA_BP_EN, 0); + ocp_write_byte(tp, MCU_TYPE_USB, USB_BP_EN, 0); + rtl_clear_bp(tp); +} + +/* +static void r8153b_clear_bp(struct r8152 *tp, u16 type) +{ + if (type == MCU_TYPE_PLA) + ocp_write_byte(tp, MCU_TYPE_PLA, PLA_BP_EN, 0); + else + ocp_write_byte(tp, MCU_TYPE_USB, USB_BP2_EN, 0); + + ocp_write_word(tp, type, PLA_BP_0, 0); + ocp_write_word(tp, type, PLA_BP_1, 0); + ocp_write_word(tp, type, PLA_BP_2, 0); + ocp_write_word(tp, type, PLA_BP_3, 0); + ocp_write_word(tp, type, PLA_BP_4, 0); + ocp_write_word(tp, type, PLA_BP_5, 0); + ocp_write_word(tp, type, PLA_BP_6, 0); + ocp_write_word(tp, type, PLA_BP_7, 0); + + if (type == MCU_TYPE_USB) { + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_8, 0); + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_9, 0); + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_10, 0); + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_11, 0); + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_12, 0); + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_13, 0); + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_14, 0); + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_15, 0); + } + usleep_range(3000, 6000); + ocp_write_word(tp, type, PLA_BP_BA, 0); +} +*/ + +static void patch4(struct r8152 *tp) +{ + u8 data; + + data = ocp_read_byte(tp, MCU_TYPE_USB, 0xd429); + data |= 0x80; + ocp_write_byte(tp, MCU_TYPE_USB, 0xd429, data); + ocp_write_word(tp, MCU_TYPE_USB, 0xc0ce, 0x0210); + data = ocp_read_byte(tp, MCU_TYPE_USB, 0xd429); + data &= ~0x80; + ocp_write_byte(tp, MCU_TYPE_USB, 0xd429, data); +} + +static void r8152b_firmware(struct r8152 *tp) +{ + if (tp->version == RTL_VER_01) { + int i; + static u8 pla_patch_a[] = { + 0x08, 0xe0, 0x40, 0xe0, + 0x78, 0xe0, 0x85, 0xe0, + 0x5d, 0xe1, 0xa1, 0xe1, + 0xa3, 0xe1, 0xab, 0xe1, + 0x31, 0xc3, 0x60, 0x72, + 0xa0, 0x49, 0x10, 0xf0, + 0xa4, 0x49, 0x0e, 0xf0, + 0x2c, 0xc3, 0x62, 0x72, + 0x26, 0x70, 0x80, 0x49, + 0x05, 0xf0, 0x2f, 0x48, + 0x62, 0x9a, 0x24, 0x70, + 0x60, 0x98, 0x24, 0xc3, + 0x60, 0x99, 0x23, 0xc3, + 0x00, 0xbb, 0x2c, 0x75, + 0xdc, 0x21, 0xbc, 0x25, + 0x04, 0x13, 0x0a, 0xf0, + 0x03, 0x13, 0x08, 0xf0, + 0x02, 0x13, 0x06, 0xf0, + 0x01, 0x13, 0x04, 0xf0, + 0x08, 0x13, 0x02, 0xf0, + 0x03, 0xe0, 0xd4, 0x49, + 0x04, 0xf1, 0x14, 0xc2, + 0x12, 0xc3, 0x00, 0xbb, + 0x12, 0xc3, 0x60, 0x75, + 0xd0, 0x49, 0x05, 0xf1, + 0x50, 0x48, 0x60, 0x9d, + 0x09, 0xc6, 0x00, 0xbe, + 0xd0, 0x48, 0x60, 0x9d, + 0xf3, 0xe7, 0xc2, 0xc0, + 0x38, 0xd2, 0xc6, 0xd2, + 0x84, 0x17, 0xa2, 0x13, + 0x0c, 0x17, 0xbc, 0xc0, + 0xa2, 0xd1, 0x33, 0xc5, + 0xa0, 0x74, 0xc0, 0x49, + 0x1f, 0xf0, 0x30, 0xc5, + 0xa0, 0x73, 0x00, 0x13, + 0x04, 0xf1, 0xa2, 0x73, + 0x00, 0x13, 0x14, 0xf0, + 0x28, 0xc5, 0xa0, 0x74, + 0xc8, 0x49, 0x1b, 0xf1, + 0x26, 0xc5, 0xa0, 0x76, + 0xa2, 0x74, 0x01, 0x06, + 0x20, 0x37, 0xa0, 0x9e, + 0xa2, 0x9c, 0x1e, 0xc5, + 0xa2, 0x73, 0x23, 0x40, + 0x10, 0xf8, 0x04, 0xf3, + 0xa0, 0x73, 0x33, 0x40, + 0x0c, 0xf8, 0x15, 0xc5, + 0xa0, 0x74, 0x41, 0x48, + 0xa0, 0x9c, 0x14, 0xc5, + 0xa0, 0x76, 0x62, 0x48, + 0xe0, 0x48, 0xa0, 0x9e, + 0x10, 0xc6, 0x00, 0xbe, + 0x0a, 0xc5, 0xa0, 0x74, + 0x48, 0x48, 0xa0, 0x9c, + 0x0b, 0xc5, 0x20, 0x1e, + 0xa0, 0x9e, 0xe5, 0x48, + 0xa0, 0x9e, 0xf0, 0xe7, + 0xbc, 0xc0, 0xc8, 0xd2, + 0xcc, 0xd2, 0x28, 0xe4, + 0x22, 0x02, 0xf0, 0xc0, + 0x0b, 0xc0, 0x00, 0x71, + 0x0a, 0xc0, 0x00, 0x72, + 0xa0, 0x49, 0x04, 0xf0, + 0xa4, 0x49, 0x02, 0xf0, + 0x93, 0x48, 0x04, 0xc0, + 0x00, 0xb8, 0x00, 0xe4, + 0xc2, 0xc0, 0x8c, 0x09, + 0x14, 0xc2, 0x40, 0x73, + 0xba, 0x48, 0x40, 0x9b, + 0x11, 0xc2, 0x40, 0x73, + 0xb0, 0x49, 0x17, 0xf0, + 0xbf, 0x49, 0x03, 0xf1, + 0x09, 0xc5, 0x00, 0xbd, + 0xb1, 0x49, 0x11, 0xf0, + 0xb1, 0x48, 0x40, 0x9b, + 0x02, 0xc2, 0x00, 0xba, + 0x82, 0x18, 0x00, 0xa0, + 0x1e, 0xfc, 0xbc, 0xc0, + 0xf0, 0xc0, 0xde, 0xe8, + 0x00, 0x80, 0x00, 0x60, + 0x2c, 0x75, 0xd4, 0x49, + 0x12, 0xf1, 0x29, 0xe0, + 0xf8, 0xc2, 0x46, 0x71, + 0xf7, 0xc2, 0x40, 0x73, + 0xbe, 0x49, 0x03, 0xf1, + 0xf5, 0xc7, 0x02, 0xe0, + 0xf2, 0xc7, 0x4f, 0x30, + 0x26, 0x62, 0xa1, 0x49, + 0xf0, 0xf1, 0x22, 0x72, + 0xa0, 0x49, 0xed, 0xf1, + 0x25, 0x25, 0x18, 0x1f, + 0x97, 0x30, 0x91, 0x30, + 0x36, 0x9a, 0x2c, 0x75, + 0x32, 0xc3, 0x60, 0x73, + 0xb1, 0x49, 0x0d, 0xf1, + 0xdc, 0x21, 0xbc, 0x25, + 0x27, 0xc6, 0xc0, 0x77, + 0x04, 0x13, 0x18, 0xf0, + 0x03, 0x13, 0x19, 0xf0, + 0x02, 0x13, 0x1a, 0xf0, + 0x01, 0x13, 0x1b, 0xf0, + 0xd4, 0x49, 0x03, 0xf1, + 0x1c, 0xc5, 0x00, 0xbd, + 0xcd, 0xc6, 0xc6, 0x67, + 0x2e, 0x75, 0xd7, 0x22, + 0xdd, 0x26, 0x05, 0x15, + 0x1a, 0xf0, 0x14, 0xc6, + 0x00, 0xbe, 0x13, 0xc5, + 0x00, 0xbd, 0x12, 0xc5, + 0x00, 0xbd, 0xf1, 0x49, + 0xfb, 0xf1, 0xef, 0xe7, + 0xf4, 0x49, 0xfa, 0xf1, + 0xec, 0xe7, 0xf3, 0x49, + 0xf7, 0xf1, 0xe9, 0xe7, + 0xf2, 0x49, 0xf4, 0xf1, + 0xe6, 0xe7, 0xb6, 0xc0, + 0x6a, 0x14, 0xac, 0x13, + 0xd6, 0x13, 0xfa, 0x14, + 0xa0, 0xd1, 0x00, 0x00, + 0xc0, 0x75, 0xd0, 0x49, + 0x46, 0xf0, 0x26, 0x72, + 0xa7, 0x49, 0x43, 0xf0, + 0x22, 0x72, 0x25, 0x25, + 0x20, 0x1f, 0x97, 0x30, + 0x91, 0x30, 0x40, 0x73, + 0xf3, 0xc4, 0x1c, 0x40, + 0x04, 0xf0, 0xd7, 0x49, + 0x05, 0xf1, 0x37, 0xe0, + 0x53, 0x48, 0xc0, 0x9d, + 0x08, 0x02, 0x40, 0x66, + 0x64, 0x27, 0x06, 0x16, + 0x30, 0xf1, 0x46, 0x63, + 0x3b, 0x13, 0x2d, 0xf1, + 0x34, 0x9b, 0x18, 0x1b, + 0x93, 0x30, 0x2b, 0xc3, + 0x10, 0x1c, 0x2b, 0xe8, + 0x01, 0x14, 0x25, 0xf1, + 0x00, 0x1d, 0x26, 0x1a, + 0x8a, 0x30, 0x22, 0x73, + 0xb5, 0x25, 0x0e, 0x0b, + 0x00, 0x1c, 0x2c, 0xe8, + 0x1f, 0xc7, 0x27, 0x40, + 0x1a, 0xf1, 0x38, 0xe8, + 0x32, 0x1f, 0x8f, 0x30, + 0x08, 0x1b, 0x24, 0xe8, + 0x36, 0x72, 0x46, 0x77, + 0x00, 0x17, 0x0d, 0xf0, + 0x13, 0xc3, 0x1f, 0x40, + 0x03, 0xf1, 0x00, 0x1f, + 0x46, 0x9f, 0x44, 0x77, + 0x9f, 0x44, 0x5f, 0x44, + 0x17, 0xe8, 0x0a, 0xc7, + 0x27, 0x40, 0x05, 0xf1, + 0x02, 0xc3, 0x00, 0xbb, + 0x50, 0x1a, 0x06, 0x1a, + 0xff, 0xc7, 0x00, 0xbf, + 0xb8, 0xcd, 0xff, 0xff, + 0x02, 0x0c, 0x54, 0xa5, + 0xdc, 0xa5, 0x2f, 0x40, + 0x05, 0xf1, 0x00, 0x14, + 0xfa, 0xf1, 0x01, 0x1c, + 0x02, 0xe0, 0x00, 0x1c, + 0x80, 0xff, 0xb0, 0x49, + 0x04, 0xf0, 0x01, 0x0b, + 0xd3, 0xa1, 0x03, 0xe0, + 0x02, 0x0b, 0xd3, 0xa5, + 0x27, 0x31, 0x20, 0x37, + 0x02, 0x0b, 0xd3, 0xa5, + 0x27, 0x31, 0x20, 0x37, + 0x00, 0x13, 0xfb, 0xf1, + 0x80, 0xff, 0x22, 0x73, + 0xb5, 0x25, 0x18, 0x1e, + 0xde, 0x30, 0xd9, 0x30, + 0x64, 0x72, 0x11, 0x1e, + 0x68, 0x23, 0x16, 0x31, + 0x80, 0xff, 0xd4, 0x49, + 0x28, 0xf0, 0x02, 0xb4, + 0x2a, 0xc4, 0x00, 0x1d, + 0x2e, 0xe8, 0xe0, 0x73, + 0xb9, 0x21, 0xbd, 0x25, + 0x04, 0x13, 0x02, 0xf0, + 0x1a, 0xe0, 0x22, 0xc4, + 0x23, 0xc3, 0x2f, 0xe8, + 0x23, 0xc3, 0x2d, 0xe8, + 0x00, 0x1d, 0x21, 0xe8, + 0xe2, 0x73, 0xbb, 0x49, + 0xfc, 0xf0, 0xe0, 0x73, + 0xb7, 0x48, 0x03, 0xb4, + 0x81, 0x1d, 0x19, 0xe8, + 0x40, 0x1a, 0x84, 0x1d, + 0x16, 0xe8, 0x12, 0xc3, + 0x1e, 0xe8, 0x03, 0xb0, + 0x81, 0x1d, 0x11, 0xe8, + 0x0e, 0xc3, 0x19, 0xe8, + 0x02, 0xb0, 0x06, 0xc7, + 0x04, 0x1e, 0xe0, 0x9e, + 0x02, 0xc6, 0x00, 0xbe, + 0x22, 0x02, 0x20, 0xe4, + 0x04, 0xb8, 0x34, 0xb0, + 0x00, 0x02, 0x00, 0x03, + 0x00, 0x0e, 0x00, 0x0c, + 0x09, 0xc7, 0xe0, 0x9b, + 0xe2, 0x9a, 0xe4, 0x9c, + 0xe6, 0x8d, 0xe6, 0x76, + 0xef, 0x49, 0xfe, 0xf1, + 0x80, 0xff, 0x08, 0xea, + 0x82, 0x1d, 0xf5, 0xef, + 0x00, 0x1a, 0x88, 0x1d, + 0xf2, 0xef, 0xed, 0xc2, + 0xf0, 0xef, 0x80, 0xff, + 0x02, 0xc6, 0x00, 0xbe, + 0x46, 0x06, 0x08, 0xc2, + 0x40, 0x73, 0x3a, 0x48, + 0x40, 0x9b, 0x06, 0xff, + 0x02, 0xc6, 0x00, 0xbe, + 0x86, 0x17, 0x1e, 0xfc, + 0x36, 0xf0, 0x08, 0x1c, + 0xea, 0x8c, 0xe3, 0x64, + 0xc7, 0x49, 0x25, 0xf1, + 0xe0, 0x75, 0xff, 0x1b, + 0xeb, 0x47, 0xff, 0x1b, + 0x6b, 0x47, 0xe0, 0x9d, + 0x15, 0xc3, 0x60, 0x75, + 0xd8, 0x49, 0x04, 0xf0, + 0x81, 0x1d, 0xe2, 0x8d, + 0x05, 0xe0, 0xe2, 0x63, + 0x81, 0x1d, 0xdd, 0x47, + 0xe2, 0x8b, 0x0b, 0xc3, + 0x00, 0x1d, 0x61, 0x8d, + 0x3c, 0x03, 0x60, 0x75, + 0xd8, 0x49, 0x06, 0xf1, + 0xdf, 0x48, 0x61, 0x95, + 0x16, 0xe0, 0x4e, 0xe8, + 0x12, 0xe8, 0x21, 0xc5, + 0xa0, 0x73, 0xb0, 0x49, + 0x03, 0xf0, 0x31, 0x48, + 0xa0, 0x9b, 0x0d, 0xe0, + 0xc0, 0x49, 0x0b, 0xf1, + 0xe2, 0x63, 0x7e, 0x1d, + 0xdd, 0x46, 0xe2, 0x8b, + 0xe0, 0x75, 0x83, 0x1b, + 0xeb, 0x46, 0xfe, 0x1b, + 0x6b, 0x46, 0xe0, 0x9d, + 0xe4, 0x49, 0x11, 0xf0, + 0x10, 0x1d, 0xea, 0x8d, + 0xe3, 0x64, 0xc6, 0x49, + 0x09, 0xf1, 0x07, 0xc5, + 0xa0, 0x73, 0xb1, 0x48, + 0xa0, 0x9b, 0x02, 0xc5, + 0x00, 0xbd, 0xe6, 0x04, + 0xa0, 0xd1, 0x02, 0xc5, + 0x00, 0xbd, 0xfe, 0x04, + 0x02, 0xc5, 0x00, 0xbd, + 0x30, 0x05, 0x00, 0x00 }; + static u16 ram_code1[] = { + 0x9700, 0x7fe0, 0x4c00, 0x4007, + 0x4400, 0x4800, 0x7c1f, 0x4c00, + 0x5310, 0x6000, 0x7c07, 0x6800, + 0x673e, 0x0000, 0x0000, 0x571f, + 0x5ffb, 0xaa05, 0x5b58, 0x7d80, + 0x6100, 0x3019, 0x5b64, 0x7d80, + 0x6080, 0xa6f8, 0xdcdb, 0x0015, + 0xb915, 0xb511, 0xd16b, 0x000f, + 0xb40f, 0xd06b, 0x000d, 0xb206, + 0x7c01, 0x5800, 0x7c04, 0x5c00, + 0x3011, 0x7c01, 0x5801, 0x7c04, + 0x5c04, 0x3019, 0x30a5, 0x3127, + 0x31d5, 0x7fe0, 0x4c60, 0x7c07, + 0x6803, 0x7d00, 0x6900, 0x65a0, + 0x0000, 0x0000, 0xaf03, 0x6015, + 0x303e, 0x6017, 0x57e0, 0x580c, + 0x588c, 0x7fdd, 0x5fa2, 0x4827, + 0x7c1f, 0x4c00, 0x7c1f, 0x4c10, + 0x8400, 0x7c30, 0x6020, 0x48bf, + 0x7c1f, 0x4c00, 0x7c1f, 0x4c01, + 0x7c07, 0x6803, 0xb806, 0x7c08, + 0x6800, 0x0000, 0x0000, 0x305c, + 0x7c08, 0x6808, 0x0000, 0x0000, + 0xae06, 0x7c02, 0x5c02, 0x0000, + 0x0000, 0x3067, 0x8e05, 0x7c02, + 0x5c00, 0x0000, 0x0000, 0xad06, + 0x7c20, 0x5c20, 0x0000, 0x0000, + 0x3072, 0x8d05, 0x7c20, 0x5c00, + 0x0000, 0x0000, 0xa008, 0x7c07, + 0x6800, 0xb8db, 0x7c07, 0x6803, + 0xd9b3, 0x00d7, 0x7fe0, 0x4c80, + 0x7c08, 0x6800, 0x0000, 0x0000, + 0x7c23, 0x5c23, 0x481d, 0x7c1f, + 0x4c00, 0x7c1f, 0x4c02, 0x5310, + 0x81ff, 0x30f5, 0x7fe0, 0x4d00, + 0x4832, 0x7c1f, 0x4c00, 0x7c1f, + 0x4c10, 0x7c08, 0x6000, 0xa49e, + 0x7c07, 0x6800, 0xb89b, 0x7c07, + 0x6803, 0xd9b3, 0x00f9, 0x7fe0, + 0x4d20, 0x7e00, 0x6200, 0x3001, + 0x7fe0, 0x4dc0, 0xd09d, 0x0002, + 0xb4fe, 0x7fe0, 0x4d80, 0x7c04, + 0x6004, 0x7c07, 0x6802, 0x6728, + 0x0000, 0x0000, 0x7c08, 0x6000, + 0x486c, 0x7c1f, 0x4c00, 0x7c1f, + 0x4c01, 0x9503, 0x7e00, 0x6200, + 0x571f, 0x5fbb, 0xaa05, 0x5b58, + 0x7d80, 0x6100, 0x30c2, 0x5b64, + 0x7d80, 0x6080, 0xcdab, 0x0063, + 0xcd8d, 0x0061, 0xd96b, 0x005f, + 0xd0a0, 0x00d7, 0xcba0, 0x0003, + 0x80ec, 0x30cf, 0x30dc, 0x7fe0, + 0x4ce0, 0x4832, 0x7c1f, 0x4c00, + 0x7c1f, 0x4c08, 0x7c08, 0x6008, + 0x8300, 0xb902, 0x30a5, 0x308a, + 0x7fe0, 0x4da0, 0x65a8, 0x0000, + 0x0000, 0x56a0, 0x590c, 0x7ffd, + 0x5fa2, 0xae06, 0x7c02, 0x5c02, + 0x0000, 0x0000, 0x30f0, 0x8e05, + 0x7c02, 0x5c00, 0x0000, 0x0000, + 0xcba4, 0x0004, 0xcd8d, 0x0002, + 0x80f1, 0x7fe0, 0x4ca0, 0x7c08, + 0x6408, 0x0000, 0x0000, 0x7d00, + 0x6800, 0xb603, 0x7c10, 0x6010, + 0x7d1f, 0x551f, 0x5fb3, 0xaa07, + 0x7c80, 0x5800, 0x5b58, 0x7d80, + 0x6100, 0x310f, 0x7c80, 0x5800, + 0x5b64, 0x7d80, 0x6080, 0x4827, + 0x7c1f, 0x4c00, 0x7c1f, 0x4c10, + 0x8400, 0x7c10, 0x6000, 0x7fe0, + 0x4cc0, 0x5fbb, 0x4824, 0x7c1f, + 0x4c00, 0x7c1f, 0x4c04, 0x8200, + 0x7ce0, 0x5400, 0x6728, 0x0000, + 0x0000, 0x30cf, 0x3001, 0x7fe0, + 0x4e00, 0x4007, 0x4400, 0x5310, + 0x7c07, 0x6800, 0x673e, 0x0000, + 0x0000, 0x570f, 0x5fff, 0xaa05, + 0x585b, 0x7d80, 0x6100, 0x313b, + 0x5867, 0x7d80, 0x6080, 0x9403, + 0x7e00, 0x6200, 0xcda3, 0x00e7, + 0xcd85, 0x00e5, 0xd96b, 0x00e3, + 0x96e3, 0x7c07, 0x6800, 0x673e, + 0x0000, 0x0000, 0x7fe0, 0x4e20, + 0x96db, 0x8b04, 0x7c08, 0x5008, + 0xab03, 0x7c08, 0x5000, 0x7c07, + 0x6801, 0x677e, 0x0000, 0x0000, + 0xdb7c, 0x00ec, 0x0000, 0x7fe1, + 0x4f40, 0x4837, 0x4418, 0x41c7, + 0x7fe0, 0x4e40, 0x7c40, 0x5400, + 0x7c1f, 0x4c01, 0x7c1f, 0x4c01, + 0x8fbf, 0xd2a0, 0x004b, 0x9204, + 0xa042, 0x3168, 0x3127, 0x7fe1, + 0x4f60, 0x489c, 0x4628, 0x7fe0, + 0x4e60, 0x7e28, 0x4628, 0x7c40, + 0x5400, 0x7c01, 0x5800, 0x7c04, + 0x5c00, 0x41e8, 0x7c1f, 0x4c01, + 0x7c1f, 0x4c01, 0x8fa5, 0xb241, + 0xa02a, 0x3182, 0x7fe0, 0x4ea0, + 0x7c02, 0x4402, 0x4448, 0x4894, + 0x7c1f, 0x4c01, 0x7c1f, 0x4c03, + 0x4824, 0x7c1f, 0x4c07, 0x41ef, + 0x41ff, 0x4891, 0x7c1f, 0x4c07, + 0x7c1f, 0x4c17, 0x8400, 0x8ef8, + 0x41c7, 0x8f8a, 0x92d5, 0xa10f, + 0xd480, 0x0008, 0xd580, 0x00b8, + 0xa202, 0x319d, 0x7c04, 0x4404, + 0x319d, 0xd484, 0x00f3, 0xd484, + 0x00f1, 0x3127, 0x7fe0, 0x4ee0, + 0x7c40, 0x5400, 0x4488, 0x41cf, + 0x3127, 0x7fe0, 0x4ec0, 0x48f3, + 0x7c1f, 0x4c01, 0x7c1f, 0x4c09, + 0x4508, 0x41c7, 0x8fb0, 0xd218, + 0x00ae, 0xd2a4, 0x009e, 0x31be, + 0x7fe0, 0x4e80, 0x4832, 0x7c1f, + 0x4c01, 0x7c1f, 0x4c11, 0x4428, + 0x7c40, 0x5440, 0x7c01, 0x5801, + 0x7c04, 0x5c04, 0x41e8, 0xa4b3, + 0x31d3, 0x7fe0, 0x4f20, 0x7c07, + 0x6800, 0x673e, 0x0000, 0x0000, + 0x570f, 0x5fff, 0xaa04, 0x585b, + 0x6100, 0x31e4, 0x5867, 0x6080, + 0xbcf1, 0x3001 }; + + patch4(tp); + rtl_clear_bp(tp); + + generic_ocp_write(tp, 0xf800, 0x3f, sizeof(pla_patch_a), + pla_patch_a, MCU_TYPE_PLA); + + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc26, 0x8000); + + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc28, 0x170b); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2a, 0x01e1); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2c, 0x0989); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2e, 0x1349); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc30, 0x01b7); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc32, 0x061d); + + ocp_write_word(tp, MCU_TYPE_PLA, 0xe422, 0x0020); + ocp_write_word(tp, MCU_TYPE_PLA, 0xe420, 0x0018); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc34, 0x1785); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc36, 0x047b); + + ocp_write_word(tp, MCU_TYPE_PLA, PLA_OCP_GPHY_BASE, 0x2000); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb092, 0x7070); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb098, 0x0600); + for (i = 0; i < ARRAY_SIZE(ram_code1); i++) + ocp_write_word(tp, MCU_TYPE_PLA, 0xb09a, ram_code1[i]); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb098, 0x0200); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb092, 0x7030); + } else if (tp->version == RTL_VER_02) { + static u8 pla_patch_a2[] = { + 0x08, 0xe0, 0x1a, 0xe0, + 0xf2, 0xe0, 0xfa, 0xe0, + 0x32, 0xe1, 0x34, 0xe1, + 0x36, 0xe1, 0x38, 0xe1, + 0x2c, 0x75, 0xdc, 0x21, + 0xbc, 0x25, 0x04, 0x13, + 0x0b, 0xf0, 0x03, 0x13, + 0x09, 0xf0, 0x02, 0x13, + 0x07, 0xf0, 0x01, 0x13, + 0x05, 0xf0, 0x08, 0x13, + 0x03, 0xf0, 0x04, 0xc3, + 0x00, 0xbb, 0x03, 0xc3, + 0x00, 0xbb, 0xd2, 0x17, + 0xbc, 0x17, 0x14, 0xc2, + 0x40, 0x73, 0xba, 0x48, + 0x40, 0x9b, 0x11, 0xc2, + 0x40, 0x73, 0xb0, 0x49, + 0x17, 0xf0, 0xbf, 0x49, + 0x03, 0xf1, 0x09, 0xc5, + 0x00, 0xbd, 0xb1, 0x49, + 0x11, 0xf0, 0xb1, 0x48, + 0x40, 0x9b, 0x02, 0xc2, + 0x00, 0xba, 0x4e, 0x19, + 0x00, 0xa0, 0x1e, 0xfc, + 0xbc, 0xc0, 0xf0, 0xc0, + 0xde, 0xe8, 0x00, 0x80, + 0x00, 0x60, 0x2c, 0x75, + 0xd4, 0x49, 0x12, 0xf1, + 0x29, 0xe0, 0xf8, 0xc2, + 0x46, 0x71, 0xf7, 0xc2, + 0x40, 0x73, 0xbe, 0x49, + 0x03, 0xf1, 0xf5, 0xc7, + 0x02, 0xe0, 0xf2, 0xc7, + 0x4f, 0x30, 0x26, 0x62, + 0xa1, 0x49, 0xf0, 0xf1, + 0x22, 0x72, 0xa0, 0x49, + 0xed, 0xf1, 0x25, 0x25, + 0x18, 0x1f, 0x97, 0x30, + 0x91, 0x30, 0x36, 0x9a, + 0x2c, 0x75, 0x32, 0xc3, + 0x60, 0x73, 0xb1, 0x49, + 0x0d, 0xf1, 0xdc, 0x21, + 0xbc, 0x25, 0x27, 0xc6, + 0xc0, 0x77, 0x04, 0x13, + 0x18, 0xf0, 0x03, 0x13, + 0x19, 0xf0, 0x02, 0x13, + 0x1a, 0xf0, 0x01, 0x13, + 0x1b, 0xf0, 0xd4, 0x49, + 0x03, 0xf1, 0x1c, 0xc5, + 0x00, 0xbd, 0xcd, 0xc6, + 0xc6, 0x67, 0x2e, 0x75, + 0xd7, 0x22, 0xdd, 0x26, + 0x05, 0x15, 0x1a, 0xf0, + 0x14, 0xc6, 0x00, 0xbe, + 0x13, 0xc5, 0x00, 0xbd, + 0x12, 0xc5, 0x00, 0xbd, + 0xf1, 0x49, 0xfb, 0xf1, + 0xef, 0xe7, 0xf4, 0x49, + 0xfa, 0xf1, 0xec, 0xe7, + 0xf3, 0x49, 0xf7, 0xf1, + 0xe9, 0xe7, 0xf2, 0x49, + 0xf4, 0xf1, 0xe6, 0xe7, + 0xb6, 0xc0, 0xf6, 0x14, + 0x36, 0x14, 0x62, 0x14, + 0x86, 0x15, 0xa0, 0xd1, + 0x00, 0x00, 0xc0, 0x75, + 0xd0, 0x49, 0x46, 0xf0, + 0x26, 0x72, 0xa7, 0x49, + 0x43, 0xf0, 0x22, 0x72, + 0x25, 0x25, 0x20, 0x1f, + 0x97, 0x30, 0x91, 0x30, + 0x40, 0x73, 0xf3, 0xc4, + 0x1c, 0x40, 0x04, 0xf0, + 0xd7, 0x49, 0x05, 0xf1, + 0x37, 0xe0, 0x53, 0x48, + 0xc0, 0x9d, 0x08, 0x02, + 0x40, 0x66, 0x64, 0x27, + 0x06, 0x16, 0x30, 0xf1, + 0x46, 0x63, 0x3b, 0x13, + 0x2d, 0xf1, 0x34, 0x9b, + 0x18, 0x1b, 0x93, 0x30, + 0x2b, 0xc3, 0x10, 0x1c, + 0x2b, 0xe8, 0x01, 0x14, + 0x25, 0xf1, 0x00, 0x1d, + 0x26, 0x1a, 0x8a, 0x30, + 0x22, 0x73, 0xb5, 0x25, + 0x0e, 0x0b, 0x00, 0x1c, + 0x2c, 0xe8, 0x1f, 0xc7, + 0x27, 0x40, 0x1a, 0xf1, + 0x38, 0xe8, 0x32, 0x1f, + 0x8f, 0x30, 0x08, 0x1b, + 0x24, 0xe8, 0x36, 0x72, + 0x46, 0x77, 0x00, 0x17, + 0x0d, 0xf0, 0x13, 0xc3, + 0x1f, 0x40, 0x03, 0xf1, + 0x00, 0x1f, 0x46, 0x9f, + 0x44, 0x77, 0x9f, 0x44, + 0x5f, 0x44, 0x17, 0xe8, + 0x0a, 0xc7, 0x27, 0x40, + 0x05, 0xf1, 0x02, 0xc3, + 0x00, 0xbb, 0x1c, 0x1b, + 0xd2, 0x1a, 0xff, 0xc7, + 0x00, 0xbf, 0xb8, 0xcd, + 0xff, 0xff, 0x02, 0x0c, + 0x54, 0xa5, 0xdc, 0xa5, + 0x2f, 0x40, 0x05, 0xf1, + 0x00, 0x14, 0xfa, 0xf1, + 0x01, 0x1c, 0x02, 0xe0, + 0x00, 0x1c, 0x80, 0xff, + 0xb0, 0x49, 0x04, 0xf0, + 0x01, 0x0b, 0xd3, 0xa1, + 0x03, 0xe0, 0x02, 0x0b, + 0xd3, 0xa5, 0x27, 0x31, + 0x20, 0x37, 0x02, 0x0b, + 0xd3, 0xa5, 0x27, 0x31, + 0x20, 0x37, 0x00, 0x13, + 0xfb, 0xf1, 0x80, 0xff, + 0x22, 0x73, 0xb5, 0x25, + 0x18, 0x1e, 0xde, 0x30, + 0xd9, 0x30, 0x64, 0x72, + 0x11, 0x1e, 0x68, 0x23, + 0x16, 0x31, 0x80, 0xff, + 0x08, 0xc2, 0x40, 0x73, + 0x3a, 0x48, 0x40, 0x9b, + 0x06, 0xff, 0x02, 0xc6, + 0x00, 0xbe, 0x4e, 0x18, + 0x1e, 0xfc, 0x33, 0xc5, + 0xa0, 0x74, 0xc0, 0x49, + 0x1f, 0xf0, 0x30, 0xc5, + 0xa0, 0x73, 0x00, 0x13, + 0x04, 0xf1, 0xa2, 0x73, + 0x00, 0x13, 0x14, 0xf0, + 0x28, 0xc5, 0xa0, 0x74, + 0xc8, 0x49, 0x1b, 0xf1, + 0x26, 0xc5, 0xa0, 0x76, + 0xa2, 0x74, 0x01, 0x06, + 0x20, 0x37, 0xa0, 0x9e, + 0xa2, 0x9c, 0x1e, 0xc5, + 0xa2, 0x73, 0x23, 0x40, + 0x10, 0xf8, 0x04, 0xf3, + 0xa0, 0x73, 0x33, 0x40, + 0x0c, 0xf8, 0x15, 0xc5, + 0xa0, 0x74, 0x41, 0x48, + 0xa0, 0x9c, 0x14, 0xc5, + 0xa0, 0x76, 0x62, 0x48, + 0xe0, 0x48, 0xa0, 0x9e, + 0x10, 0xc6, 0x00, 0xbe, + 0x0a, 0xc5, 0xa0, 0x74, + 0x48, 0x48, 0xa0, 0x9c, + 0x0b, 0xc5, 0x20, 0x1e, + 0xa0, 0x9e, 0xe5, 0x48, + 0xa0, 0x9e, 0xf0, 0xe7, + 0xbc, 0xc0, 0xc8, 0xd2, + 0xcc, 0xd2, 0x28, 0xe4, + 0x22, 0x02, 0xf0, 0xc0, + 0x02, 0xc6, 0x00, 0xbe, + 0x00, 0x00, 0x02, 0xc6, + 0x00, 0xbe, 0x00, 0x00, + 0x02, 0xc6, 0x00, 0xbe, + 0x00, 0x00, 0x02, 0xc6, + 0x00, 0xbe, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 }; + + rtl_clear_bp(tp); + + generic_ocp_write(tp, 0xf800, 0xff, sizeof(pla_patch_a2), + pla_patch_a2, MCU_TYPE_PLA); + + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc26, 0x8000); + + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc28, 0x17a5); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2a, 0x13ad); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2c, 0x184d); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2e, 0x01e1); + } +} + static void r8152_aldps_en(struct r8152 *tp, bool enable) { if (enable) { @@ -2558,6 +3676,7 @@ static inline void r8152_mmd_indirect(struct r8152 *tp, u16 dev, u16 reg) ocp_reg_write(tp, OCP_EEE_AR, FUN_DATA | dev); } +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) static u16 r8152_mmd_read(struct r8152 *tp, u16 dev, u16 reg) { u16 data; @@ -2568,6 +3687,7 @@ static u16 r8152_mmd_read(struct r8152 *tp, u16 dev, u16 reg) return data; } +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */ static void r8152_mmd_write(struct r8152 *tp, u16 dev, u16 reg, u16 data) { @@ -2624,13 +3744,15 @@ static void r8152b_enable_fc(struct r8152 *tp) static void rtl8152_disable(struct r8152 *tp) { - r8152_aldps_en(tp, false); + tp->rtl_ops.aldps_enable(tp, false); rtl_disable(tp); - r8152_aldps_en(tp, true); + tp->rtl_ops.aldps_enable(tp, true); } static void r8152b_hw_phy_cfg(struct r8152 *tp) { + r8152b_firmware(tp); + r8152b_enable_eee(tp); r8152_aldps_en(tp, true); r8152b_enable_fc(tp); @@ -2767,6 +3889,1063 @@ static void r8152b_enter_oob(struct r8152 *tp) ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data); } +static int r8153_patch_request(struct r8152 *tp, bool request) +{ + u16 data; + int i; + + data = ocp_reg_read(tp, OCP_PHY_PATCH_CMD); + if (request) + data |= PATCH_REQUEST; + else + data &= ~PATCH_REQUEST; + ocp_reg_write(tp, OCP_PHY_PATCH_CMD, data); + + for (i = 0; request && i < 5000; i++) { + usleep_range(1000, 2000); + if (ocp_reg_read(tp, OCP_PHY_PATCH_STAT) & PATCH_READY) + break; + } + + if (request && !(ocp_reg_read(tp, OCP_PHY_PATCH_STAT) & PATCH_READY)) { + netif_err(tp, drv, tp->netdev, "patch request fail\n"); + r8153_patch_request(tp, false); + return -ETIME; + } else { + return 0; + } +} + +static int r8153_pre_ram_code(struct r8152 *tp, u16 key_addr, u16 patch_key) +{ + if (r8153_patch_request(tp, true)) + return -ETIME; + + sram_write(tp, key_addr, patch_key); + sram_write(tp, 0xb82e, 0x0001); + + return 0; +} + +static int r8153_post_ram_code(struct r8152 *tp, u16 key_addr) +{ + u16 data; + + sram_write(tp, 0x0000, 0x0000); + + data = ocp_reg_read(tp, 0xb82e); + data &= ~0x0001; + ocp_reg_write(tp, 0xb82e, data); + + sram_write(tp, key_addr, 0x0000); + + r8153_patch_request(tp, false); + + ocp_write_word(tp, MCU_TYPE_PLA, PLA_OCP_GPHY_BASE, tp->ocp_base); + + return 0; +} + +static void r8153_wdt1_end(struct r8152 *tp) +{ + int i; + + for (i = 0; i < 104; i++) { + if (!(ocp_read_byte(tp, MCU_TYPE_USB, 0xe404) & 1)) + break; + usleep_range(1000, 2000); + } +} + +static void r8153_firmware(struct r8152 *tp) +{ + if (tp->version == RTL_VER_03) { + r8153_clear_bp(tp); + + r8153_pre_ram_code(tp, 0x8146, 0x7000); + sram_write(tp, 0xb820, 0x0290); + sram_write(tp, 0xa012, 0x0000); + sram_write(tp, 0xa014, 0x2c04); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c18); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c45); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c45); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd502); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8301); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8306); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd500); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8208); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd501); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xe018); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x0308); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x60f2); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8404); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x607d); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc117); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c16); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc116); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c16); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x607d); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc117); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa404); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd500); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x0800); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd501); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x62d2); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x615d); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc115); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa404); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc307); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd502); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8301); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8306); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd500); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8208); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c42); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc114); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8404); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc317); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd701); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x435d); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd500); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa208); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd502); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa306); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa301); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c42); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8404); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x613d); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc115); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc307); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd502); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8301); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8306); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd500); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8208); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c42); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc114); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xc317); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd701); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x40dd); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd500); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa208); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd502); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa306); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa301); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd500); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd702); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x0800); + sram_write(tp, 0xa01a, 0x0000); + sram_write(tp, 0xa006, 0x0fff); + sram_write(tp, 0xa004, 0x0fff); + sram_write(tp, 0xa002, 0x05a3); + sram_write(tp, 0xa000, 0x3591); + sram_write(tp, 0xb820, 0x0210); + r8153_post_ram_code(tp, 0x8146); + } else if (tp->version == RTL_VER_04) { + static u8 usb_patch_b[] = { + 0x08, 0xe0, 0x0f, 0xe0, + 0x18, 0xe0, 0x24, 0xe0, + 0x26, 0xe0, 0x3a, 0xe0, + 0x84, 0xe0, 0x9c, 0xe0, + 0xc2, 0x49, 0x04, 0xf0, + 0x02, 0xc0, 0x00, 0xb8, + 0x14, 0x18, 0x02, 0xc0, + 0x00, 0xb8, 0x2e, 0x18, + 0x06, 0x89, 0x08, 0xc0, + 0x0c, 0x61, 0x92, 0x48, + 0x93, 0x48, 0x0c, 0x89, + 0x02, 0xc0, 0x00, 0xb8, + 0x08, 0x05, 0x40, 0xb4, + 0x16, 0x89, 0x6d, 0xc0, + 0x00, 0x61, 0x95, 0x49, + 0x06, 0xf0, 0xfa, 0xc0, + 0x0c, 0x61, 0x92, 0x48, + 0x93, 0x48, 0x0c, 0x89, + 0x02, 0xc0, 0x00, 0xb8, + 0xe2, 0x04, 0x02, 0xc2, + 0x00, 0xba, 0xec, 0x11, + 0x60, 0x60, 0x85, 0x49, + 0x0d, 0xf1, 0x11, 0xc6, + 0xd2, 0x61, 0x91, 0x49, + 0xfd, 0xf0, 0x74, 0x60, + 0x04, 0x48, 0x74, 0x88, + 0x08, 0xc6, 0x08, 0xc0, + 0xc4, 0x98, 0x01, 0x18, + 0xc0, 0x88, 0x02, 0xc0, + 0x00, 0xb8, 0x6e, 0x12, + 0x04, 0xe4, 0x0d, 0x00, + 0x00, 0xd4, 0xd1, 0x49, + 0x3c, 0xf1, 0xd2, 0x49, + 0x16, 0xf1, 0xd3, 0x49, + 0x18, 0xf1, 0xd4, 0x49, + 0x19, 0xf1, 0xd5, 0x49, + 0x1a, 0xf1, 0xd6, 0x49, + 0x1b, 0xf1, 0xd7, 0x49, + 0x1c, 0xf1, 0xd8, 0x49, + 0x1d, 0xf1, 0xd9, 0x49, + 0x20, 0xf1, 0xda, 0x49, + 0x23, 0xf1, 0xdb, 0x49, + 0x24, 0xf1, 0x02, 0xc4, + 0x00, 0xbc, 0x20, 0x04, + 0xe5, 0x8e, 0x02, 0xc4, + 0x00, 0xbc, 0x14, 0x02, + 0x02, 0xc4, 0x00, 0xbc, + 0x16, 0x02, 0x02, 0xc4, + 0x00, 0xbc, 0x18, 0x02, + 0x02, 0xc4, 0x00, 0xbc, + 0x1a, 0x02, 0x02, 0xc4, + 0x00, 0xbc, 0x1c, 0x02, + 0x02, 0xc4, 0x00, 0xbc, + 0x94, 0x02, 0x10, 0xc7, + 0xe0, 0x8e, 0x02, 0xc4, + 0x00, 0xbc, 0x8a, 0x02, + 0x0b, 0xc7, 0xe4, 0x8e, + 0x02, 0xc4, 0x00, 0xbc, + 0x88, 0x02, 0x02, 0xc4, + 0x00, 0xbc, 0x6e, 0x02, + 0x02, 0xc4, 0x00, 0xbc, + 0x5a, 0x02, 0x30, 0xe4, + 0x0c, 0xc3, 0x60, 0x64, + 0xc5, 0x49, 0x04, 0xf1, + 0x74, 0x64, 0xc4, 0x48, + 0x74, 0x8c, 0x06, 0xc3, + 0x64, 0x8e, 0x02, 0xc4, + 0x00, 0xbc, 0x20, 0x04, + 0x00, 0xd8, 0x00, 0xe4, + 0xb2, 0xc0, 0x00, 0x61, + 0x90, 0x49, 0x09, 0xf1, + 0x8b, 0xc6, 0xca, 0x61, + 0x94, 0x49, 0x0e, 0xf1, + 0xf6, 0xc6, 0xda, 0x60, + 0x81, 0x49, 0x0a, 0xf0, + 0x65, 0x60, 0x03, 0x48, + 0x65, 0x88, 0xef, 0xc6, + 0xdc, 0x60, 0x80, 0x48, + 0xdc, 0x88, 0x05, 0xc6, + 0x00, 0xbe, 0x02, 0xc6, + 0x00, 0xbe, 0x36, 0x13, + 0x4c, 0x17, 0x99, 0xc4, + 0x80, 0x65, 0xd0, 0x49, + 0x04, 0xf1, 0xfa, 0x75, + 0x04, 0xc4, 0x00, 0xbc, + 0x03, 0xc4, 0x00, 0xbc, + 0x9a, 0x00, 0xee, 0x01 }; + static u8 pla_patch_b[] = { + 0x08, 0xe0, 0xea, 0xe0, + 0xf2, 0xe0, 0x04, 0xe1, + 0x09, 0xe1, 0x0e, 0xe1, + 0x46, 0xe1, 0xf7, 0xe1, + 0x14, 0xc2, 0x40, 0x73, + 0xba, 0x48, 0x40, 0x9b, + 0x11, 0xc2, 0x40, 0x73, + 0xb0, 0x49, 0x17, 0xf0, + 0xbf, 0x49, 0x03, 0xf1, + 0x09, 0xc5, 0x00, 0xbd, + 0xb1, 0x49, 0x11, 0xf0, + 0xb1, 0x48, 0x40, 0x9b, + 0x02, 0xc2, 0x00, 0xba, + 0x1a, 0x17, 0x00, 0xe0, + 0x1e, 0xfc, 0xbc, 0xc0, + 0xf0, 0xc0, 0xde, 0xe8, + 0x00, 0x80, 0x00, 0x20, + 0x2c, 0x75, 0xd4, 0x49, + 0x12, 0xf1, 0x32, 0xe0, + 0xf8, 0xc2, 0x46, 0x71, + 0xf7, 0xc2, 0x40, 0x73, + 0xbe, 0x49, 0x03, 0xf1, + 0xf5, 0xc7, 0x02, 0xe0, + 0xf2, 0xc7, 0x4f, 0x30, + 0x26, 0x62, 0xa1, 0x49, + 0xf0, 0xf1, 0x22, 0x72, + 0xa0, 0x49, 0xed, 0xf1, + 0x25, 0x25, 0x18, 0x1f, + 0x97, 0x30, 0x91, 0x30, + 0x36, 0x9a, 0x2c, 0x75, + 0x3c, 0xc3, 0x60, 0x73, + 0xb1, 0x49, 0x0d, 0xf1, + 0xdc, 0x21, 0xbc, 0x25, + 0x30, 0xc6, 0xc0, 0x77, + 0x04, 0x13, 0x21, 0xf0, + 0x03, 0x13, 0x22, 0xf0, + 0x02, 0x13, 0x23, 0xf0, + 0x01, 0x13, 0x24, 0xf0, + 0x08, 0x13, 0x08, 0xf1, + 0x2e, 0x73, 0xba, 0x21, + 0xbd, 0x25, 0x05, 0x13, + 0x03, 0xf1, 0x24, 0xc5, + 0x00, 0xbd, 0xd4, 0x49, + 0x03, 0xf1, 0x1c, 0xc5, + 0x00, 0xbd, 0xc4, 0xc6, + 0xc6, 0x67, 0x2e, 0x75, + 0xd7, 0x22, 0xdd, 0x26, + 0x05, 0x15, 0x1b, 0xf0, + 0x14, 0xc6, 0x00, 0xbe, + 0x13, 0xc5, 0x00, 0xbd, + 0x12, 0xc5, 0x00, 0xbd, + 0xf1, 0x49, 0xfb, 0xf1, + 0xef, 0xe7, 0xf4, 0x49, + 0xfa, 0xf1, 0xec, 0xe7, + 0xf3, 0x49, 0xf7, 0xf1, + 0xe9, 0xe7, 0xf2, 0x49, + 0xf4, 0xf1, 0xe6, 0xe7, + 0xb6, 0xc0, 0x9e, 0x12, + 0xde, 0x11, 0x0a, 0x12, + 0x3c, 0x13, 0x00, 0xa0, + 0xa0, 0xd1, 0x00, 0x00, + 0xc0, 0x75, 0xd0, 0x49, + 0x46, 0xf0, 0x26, 0x72, + 0xa7, 0x49, 0x43, 0xf0, + 0x22, 0x72, 0x25, 0x25, + 0x20, 0x1f, 0x97, 0x30, + 0x91, 0x30, 0x40, 0x73, + 0xf3, 0xc4, 0x1c, 0x40, + 0x04, 0xf0, 0xd7, 0x49, + 0x05, 0xf1, 0x37, 0xe0, + 0x53, 0x48, 0xc0, 0x9d, + 0x08, 0x02, 0x40, 0x66, + 0x64, 0x27, 0x06, 0x16, + 0x30, 0xf1, 0x46, 0x63, + 0x3b, 0x13, 0x2d, 0xf1, + 0x34, 0x9b, 0x18, 0x1b, + 0x93, 0x30, 0x2b, 0xc3, + 0x10, 0x1c, 0x2b, 0xe8, + 0x01, 0x14, 0x25, 0xf1, + 0x00, 0x1d, 0x26, 0x1a, + 0x8a, 0x30, 0x22, 0x73, + 0xb5, 0x25, 0x0e, 0x0b, + 0x00, 0x1c, 0x2c, 0xe8, + 0x1f, 0xc7, 0x27, 0x40, + 0x1a, 0xf1, 0x38, 0xe8, + 0x32, 0x1f, 0x8f, 0x30, + 0x08, 0x1b, 0x24, 0xe8, + 0x36, 0x72, 0x46, 0x77, + 0x00, 0x17, 0x0d, 0xf0, + 0x13, 0xc3, 0x1f, 0x40, + 0x03, 0xf1, 0x00, 0x1f, + 0x46, 0x9f, 0x44, 0x77, + 0x9f, 0x44, 0x5f, 0x44, + 0x17, 0xe8, 0x0a, 0xc7, + 0x27, 0x40, 0x05, 0xf1, + 0x02, 0xc3, 0x00, 0xbb, + 0xfa, 0x18, 0xb0, 0x18, + 0xff, 0xc7, 0x00, 0xbf, + 0xb8, 0xcd, 0xff, 0xff, + 0x02, 0x0c, 0x54, 0xa5, + 0xdc, 0xa5, 0x2f, 0x40, + 0x05, 0xf1, 0x00, 0x14, + 0xfa, 0xf1, 0x01, 0x1c, + 0x02, 0xe0, 0x00, 0x1c, + 0x80, 0xff, 0xb0, 0x49, + 0x04, 0xf0, 0x01, 0x0b, + 0xd3, 0xa1, 0x03, 0xe0, + 0x02, 0x0b, 0xd3, 0xa5, + 0x27, 0x31, 0x20, 0x37, + 0x02, 0x0b, 0xd3, 0xa5, + 0x27, 0x31, 0x20, 0x37, + 0x00, 0x13, 0xfb, 0xf1, + 0x80, 0xff, 0x22, 0x73, + 0xb5, 0x25, 0x18, 0x1e, + 0xde, 0x30, 0xd9, 0x30, + 0x64, 0x72, 0x11, 0x1e, + 0x68, 0x23, 0x16, 0x31, + 0x80, 0xff, 0x08, 0xc2, + 0x40, 0x73, 0x3a, 0x48, + 0x40, 0x9b, 0x06, 0xff, + 0x02, 0xc6, 0x00, 0xbe, + 0x08, 0x16, 0x1e, 0xfc, + 0x2c, 0x75, 0xdc, 0x21, + 0xbc, 0x25, 0x04, 0x13, + 0x0b, 0xf0, 0x03, 0x13, + 0x09, 0xf0, 0x02, 0x13, + 0x07, 0xf0, 0x01, 0x13, + 0x05, 0xf0, 0x08, 0x13, + 0x03, 0xf0, 0x04, 0xc3, + 0x00, 0xbb, 0x03, 0xc3, + 0x00, 0xbb, 0x8c, 0x15, + 0x76, 0x15, 0xa0, 0x64, + 0x40, 0x48, 0xa0, 0x8c, + 0x02, 0xc4, 0x00, 0xbc, + 0x82, 0x00, 0xa0, 0x62, + 0x21, 0x48, 0xa0, 0x8a, + 0x02, 0xc2, 0x00, 0xba, + 0x40, 0x03, 0x33, 0xc5, + 0xa0, 0x74, 0xc0, 0x49, + 0x1f, 0xf0, 0x30, 0xc5, + 0xa0, 0x73, 0x00, 0x13, + 0x04, 0xf1, 0xa2, 0x73, + 0x00, 0x13, 0x14, 0xf0, + 0x28, 0xc5, 0xa0, 0x74, + 0xc8, 0x49, 0x1b, 0xf1, + 0x26, 0xc5, 0xa0, 0x76, + 0xa2, 0x74, 0x01, 0x06, + 0x20, 0x37, 0xa0, 0x9e, + 0xa2, 0x9c, 0x1e, 0xc5, + 0xa2, 0x73, 0x23, 0x40, + 0x10, 0xf8, 0x04, 0xf3, + 0xa0, 0x73, 0x33, 0x40, + 0x0c, 0xf8, 0x15, 0xc5, + 0xa0, 0x74, 0x41, 0x48, + 0xa0, 0x9c, 0x14, 0xc5, + 0xa0, 0x76, 0x62, 0x48, + 0xe0, 0x48, 0xa0, 0x9e, + 0x10, 0xc6, 0x00, 0xbe, + 0x0a, 0xc5, 0xa0, 0x74, + 0x48, 0x48, 0xa0, 0x9c, + 0x0b, 0xc5, 0x20, 0x1e, + 0xa0, 0x9e, 0xe5, 0x48, + 0xa0, 0x9e, 0xf0, 0xe7, + 0xbc, 0xc0, 0xc8, 0xd2, + 0xcc, 0xd2, 0x28, 0xe4, + 0xe6, 0x01, 0xf0, 0xc0, + 0x18, 0x89, 0x00, 0x1d, + 0x3c, 0xc3, 0x64, 0x71, + 0x3c, 0xc0, 0x02, 0x99, + 0x00, 0x61, 0x67, 0x11, + 0x3c, 0xf1, 0x69, 0x33, + 0x35, 0xc0, 0x28, 0x40, + 0xf6, 0xf1, 0x34, 0xc0, + 0x00, 0x19, 0x81, 0x1b, + 0x91, 0xe8, 0x31, 0xc0, + 0x04, 0x1a, 0x84, 0x1b, + 0x8d, 0xe8, 0x82, 0xe8, + 0xa3, 0x49, 0xfe, 0xf0, + 0x2b, 0xc0, 0x7e, 0xe8, + 0xa1, 0x48, 0x28, 0xc0, + 0x84, 0x1b, 0x84, 0xe8, + 0x00, 0x1d, 0x69, 0x33, + 0x00, 0x1e, 0x01, 0x06, + 0xff, 0x18, 0x30, 0x40, + 0xfd, 0xf1, 0x19, 0xc0, + 0x00, 0x76, 0x2e, 0x40, + 0xf7, 0xf1, 0x21, 0x48, + 0x19, 0xc0, 0x84, 0x1b, + 0x75, 0xe8, 0x10, 0xc0, + 0x69, 0xe8, 0xa1, 0x49, + 0xfd, 0xf0, 0x11, 0xc0, + 0x00, 0x1a, 0x84, 0x1b, + 0x6d, 0xe8, 0x62, 0xe8, + 0xa5, 0x49, 0xfe, 0xf0, + 0x09, 0xc0, 0x01, 0x19, + 0x81, 0x1b, 0x66, 0xe8, + 0x54, 0xe0, 0x10, 0xd4, + 0x88, 0xd3, 0xb8, 0x0b, + 0x50, 0xe8, 0x20, 0xb4, + 0x10, 0xd8, 0x84, 0xd4, + 0xfd, 0xc0, 0x52, 0xe8, + 0x48, 0x33, 0xf9, 0xc0, + 0x00, 0x61, 0x9c, 0x20, + 0x9c, 0x24, 0xd0, 0x49, + 0x04, 0xf0, 0x04, 0x11, + 0x02, 0xf1, 0x03, 0xe0, + 0x00, 0x11, 0x06, 0xf1, + 0x5c, 0xc0, 0x00, 0x61, + 0x92, 0x48, 0x00, 0x89, + 0x3a, 0xe0, 0x06, 0x11, + 0x06, 0xf1, 0x55, 0xc0, + 0x00, 0x61, 0x11, 0x48, + 0x00, 0x89, 0x33, 0xe0, + 0x05, 0x11, 0x08, 0xf1, + 0x4e, 0xc0, 0x00, 0x61, + 0x91, 0x49, 0x04, 0xf0, + 0x91, 0x48, 0x00, 0x89, + 0x11, 0xe0, 0xd9, 0xc0, + 0x00, 0x61, 0x98, 0x20, + 0x98, 0x24, 0x25, 0x11, + 0x24, 0xf1, 0x44, 0xc0, + 0x29, 0xe8, 0x95, 0x49, + 0x20, 0xf0, 0xcf, 0xc0, + 0x00, 0x61, 0x98, 0x20, + 0x98, 0x24, 0x25, 0x11, + 0x1a, 0xf1, 0x37, 0xc0, + 0x00, 0x61, 0x92, 0x49, + 0x16, 0xf1, 0x12, 0x48, + 0x00, 0x89, 0x2f, 0xc0, + 0x00, 0x19, 0x00, 0x89, + 0x2d, 0xc0, 0x01, 0x89, + 0x2d, 0xc0, 0x04, 0x19, + 0x81, 0x1b, 0x1c, 0xe8, + 0x2a, 0xc0, 0x14, 0x19, + 0x81, 0x1b, 0x18, 0xe8, + 0x21, 0xc0, 0x0c, 0xe8, + 0x1f, 0xc0, 0x12, 0x48, + 0x81, 0x1b, 0x12, 0xe8, + 0xae, 0xc3, 0x66, 0x71, + 0xae, 0xc0, 0x02, 0x99, + 0x02, 0xc0, 0x00, 0xb8, + 0x96, 0x07, 0x13, 0xc4, + 0x84, 0x98, 0x00, 0x1b, + 0x86, 0x8b, 0x86, 0x73, + 0xbf, 0x49, 0xfe, 0xf1, + 0x80, 0x71, 0x82, 0x72, + 0x80, 0xff, 0x09, 0xc4, + 0x84, 0x98, 0x80, 0x99, + 0x82, 0x9a, 0x86, 0x8b, + 0x86, 0x73, 0xbf, 0x49, + 0xfe, 0xf1, 0x80, 0xff, + 0x08, 0xea, 0x30, 0xd4, + 0x10, 0xc0, 0x12, 0xe8, + 0x8a, 0xd3, 0x28, 0xe4, + 0x2c, 0xe4, 0x00, 0xd8, + 0x00, 0x00, 0x00, 0x00 }; + + r8153_pre_ram_code(tp, 0x8146, 0x7001); + sram_write(tp, 0xb820, 0x0290); + sram_write(tp, 0xa012, 0x0000); + sram_write(tp, 0xa014, 0x2c04); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c07); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c0a); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c0d); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa240); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa104); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x292d); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8620); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa480); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2a2c); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8480); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa101); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2a36); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd056); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2223); + sram_write(tp, 0xa01a, 0x0000); + sram_write(tp, 0xa006, 0x0222); + sram_write(tp, 0xa004, 0x0a35); + sram_write(tp, 0xa002, 0x0a2b); + sram_write(tp, 0xa000, 0xf92c); + sram_write(tp, 0xb820, 0x0210); + r8153_post_ram_code(tp, 0x8146); + + r8153_wdt1_end(tp); + r8153_clear_bp(tp); + + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_EN, 0x0000); + generic_ocp_write(tp, 0xf800, 0xff, sizeof(usb_patch_b), + usb_patch_b, MCU_TYPE_USB); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc26, 0xa000); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc28, 0x180c); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc2a, 0x0506); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc2c, 0x04E0); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc2e, 0x11E4); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc30, 0x125C); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc32, 0x0232); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc34, 0x131E); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc36, 0x0098); + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_EN, 0x00FF); + + if (!(ocp_read_word(tp, MCU_TYPE_PLA, 0xd38e) & BIT(0))) { + ocp_write_word(tp, MCU_TYPE_PLA, 0xd38c, 0x0082); + ocp_write_word(tp, MCU_TYPE_PLA, 0xd38e, 0x0082); + } + + ocp_write_word(tp, MCU_TYPE_PLA, PLA_BP_EN, 0x0000); + generic_ocp_write(tp, 0xf800, 0xff, sizeof(pla_patch_b), + pla_patch_b, MCU_TYPE_PLA); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc26, 0x8000); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc28, 0x1154); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2a, 0x1606); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2c, 0x155a); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2e, 0x0080); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc30, 0x033c); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc32, 0x01a0); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc34, 0x0794); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc36, 0x0000); + ocp_write_word(tp, MCU_TYPE_PLA, PLA_BP_EN, 0x007f); + + ocp_write_word(tp, MCU_TYPE_PLA, 0xd388, 0x08ca); + } else if (tp->version == RTL_VER_05) { + u32 ocp_data; + static u8 usb_patch_c[] = { + 0x08, 0xe0, 0x0a, 0xe0, + 0x14, 0xe0, 0x2e, 0xe0, + 0x3a, 0xe0, 0x41, 0xe0, + 0x70, 0xe0, 0x7b, 0xe0, + 0x02, 0xc5, 0x00, 0xbd, + 0x38, 0x3b, 0xdb, 0x49, + 0x04, 0xf1, 0x06, 0xc3, + 0x00, 0xbb, 0x5a, 0x02, + 0x05, 0xc4, 0x03, 0xc3, + 0x00, 0xbb, 0xa4, 0x04, + 0x7e, 0x02, 0x30, 0xd4, + 0x30, 0x18, 0x18, 0xc1, + 0x0c, 0xe8, 0x17, 0xc6, + 0xc7, 0x65, 0xd0, 0x49, + 0x05, 0xf0, 0x32, 0x48, + 0x02, 0xc2, 0x00, 0xba, + 0x3e, 0x16, 0x02, 0xc2, + 0x00, 0xba, 0x48, 0x16, + 0x02, 0xb4, 0x09, 0xc2, + 0x40, 0x99, 0x0e, 0x48, + 0x42, 0x98, 0x42, 0x70, + 0x8e, 0x49, 0xfe, 0xf1, + 0x02, 0xb0, 0x80, 0xff, + 0xc0, 0xd4, 0xe4, 0x40, + 0x20, 0xd4, 0x0c, 0xc0, + 0x00, 0x63, 0xb5, 0x49, + 0x0c, 0xc0, 0x30, 0x18, + 0x06, 0xc1, 0xed, 0xef, + 0xf8, 0xc7, 0x02, 0xc0, + 0x00, 0xb8, 0xd0, 0x10, + 0xe4, 0x4b, 0x00, 0xd8, + 0x07, 0xc3, 0x70, 0x61, + 0x12, 0x48, 0x70, 0x89, + 0x02, 0xc3, 0x00, 0xbb, + 0x9c, 0x15, 0x20, 0xd4, + 0x2b, 0xc5, 0xa0, 0x77, + 0x00, 0x1c, 0xa0, 0x9c, + 0x28, 0xc5, 0xa0, 0x64, + 0xc0, 0x48, 0xc1, 0x48, + 0xc2, 0x48, 0xa0, 0x8c, + 0xb1, 0x64, 0xc0, 0x48, + 0xb1, 0x8c, 0x20, 0xc5, + 0xa0, 0x64, 0x40, 0x48, + 0x41, 0x48, 0xc2, 0x48, + 0xa0, 0x8c, 0x19, 0xc5, + 0xa4, 0x64, 0x44, 0x48, + 0xa4, 0x8c, 0xb1, 0x64, + 0x40, 0x48, 0xb1, 0x8c, + 0x14, 0xc4, 0x80, 0x73, + 0x13, 0xc4, 0x82, 0x9b, + 0x11, 0x1b, 0x80, 0x9b, + 0x0c, 0xc5, 0xa0, 0x64, + 0x40, 0x48, 0x41, 0x48, + 0x42, 0x48, 0xa0, 0x8c, + 0x05, 0xc5, 0xa0, 0x9f, + 0x02, 0xc5, 0x00, 0xbd, + 0x6c, 0x3a, 0x1e, 0xfc, + 0x10, 0xd8, 0x86, 0xd4, + 0xf8, 0xcb, 0x20, 0xe4, + 0x0a, 0xc0, 0x16, 0x61, + 0x91, 0x48, 0x16, 0x89, + 0x07, 0xc0, 0x11, 0x19, + 0x0c, 0x89, 0x02, 0xc1, + 0x00, 0xb9, 0x02, 0x06, + 0x00, 0xd4, 0x40, 0xb4, + 0xfe, 0xc0, 0x16, 0x61, + 0x91, 0x48, 0x16, 0x89, + 0xfb, 0xc0, 0x11, 0x19, + 0x0c, 0x89, 0x02, 0xc1, + 0x00, 0xb9, 0xd2, 0x05 }; + static u8 pla_patch_c[] = { + 0x08, 0xe0, 0xea, 0xe0, + 0xf2, 0xe0, 0x04, 0xe1, + 0x06, 0xe1, 0x08, 0xe1, + 0x40, 0xe1, 0xf4, 0xe1, + 0x14, 0xc2, 0x40, 0x73, + 0xba, 0x48, 0x40, 0x9b, + 0x11, 0xc2, 0x40, 0x73, + 0xb0, 0x49, 0x17, 0xf0, + 0xbf, 0x49, 0x03, 0xf1, + 0x09, 0xc5, 0x00, 0xbd, + 0xb1, 0x49, 0x11, 0xf0, + 0xb1, 0x48, 0x40, 0x9b, + 0x02, 0xc2, 0x00, 0xba, + 0xde, 0x18, 0x00, 0xe0, + 0x1e, 0xfc, 0xbc, 0xc0, + 0xf0, 0xc0, 0xde, 0xe8, + 0x00, 0x80, 0x00, 0x20, + 0x2c, 0x75, 0xd4, 0x49, + 0x12, 0xf1, 0x32, 0xe0, + 0xf8, 0xc2, 0x46, 0x71, + 0xf7, 0xc2, 0x40, 0x73, + 0xbe, 0x49, 0x03, 0xf1, + 0xf5, 0xc7, 0x02, 0xe0, + 0xf2, 0xc7, 0x4f, 0x30, + 0x26, 0x62, 0xa1, 0x49, + 0xf0, 0xf1, 0x22, 0x72, + 0xa0, 0x49, 0xed, 0xf1, + 0x25, 0x25, 0x18, 0x1f, + 0x97, 0x30, 0x91, 0x30, + 0x36, 0x9a, 0x2c, 0x75, + 0x3c, 0xc3, 0x60, 0x73, + 0xb1, 0x49, 0x0d, 0xf1, + 0xdc, 0x21, 0xbc, 0x25, + 0x30, 0xc6, 0xc0, 0x77, + 0x04, 0x13, 0x21, 0xf0, + 0x03, 0x13, 0x22, 0xf0, + 0x02, 0x13, 0x23, 0xf0, + 0x01, 0x13, 0x24, 0xf0, + 0x08, 0x13, 0x08, 0xf1, + 0x2e, 0x73, 0xba, 0x21, + 0xbd, 0x25, 0x05, 0x13, + 0x03, 0xf1, 0x24, 0xc5, + 0x00, 0xbd, 0xd4, 0x49, + 0x03, 0xf1, 0x1c, 0xc5, + 0x00, 0xbd, 0xc4, 0xc6, + 0xc6, 0x67, 0x2e, 0x75, + 0xd7, 0x22, 0xdd, 0x26, + 0x05, 0x15, 0x1b, 0xf0, + 0x14, 0xc6, 0x00, 0xbe, + 0x13, 0xc5, 0x00, 0xbd, + 0x12, 0xc5, 0x00, 0xbd, + 0xf1, 0x49, 0xfb, 0xf1, + 0xef, 0xe7, 0xf4, 0x49, + 0xfa, 0xf1, 0xec, 0xe7, + 0xf3, 0x49, 0xf7, 0xf1, + 0xe9, 0xe7, 0xf2, 0x49, + 0xf4, 0xf1, 0xe6, 0xe7, + 0xb6, 0xc0, 0x50, 0x14, + 0x90, 0x13, 0xbc, 0x13, + 0xf2, 0x14, 0x00, 0xa0, + 0xa0, 0xd1, 0x00, 0x00, + 0xc0, 0x75, 0xd0, 0x49, + 0x46, 0xf0, 0x26, 0x72, + 0xa7, 0x49, 0x43, 0xf0, + 0x22, 0x72, 0x25, 0x25, + 0x20, 0x1f, 0x97, 0x30, + 0x91, 0x30, 0x40, 0x73, + 0xf3, 0xc4, 0x1c, 0x40, + 0x04, 0xf0, 0xd7, 0x49, + 0x05, 0xf1, 0x37, 0xe0, + 0x53, 0x48, 0xc0, 0x9d, + 0x08, 0x02, 0x40, 0x66, + 0x64, 0x27, 0x06, 0x16, + 0x30, 0xf1, 0x46, 0x63, + 0x3b, 0x13, 0x2d, 0xf1, + 0x34, 0x9b, 0x18, 0x1b, + 0x93, 0x30, 0x2b, 0xc3, + 0x10, 0x1c, 0x2b, 0xe8, + 0x01, 0x14, 0x25, 0xf1, + 0x00, 0x1d, 0x26, 0x1a, + 0x8a, 0x30, 0x22, 0x73, + 0xb5, 0x25, 0x0e, 0x0b, + 0x00, 0x1c, 0x2c, 0xe8, + 0x1f, 0xc7, 0x27, 0x40, + 0x1a, 0xf1, 0x38, 0xe8, + 0x32, 0x1f, 0x8f, 0x30, + 0x08, 0x1b, 0x24, 0xe8, + 0x36, 0x72, 0x46, 0x77, + 0x00, 0x17, 0x0d, 0xf0, + 0x13, 0xc3, 0x1f, 0x40, + 0x03, 0xf1, 0x00, 0x1f, + 0x46, 0x9f, 0x44, 0x77, + 0x9f, 0x44, 0x5f, 0x44, + 0x17, 0xe8, 0x0a, 0xc7, + 0x27, 0x40, 0x05, 0xf1, + 0x02, 0xc3, 0x00, 0xbb, + 0xbe, 0x1a, 0x74, 0x14, + 0xff, 0xc7, 0x00, 0xbf, + 0xb8, 0xcd, 0xff, 0xff, + 0x02, 0x0c, 0x54, 0xa5, + 0xdc, 0xa5, 0x2f, 0x40, + 0x05, 0xf1, 0x00, 0x14, + 0xfa, 0xf1, 0x01, 0x1c, + 0x02, 0xe0, 0x00, 0x1c, + 0x80, 0xff, 0xb0, 0x49, + 0x04, 0xf0, 0x01, 0x0b, + 0xd3, 0xa1, 0x03, 0xe0, + 0x02, 0x0b, 0xd3, 0xa5, + 0x27, 0x31, 0x20, 0x37, + 0x02, 0x0b, 0xd3, 0xa5, + 0x27, 0x31, 0x20, 0x37, + 0x00, 0x13, 0xfb, 0xf1, + 0x80, 0xff, 0x22, 0x73, + 0xb5, 0x25, 0x18, 0x1e, + 0xde, 0x30, 0xd9, 0x30, + 0x64, 0x72, 0x11, 0x1e, + 0x68, 0x23, 0x16, 0x31, + 0x80, 0xff, 0x08, 0xc2, + 0x40, 0x73, 0x3a, 0x48, + 0x40, 0x9b, 0x06, 0xff, + 0x02, 0xc6, 0x00, 0xbe, + 0xcc, 0x17, 0x1e, 0xfc, + 0x2c, 0x75, 0xdc, 0x21, + 0xbc, 0x25, 0x04, 0x13, + 0x0b, 0xf0, 0x03, 0x13, + 0x09, 0xf0, 0x02, 0x13, + 0x07, 0xf0, 0x01, 0x13, + 0x05, 0xf0, 0x08, 0x13, + 0x03, 0xf0, 0x04, 0xc3, + 0x00, 0xbb, 0x03, 0xc3, + 0x00, 0xbb, 0x50, 0x17, + 0x3a, 0x17, 0x02, 0xc6, + 0x00, 0xbe, 0x00, 0x00, + 0x02, 0xc6, 0x00, 0xbe, + 0x00, 0x00, 0x33, 0xc5, + 0xa0, 0x74, 0xc0, 0x49, + 0x1f, 0xf0, 0x30, 0xc5, + 0xa0, 0x73, 0x00, 0x13, + 0x04, 0xf1, 0xa2, 0x73, + 0x00, 0x13, 0x14, 0xf0, + 0x28, 0xc5, 0xa0, 0x74, + 0xc8, 0x49, 0x1b, 0xf1, + 0x26, 0xc5, 0xa0, 0x76, + 0xa2, 0x74, 0x01, 0x06, + 0x20, 0x37, 0xa0, 0x9e, + 0xa2, 0x9c, 0x1e, 0xc5, + 0xa2, 0x73, 0x23, 0x40, + 0x10, 0xf8, 0x04, 0xf3, + 0xa0, 0x73, 0x33, 0x40, + 0x0c, 0xf8, 0x15, 0xc5, + 0xa0, 0x74, 0x41, 0x48, + 0xa0, 0x9c, 0x14, 0xc5, + 0xa0, 0x76, 0x62, 0x48, + 0xe0, 0x48, 0xa0, 0x9e, + 0x10, 0xc6, 0x00, 0xbe, + 0x0a, 0xc5, 0xa0, 0x74, + 0x48, 0x48, 0xa0, 0x9c, + 0x0b, 0xc5, 0x20, 0x1e, + 0xa0, 0x9e, 0xe5, 0x48, + 0xa0, 0x9e, 0xf0, 0xe7, + 0xbc, 0xc0, 0xc8, 0xd2, + 0xcc, 0xd2, 0x28, 0xe4, + 0xfa, 0x01, 0xf0, 0xc0, + 0x18, 0x89, 0x00, 0x1d, + 0x4a, 0xc3, 0x66, 0x62, + 0xa0, 0x49, 0x06, 0xf0, + 0x40, 0xc0, 0x02, 0x71, + 0x60, 0x99, 0x3e, 0xc1, + 0x03, 0xe0, 0x3b, 0xc0, + 0x3c, 0xc1, 0x02, 0x99, + 0x00, 0x61, 0x67, 0x11, + 0x3d, 0xf1, 0x69, 0x33, + 0x33, 0xc0, 0x28, 0x40, + 0xf7, 0xf1, 0x34, 0xc0, + 0x00, 0x19, 0x81, 0x1b, + 0x8d, 0xe8, 0x31, 0xc0, + 0x04, 0x1a, 0x84, 0x1b, + 0x89, 0xe8, 0x7e, 0xe8, + 0xa3, 0x49, 0xfe, 0xf0, + 0x2b, 0xc0, 0x7a, 0xe8, + 0xa1, 0x48, 0x28, 0xc0, + 0x84, 0x1b, 0x80, 0xe8, + 0x00, 0x1d, 0x69, 0x33, + 0x00, 0x1e, 0x01, 0x06, + 0xff, 0x18, 0x30, 0x40, + 0xfd, 0xf1, 0x1f, 0xc0, + 0x00, 0x76, 0x2e, 0x40, + 0xf7, 0xf1, 0x21, 0x48, + 0x19, 0xc0, 0x84, 0x1b, + 0x71, 0xe8, 0x7a, 0xc0, + 0x65, 0xe8, 0xa1, 0x49, + 0xfd, 0xf0, 0x11, 0xc0, + 0x00, 0x1a, 0x84, 0x1b, + 0x69, 0xe8, 0x5e, 0xe8, + 0xa5, 0x49, 0xfe, 0xf0, + 0x09, 0xc0, 0x01, 0x19, + 0x81, 0x1b, 0x62, 0xe8, + 0x4d, 0xe0, 0xb8, 0x0b, + 0x50, 0xe8, 0x83, 0x00, + 0x82, 0x00, 0x20, 0xb4, + 0x10, 0xd8, 0x84, 0xd4, + 0x88, 0xd3, 0xfc, 0xc0, + 0x4d, 0xe8, 0x48, 0x33, + 0xf6, 0xc0, 0x00, 0x61, + 0x9c, 0x20, 0x9c, 0x24, + 0xd0, 0x49, 0x04, 0xf0, + 0x04, 0x11, 0x02, 0xf1, + 0x03, 0xe0, 0x00, 0x11, + 0x06, 0xf1, 0x58, 0xc0, + 0x00, 0x61, 0x92, 0x48, + 0x00, 0x89, 0x32, 0xe0, + 0x06, 0x11, 0x06, 0xf1, + 0x51, 0xc0, 0x00, 0x61, + 0x11, 0x48, 0x00, 0x89, + 0x2b, 0xe0, 0x05, 0x11, + 0x08, 0xf1, 0x4a, 0xc0, + 0x00, 0x61, 0x91, 0x49, + 0x04, 0xf0, 0x91, 0x48, + 0x00, 0x89, 0x11, 0xe0, + 0xd6, 0xc0, 0x00, 0x61, + 0x98, 0x20, 0x98, 0x24, + 0x25, 0x11, 0x1c, 0xf1, + 0x3e, 0xc0, 0x24, 0xe8, + 0x95, 0x49, 0x18, 0xf0, + 0xcc, 0xc0, 0x00, 0x61, + 0x98, 0x20, 0x98, 0x24, + 0x25, 0x11, 0x12, 0xf1, + 0x33, 0xc0, 0x00, 0x61, + 0x92, 0x49, 0x0e, 0xf1, + 0x12, 0x48, 0x00, 0x89, + 0x2b, 0xc0, 0x00, 0x19, + 0x00, 0x89, 0x29, 0xc0, + 0x01, 0x89, 0x25, 0xc0, + 0x0f, 0xe8, 0x23, 0xc0, + 0x12, 0x48, 0x81, 0x1b, + 0x15, 0xe8, 0xbb, 0xc3, + 0x66, 0x62, 0xa0, 0x49, + 0x04, 0xf0, 0x64, 0x71, + 0xb0, 0xc0, 0x02, 0x99, + 0x02, 0xc0, 0x00, 0xb8, + 0xd6, 0x07, 0x13, 0xc4, + 0x84, 0x98, 0x00, 0x1b, + 0x86, 0x8b, 0x86, 0x73, + 0xbf, 0x49, 0xfe, 0xf1, + 0x80, 0x71, 0x82, 0x72, + 0x80, 0xff, 0x09, 0xc4, + 0x84, 0x98, 0x80, 0x99, + 0x82, 0x9a, 0x86, 0x8b, + 0x86, 0x73, 0xbf, 0x49, + 0xfe, 0xf1, 0x80, 0xff, + 0x08, 0xea, 0x10, 0xd4, + 0x30, 0xd4, 0x10, 0xc0, + 0x12, 0xe8, 0x8a, 0xd3, + 0x00, 0xd8, 0x02, 0xc0, + 0x00, 0xb8, 0xe0, 0x08, + 0x00, 0x00, 0x00, 0x00 }; + + ocp_data = ocp_read_word(tp, MCU_TYPE_USB, 0xcfca); + ocp_data &= ~0x4000; + ocp_write_word(tp, MCU_TYPE_USB, 0xcfca, ocp_data); + + r8153_pre_ram_code(tp, 0x8146, 0x7001); + sram_write(tp, 0xb820, 0x0290); + sram_write(tp, 0xa012, 0x0000); + sram_write(tp, 0xa014, 0x2c04); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c07); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c0a); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c0d); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa240); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa104); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x292d); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8620); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa480); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2a2c); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x8480); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa101); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2a36); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xd056); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2223); + sram_write(tp, 0xa01a, 0x0000); + sram_write(tp, 0xa006, 0x0222); + sram_write(tp, 0xa004, 0x0a35); + sram_write(tp, 0xa002, 0x0a2b); + sram_write(tp, 0xa000, 0xf92c); + sram_write(tp, 0xb820, 0x0210); + r8153_post_ram_code(tp, 0x8146); + + r8153_wdt1_end(tp); + r8153_clear_bp(tp); + + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_EN, 0x0000); + generic_ocp_write(tp, 0xf800, 0xff, sizeof(usb_patch_c), + usb_patch_c, MCU_TYPE_USB); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc26, 0xa000); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc28, 0x3b34); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc2a, 0x027c); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc2c, 0x162c); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc2e, 0x10ce); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc30, 0x1578); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc32, 0x3a28); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc34, 0x05f8); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc36, 0x05c8); + if (ocp_read_byte(tp, MCU_TYPE_USB, 0xcfef) & 1) + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_EN, 0x00ff); + else + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_EN, 0x00ef); + + ocp_write_word(tp, MCU_TYPE_PLA, PLA_BP_EN, 0x0000); + generic_ocp_write(tp, 0xf800, 0xff, sizeof(pla_patch_c), + pla_patch_c, MCU_TYPE_PLA); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc26, 0x8000); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc28, 0x1306); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2a, 0x17ca); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2c, 0x171e); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc2e, 0x0000); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc30, 0x0000); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc32, 0x01b4); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc34, 0x07d4); + ocp_write_word(tp, MCU_TYPE_PLA, 0xfc36, 0x0894); + ocp_write_word(tp, MCU_TYPE_PLA, PLA_BP_EN, 0x00e7); + + ocp_write_word(tp, MCU_TYPE_PLA, 0xd388, 0x08ca); + + ocp_data = ocp_read_word(tp, MCU_TYPE_USB, 0xcfca); + ocp_data |= 0x4000; + ocp_write_word(tp, MCU_TYPE_USB, 0xcfca, ocp_data); + } else if (tp->version == RTL_VER_06) { + static u8 usb_patch_d[] = { + 0x08, 0xe0, 0x0e, 0xe0, + 0x11, 0xe0, 0x24, 0xe0, + 0x30, 0xe0, 0x38, 0xe0, + 0x3a, 0xe0, 0x3c, 0xe0, + 0x1e, 0xc3, 0x70, 0x61, + 0x12, 0x48, 0x70, 0x89, + 0x02, 0xc3, 0x00, 0xbb, + 0x02, 0x17, 0x31, 0x19, + 0x02, 0xc3, 0x00, 0xbb, + 0x44, 0x14, 0x30, 0x18, + 0x11, 0xc1, 0x05, 0xe8, + 0x10, 0xc6, 0x02, 0xc2, + 0x00, 0xba, 0x94, 0x17, + 0x02, 0xb4, 0x09, 0xc2, + 0x40, 0x99, 0x0e, 0x48, + 0x42, 0x98, 0x42, 0x70, + 0x8e, 0x49, 0xfe, 0xf1, + 0x02, 0xb0, 0x80, 0xff, + 0xc0, 0xd4, 0xe4, 0x40, + 0x20, 0xd4, 0x0c, 0xc0, + 0x00, 0x63, 0xb5, 0x49, + 0x0c, 0xc0, 0x30, 0x18, + 0x06, 0xc1, 0xed, 0xef, + 0xf8, 0xc7, 0x02, 0xc0, + 0x00, 0xb8, 0x38, 0x12, + 0xe4, 0x4b, 0x00, 0xd8, + 0x0c, 0x61, 0x95, 0x48, + 0x96, 0x48, 0x92, 0x48, + 0x93, 0x48, 0x0c, 0x89, + 0x02, 0xc0, 0x00, 0xb8, + 0x0e, 0x06, 0x02, 0xc5, + 0x00, 0xbd, 0x00, 0x00, + 0x02, 0xc1, 0x00, 0xb9, + 0x00, 0x00, 0x02, 0xc1, + 0x00, 0xb9, 0x00, 0x00 }; + + r8153_pre_ram_code(tp, 0x8146, 0x7002); + sram_write(tp, 0xb820, 0x0290); + sram_write(tp, 0xa012, 0x0000); + sram_write(tp, 0xa014, 0x2c04); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c07); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c07); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2c07); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa240); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0xa104); + ocp_write_word(tp, MCU_TYPE_PLA, 0xb438, 0x2944); + sram_write(tp, 0xa01a, 0x0000); + sram_write(tp, 0xa006, 0x0fff); + sram_write(tp, 0xa004, 0x0fff); + sram_write(tp, 0xa002, 0x0fff); + sram_write(tp, 0xa000, 0x1943); + sram_write(tp, 0xb820, 0x0210); + r8153_post_ram_code(tp, 0x8146); + + r8153_clear_bp(tp); + + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_EN, 0x0000); + generic_ocp_write(tp, 0xf800, 0xff, sizeof(usb_patch_d), + usb_patch_d, MCU_TYPE_USB); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc26, 0xa000); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc28, 0x16de); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc2a, 0x1442); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc2c, 0x1792); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc2e, 0x1236); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc30, 0x0606); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc32, 0x0000); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc34, 0x0000); + ocp_write_word(tp, MCU_TYPE_USB, 0xfc36, 0x0000); + if (ocp_read_byte(tp, MCU_TYPE_USB, 0xcfef) & 1) + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_EN, 0x001b); + else + ocp_write_word(tp, MCU_TYPE_USB, USB_BP_EN, 0x001a); + } +} + +static void r8153b_firmware(struct r8152 *tp) +{ +/* + r8153b_clear_bp(tp, MCU_TYPE_PLA); + r8153b_clear_bp(tp, MCU_TYPE_USB); +*/ +} + +static void r8153b_ups_flags_w0w1(struct r8152 *tp, u32 set, u32 clear) +{ + u32 ocp_data; + + ocp_data = ocp_read_dword(tp, MCU_TYPE_USB, USB_UPS_FLAGS); + ocp_data &= ~clear; + ocp_data |= set; + ocp_write_dword(tp, MCU_TYPE_USB, USB_UPS_FLAGS, ocp_data); +} + static void r8153_aldps_en(struct r8152 *tp, bool enable) { u16 data; @@ -2776,12 +4955,28 @@ static void r8153_aldps_en(struct r8152 *tp, bool enable) data |= EN_ALDPS; ocp_reg_write(tp, OCP_POWER_CFG, data); } else { + int i; + data &= ~EN_ALDPS; ocp_reg_write(tp, OCP_POWER_CFG, data); - msleep(20); + for (i = 0; i < 20; i++) { + usleep_range(1000, 2000); + if (ocp_read_word(tp, MCU_TYPE_PLA, 0xe000) & 0x0100) + break; + } } } +static void r8153b_aldps_en(struct r8152 *tp, bool enable) +{ + r8153_aldps_en(tp, enable); + + if (enable) + r8153b_ups_flags_w0w1(tp, UPS_FLAGS_EN_ALDPS, 0); + else + r8153b_ups_flags_w0w1(tp, 0, UPS_FLAGS_EN_ALDPS); +} + static void r8153_eee_en(struct r8152 *tp, bool enable) { u32 ocp_data; @@ -2802,6 +4997,22 @@ static void r8153_eee_en(struct r8152 *tp, bool enable) ocp_reg_write(tp, OCP_EEE_CFG, config); } +static void r8153b_eee_en(struct r8152 *tp, bool enable) +{ + r8153_eee_en(tp, enable); + + if (enable) + r8153b_ups_flags_w0w1(tp, UPS_FLAGS_EN_EEE, 0); + else + r8153b_ups_flags_w0w1(tp, 0, UPS_FLAGS_EN_EEE); +} + +static void r8153b_enable_fc(struct r8152 *tp) +{ + r8152b_enable_fc(tp); + r8153b_ups_flags_w0w1(tp, UPS_FLAGS_EN_FLOW_CTR, 0); +} + static void r8153_hw_phy_cfg(struct r8152 *tp) { u32 ocp_data; @@ -2814,6 +5025,8 @@ static void r8153_hw_phy_cfg(struct r8152 *tp) r8153_eee_en(tp, false); ocp_reg_write(tp, OCP_EEE_ADV, 0); + r8153_firmware(tp); + if (tp->version == RTL_VER_03) { data = ocp_reg_read(tp, OCP_EEE_CFG); data &= ~CTAP_SHORT_EN; @@ -2852,6 +5065,100 @@ static void r8153_hw_phy_cfg(struct r8152 *tp) set_bit(PHY_RESET, &tp->flags); } +static u32 r8152_efuse_read(struct r8152 *tp, u8 addr) +{ + u32 ocp_data; + + ocp_write_word(tp, MCU_TYPE_PLA, PLA_EFUSE_CMD, EFUSE_READ_CMD | addr); + ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EFUSE_CMD); + ocp_data = (ocp_data & EFUSE_DATA_BIT16) << 9; /* data of bit16 */ + ocp_data |= ocp_read_word(tp, MCU_TYPE_PLA, PLA_EFUSE_DATA); + + return ocp_data; +} + +static void r8153b_hw_phy_cfg(struct r8152 *tp) +{ + u32 ocp_data, ups_flags = 0; + u16 data; + + /* disable ALDPS before updating the PHY parameters */ + r8153b_aldps_en(tp, false); + + /* disable EEE before updating the PHY parameters */ + r8153b_eee_en(tp, false); + ocp_reg_write(tp, OCP_EEE_ADV, 0); + + r8153b_firmware(tp); + + data = sram_read(tp, SRAM_GREEN_CFG); + data |= GREEN_ETH_EN | R_TUNE_EN; + sram_write(tp, SRAM_GREEN_CFG, data); + data = ocp_reg_read(tp, OCP_NCTL_CFG); + data |= PGA_RETURN_EN; + ocp_reg_write(tp, OCP_NCTL_CFG, data); + ups_flags |= UPS_FLAGS_EN_GREEN; + + /* ADC Bias Calibration: + * read efuse offset 0x7d to get a 17-bit data. Remove the dummy/fake + * bit (bit3) to rebuild the real 16-bit data. Write the data to the + * ADC ioffset. + */ + ocp_data = r8152_efuse_read(tp, 0x7d); + data = (u16)(((ocp_data & 0x1fff0) >> 1) | (ocp_data & 0x7)); + if (data != 0xffff) + ocp_reg_write(tp, OCP_ADC_IOFFSET, data); + + /* ups mode tx-link-pulse timing adjustment: + * rg_saw_cnt = OCP reg 0xC426 Bit[13:0] + * swr_cnt_1ms_ini = 16000000 / rg_saw_cnt + */ + ocp_data = ocp_reg_read(tp, 0xc426); + ocp_data &= 0x3fff; + if (ocp_data) { + u32 swr_cnt_1ms_ini; + + swr_cnt_1ms_ini = (16000000 / ocp_data) & SAW_CNT_1MS_MASK; + ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_UPS_CFG); + ocp_data = (ocp_data & ~SAW_CNT_1MS_MASK) | swr_cnt_1ms_ini; + ocp_write_word(tp, MCU_TYPE_USB, USB_UPS_CFG, ocp_data); + } + + ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR); + ocp_data |= PFM_PWM_SWITCH; + ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data); + + /* Advnace EEE */ + if (!r8153_patch_request(tp, true)) { + data = ocp_reg_read(tp, OCP_POWER_CFG); + data |= EEE_CLKDIV_EN; + ocp_reg_write(tp, OCP_POWER_CFG, data); + + data = ocp_reg_read(tp, OCP_DOWN_SPEED); + data |= EN_EEE_CMODE | EN_EEE_1000 | EN_EEE_100 | EN_10M_CLKDIV; + ocp_reg_write(tp, OCP_DOWN_SPEED, data); + + ocp_reg_write(tp, OCP_SYSCLK_CFG, 0); + ocp_reg_write(tp, OCP_SYSCLK_CFG, clk_div_expo(5)); + + ups_flags |= UPS_FLAGS_EN_10M_CKDIV | UPS_FLAGS_250M_CKDIV | + UPS_FLAGS_EN_EEE_CKDIV | UPS_FLAGS_EEE_CMOD_LV_EN | + UPS_FLAGS_EEE_PLLOFF_GIGA; + + r8153_patch_request(tp, false); + } + + r8153b_ups_flags_w0w1(tp, ups_flags, 0); + + r8153b_eee_en(tp, true); + ocp_reg_write(tp, OCP_EEE_ADV, MDIO_EEE_1000T | MDIO_EEE_100TX); + + r8153b_aldps_en(tp, true); + r8153b_enable_fc(tp); + + set_bit(PHY_RESET, &tp->flags); +} + static void r8153_first_init(struct r8152 *tp) { u32 ocp_data; @@ -2895,7 +5202,8 @@ static void r8153_first_init(struct r8152 *tp) rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX); - ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8153_RMS); + ocp_data = tp->netdev->mtu + VLAN_ETH_HLEN + CRC_SIZE; + ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, ocp_data); ocp_write_byte(tp, MCU_TYPE_PLA, PLA_MTPS, MTPS_JUMBO); ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR0); @@ -2911,6 +5219,16 @@ static void r8153_first_init(struct r8152 *tp) /* TX share fifo free credit full threshold */ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_TXFIFO_CTRL, TXFIFO_THR_NORMAL2); + switch (tp->version) { + case RTL_VER_08: + case RTL_VER_09: + ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_BUF_TH, RX_THR_B); + break; + + default: + break; + } + /* rx aggregation */ ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL); ocp_data &= ~(RX_AGG_DISABLE | RX_ZERO_EN); @@ -2947,11 +5265,31 @@ static void r8153_enter_oob(struct r8152 *tp) usleep_range(1000, 2000); } - ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8153_RMS); + ocp_data = tp->netdev->mtu + VLAN_ETH_HLEN + CRC_SIZE; + ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, ocp_data); - ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG); - ocp_data &= ~TEREDO_WAKE_MASK; - ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, ocp_data); + switch (tp->version) { + case RTL_VER_03: + case RTL_VER_04: + case RTL_VER_05: + case RTL_VER_06: + ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG); + ocp_data &= ~TEREDO_WAKE_MASK; + ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, ocp_data); + break; + + case RTL_VER_08: + case RTL_VER_09: + /* Clear teredo wake event. bit[15:8] is the teredo wakeup + * type. Set it to zero. bits[7:0] are the W1C bits about + * the events. Set them to all 1 to clear them. + */ + ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_WAKE_BASE, 0x00ff); + break; + + default: + break; + } rtl_rx_vlan_en(tp, true); @@ -2972,16 +5310,17 @@ static void r8153_enter_oob(struct r8152 *tp) static void rtl8153_disable(struct r8152 *tp) { - r8153_aldps_en(tp, false); + tp->rtl_ops.aldps_enable(tp, false); rtl_disable(tp); rtl_reset_bmu(tp); - r8153_aldps_en(tp, true); + tp->rtl_ops.aldps_enable(tp, true); usb_enable_lpm(tp->udev); } static int rtl8152_set_speed(struct r8152 *tp, u8 autoneg, u16 speed, u8 duplex) { u16 bmcr, anar, gbcr; + enum spd_duplex speed_duplex; int ret = 0; anar = r8152_mdio_read(tp, MII_ADVERTISE); @@ -2998,32 +5337,43 @@ static int rtl8152_set_speed(struct r8152 *tp, u8 autoneg, u16 speed, u8 duplex) if (speed == SPEED_10) { bmcr = 0; anar |= ADVERTISE_10HALF | ADVERTISE_10FULL; + speed_duplex = FORCE_10M_HALF; } else if (speed == SPEED_100) { bmcr = BMCR_SPEED100; anar |= ADVERTISE_100HALF | ADVERTISE_100FULL; + speed_duplex = FORCE_100M_HALF; } else if (speed == SPEED_1000 && tp->mii.supports_gmii) { bmcr = BMCR_SPEED1000; gbcr |= ADVERTISE_1000FULL | ADVERTISE_1000HALF; + speed_duplex = NWAY_1000M_FULL; } else { ret = -EINVAL; goto out; } - if (duplex == DUPLEX_FULL) + if (duplex == DUPLEX_FULL) { bmcr |= BMCR_FULLDPLX; + if (speed != SPEED_1000) + speed_duplex++; + } } else { if (speed == SPEED_10) { - if (duplex == DUPLEX_FULL) + if (duplex == DUPLEX_FULL) { anar |= ADVERTISE_10HALF | ADVERTISE_10FULL; - else + speed_duplex = NWAY_10M_FULL; + } else { anar |= ADVERTISE_10HALF; + speed_duplex = NWAY_10M_HALF; + } } else if (speed == SPEED_100) { if (duplex == DUPLEX_FULL) { anar |= ADVERTISE_10HALF | ADVERTISE_10FULL; anar |= ADVERTISE_100HALF | ADVERTISE_100FULL; + speed_duplex = NWAY_100M_FULL; } else { anar |= ADVERTISE_10HALF; anar |= ADVERTISE_100HALF; + speed_duplex = NWAY_100M_HALF; } } else if (speed == SPEED_1000 && tp->mii.supports_gmii) { if (duplex == DUPLEX_FULL) { @@ -3035,6 +5385,7 @@ static int rtl8152_set_speed(struct r8152 *tp, u8 autoneg, u16 speed, u8 duplex) anar |= ADVERTISE_100HALF; gbcr |= ADVERTISE_1000HALF; } + speed_duplex = NWAY_1000M_FULL; } else { ret = -EINVAL; goto out; @@ -3052,6 +5403,17 @@ static int rtl8152_set_speed(struct r8152 *tp, u8 autoneg, u16 speed, u8 duplex) r8152_mdio_write(tp, MII_ADVERTISE, anar); r8152_mdio_write(tp, MII_BMCR, bmcr); + switch (tp->version) { + case RTL_VER_08: + case RTL_VER_09: + r8153b_ups_flags_w0w1(tp, ups_flags_speed(speed_duplex), + UPS_FLAGS_SPEED_MASK); + break; + + default: + break; + } + if (bmcr & BMCR_RESET) { int i; @@ -3087,6 +5449,8 @@ static void rtl8152_down(struct r8152 *tp) r8152_aldps_en(tp, false); r8152b_enter_oob(tp); r8152_aldps_en(tp, true); + if (tp->version == RTL_VER_01) + rtl8152_set_speed(tp, AUTONEG_ENABLE, SPEED_10, DUPLEX_FULL); } static void rtl8153_up(struct r8152 *tp) @@ -3094,12 +5458,12 @@ static void rtl8153_up(struct r8152 *tp) if (test_bit(RTL8152_UNPLUG, &tp->flags)) return; - r8153_u1u2en(tp, false); - r8153_aldps_en(tp, false); + tp->rtl_ops.u1u2_enable(tp, false); + tp->rtl_ops.aldps_enable(tp, false); r8153_first_init(tp); - r8153_aldps_en(tp, true); - r8153_u2p3en(tp, true); - r8153_u1u2en(tp, true); + tp->rtl_ops.aldps_enable(tp, true); + tp->rtl_ops.u2p3_enable(tp, true); + tp->rtl_ops.u1u2_enable(tp, true); usb_enable_lpm(tp->udev); } @@ -3110,12 +5474,12 @@ static void rtl8153_down(struct r8152 *tp) return; } - r8153_u1u2en(tp, false); - r8153_u2p3en(tp, false); - r8153_power_cut_en(tp, false); - r8153_aldps_en(tp, false); + tp->rtl_ops.u1u2_enable(tp, false); + tp->rtl_ops.u2p3_enable(tp, false); + tp->rtl_ops.power_cut_en(tp, false); + tp->rtl_ops.aldps_enable(tp, false); r8153_enter_oob(tp); - r8153_aldps_en(tp, true); + tp->rtl_ops.aldps_enable(tp, true); } static bool rtl8152_in_nway(struct r8152 *tp) @@ -3170,10 +5534,8 @@ static void set_carrier(struct r8152 *tp) } } -static void rtl_work_func_t(struct work_struct *work) +static inline void __rtl_work_func(struct r8152 *tp) { - struct r8152 *tp = container_of(work, struct r8152, schedule.work); - /* If the device is unplugged or !netif_running(), the workqueue * doesn't need to wake the device, and could return directly. */ @@ -3194,8 +5556,8 @@ static void rtl_work_func_t(struct work_struct *work) if (test_and_clear_bit(RTL8152_LINK_CHG, &tp->flags)) set_carrier(tp); - if (test_and_clear_bit(RTL8152_SET_RX_MODE, &tp->flags)) - _rtl8152_set_rx_mode(tp->netdev); + if (test_bit(RTL8152_SET_RX_MODE, &tp->flags)) + rtl8152_set_rx_mode(tp->netdev); /* don't schedule napi before linking */ if (test_and_clear_bit(SCHEDULE_NAPI, &tp->flags) && @@ -3208,10 +5570,8 @@ out1: usb_autopm_put_interface(tp->intf); } -static void rtl_hw_phy_work_func_t(struct work_struct *work) +static inline void __rtl_hw_phy_work_func(struct r8152 *tp) { - struct r8152 *tp = container_of(work, struct r8152, hw_phy_work.work); - if (test_bit(RTL8152_UNPLUG, &tp->flags)) return; @@ -3229,7 +5589,41 @@ static void rtl_hw_phy_work_func_t(struct work_struct *work) usb_autopm_put_interface(tp->intf); } -#ifdef CONFIG_PM_SLEEP +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) + +static void rtl_work_func_t(void *data) +{ + struct r8152 *tp = (struct r8152 *)data; + + __rtl_work_func(tp); +} + +static void rtl_hw_phy_work_func_t(void *data) +{ + struct r8152 *tp = (struct r8152 *)data; + + __rtl_hw_phy_work_func(tp); +} + +#else + +static void rtl_work_func_t(struct work_struct *work) +{ + struct r8152 *tp = container_of(work, struct r8152, schedule.work); + + __rtl_work_func(tp); +} + +static void rtl_hw_phy_work_func_t(struct work_struct *work) +{ + struct r8152 *tp = container_of(work, struct r8152, hw_phy_work.work); + + __rtl_hw_phy_work_func(tp); +} + +#endif + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23) && defined(CONFIG_PM_SLEEP) static int rtl_notifier(struct notifier_block *nb, unsigned long action, void *data) { @@ -3256,18 +5650,35 @@ static int rtl_notifier(struct notifier_block *nb, unsigned long action, } #endif +static int rtk_disable_diag(struct r8152 *tp) +{ + tp->rtk_enable_diag--; + ocp_write_word(tp, MCU_TYPE_PLA, PLA_OCP_GPHY_BASE, tp->ocp_base); + netif_info(tp, drv, tp->netdev, "disable rtk diag %d\n", + tp->rtk_enable_diag); + mutex_unlock(&tp->control); + usb_autopm_put_interface(tp->intf); + + return 0; +} + static int rtl8152_open(struct net_device *netdev) { struct r8152 *tp = netdev_priv(netdev); int res = 0; + if (unlikely(tp->rtk_enable_diag)) + return -EBUSY; + res = alloc_all_mem(tp); if (res) goto out; res = usb_autopm_get_interface(tp->intf); - if (res < 0) - goto out_free; + if (res < 0) { + free_all_mem(tp); + goto out; + } mutex_lock(&tp->control); @@ -3283,24 +5694,19 @@ static int rtl8152_open(struct net_device *netdev) netif_device_detach(tp->netdev); netif_warn(tp, ifup, netdev, "intr_urb submit failed: %d\n", res); - goto out_unlock; + free_all_mem(tp); + } else { + napi_enable(&tp->napi); } - napi_enable(&tp->napi); mutex_unlock(&tp->control); usb_autopm_put_interface(tp->intf); -#ifdef CONFIG_PM_SLEEP +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23) && defined(CONFIG_PM_SLEEP) tp->pm_notifier.notifier_call = rtl_notifier; register_pm_notifier(&tp->pm_notifier); #endif - return 0; -out_unlock: - mutex_unlock(&tp->control); - usb_autopm_put_interface(tp->intf); -out_free: - free_all_mem(tp); out: return res; } @@ -3310,7 +5716,7 @@ static int rtl8152_close(struct net_device *netdev) struct r8152 *tp = netdev_priv(netdev); int res = 0; -#ifdef CONFIG_PM_SLEEP +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23) && defined(CONFIG_PM_SLEEP) unregister_pm_notifier(&tp->pm_notifier); #endif napi_disable(&tp->napi); @@ -3319,6 +5725,11 @@ static int rtl8152_close(struct net_device *netdev) cancel_delayed_work_sync(&tp->schedule); netif_stop_queue(netdev); + if (unlikely(tp->rtk_enable_diag)) { + netif_err(tp, drv, tp->netdev, "rtk diag isn't disabled\n"); + rtk_disable_diag(tp); + } + res = usb_autopm_get_interface(tp->intf); if (res < 0 || test_bit(RTL8152_UNPLUG, &tp->flags)) { rtl_drop_queued_tx(tp); @@ -3327,7 +5738,9 @@ static int rtl8152_close(struct net_device *netdev) mutex_lock(&tp->control); tp->rtl_ops.down(tp); - +#if defined(RTL8152_S5_WOL) && defined(CONFIG_PM) + res = rtl_s5_wol(tp); +#endif mutex_unlock(&tp->control); usb_autopm_put_interface(tp->intf); @@ -3355,6 +5768,18 @@ static void r8152b_init(struct r8152 *tp) if (test_bit(RTL8152_UNPLUG, &tp->flags)) return; +#if 0 + /* Clear EP3 Fifo before using interrupt transfer */ + if (ocp_read_byte(tp, MCU_TYPE_USB, 0xb963) & 0x80) { + ocp_write_byte(tp, MCU_TYPE_USB, 0xb963, 0x08); + ocp_write_byte(tp, MCU_TYPE_USB, 0xb963, 0x40); + ocp_write_byte(tp, MCU_TYPE_USB, 0xb963, 0x00); + ocp_write_byte(tp, MCU_TYPE_USB, 0xb968, 0x00); + ocp_write_word(tp, MCU_TYPE_USB, 0xb010, 0x00e0); + ocp_write_byte(tp, MCU_TYPE_USB, 0xb963, 0x04); + } +#endif + data = r8152_mdio_read(tp, MII_BMCR); if (data & BMCR_PDOWN) { data &= ~BMCR_PDOWN; @@ -3382,6 +5807,13 @@ static void r8152b_init(struct r8152 *tp) SPDWN_RXDV_MSK | SPDWN_LINKCHG_MSK; ocp_write_word(tp, MCU_TYPE_PLA, PLA_GPHY_INTR_IMR, ocp_data); + ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_TIMER); + ocp_data |= BIT(15); + ocp_write_word(tp, MCU_TYPE_USB, USB_USB_TIMER, ocp_data); + ocp_write_word(tp, MCU_TYPE_USB, 0xcbfc, 0x03e8); + ocp_data &= ~BIT(15); + ocp_write_word(tp, MCU_TYPE_USB, USB_USB_TIMER, ocp_data); + rtl_tally_reset(tp); /* enable rx aggregation */ @@ -3501,6 +5933,89 @@ static void r8153_init(struct r8152 *tp) rtl_tally_reset(tp); r8153_u2p3en(tp, true); + + switch (tp->udev->speed) { + case USB_SPEED_SUPER: +#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,6,0) + case USB_SPEED_SUPER_PLUS: +#endif + tp->coalesce = COALESCE_SUPER; + break; + case USB_SPEED_HIGH: + tp->coalesce = COALESCE_HIGH; + break; + default: + tp->coalesce = COALESCE_SLOW; + break; + } +} + +static void r8153b_init(struct r8152 *tp) +{ + u32 ocp_data; + u16 data; + int i; + + if (test_bit(RTL8152_UNPLUG, &tp->flags)) + return; + + r8153b_u1u2en(tp, false); + + for (i = 0; i < 500; i++) { + if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) & + AUTOLOAD_DONE) + break; + msleep(20); + } + + for (i = 0; i < 500; i++) { + ocp_data = ocp_reg_read(tp, OCP_PHY_STATUS) & PHY_STAT_MASK; + if (ocp_data == PHY_STAT_LAN_ON || ocp_data == PHY_STAT_PWRDN) + break; + msleep(20); + } + + data = r8152_mdio_read(tp, MII_BMCR); + if (data & BMCR_PDOWN) { + data &= ~BMCR_PDOWN; + r8152_mdio_write(tp, MII_BMCR, data); + } + + for (i = 0; i < 500; i++) { + ocp_data = ocp_reg_read(tp, OCP_PHY_STATUS) & PHY_STAT_MASK; + if (ocp_data == PHY_STAT_LAN_ON) + break; + msleep(20); + } + + r8153_u2p3en(tp, false); + + /* MSC timer = 0xfff * 8ms = 32760 ms */ + ocp_write_word(tp, MCU_TYPE_USB, USB_MSC_TIMER, 0x0fff); + + /* U1/U2/L1 idle timer. 500 us */ + ocp_write_word(tp, MCU_TYPE_USB, USB_U1U2_TIMER, 500); + + r8153B_power_cut_en(tp, false); + r8153b_ups_en(tp, false); + r8153b_queue_wake(tp, false); + r8153b_u1u2en(tp, true); + + /* MAC clock speed down */ + ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2); + ocp_data |= MAC_CLK_SPDWN_EN; + ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2, ocp_data); + + rtl_tally_reset(tp); + + tp->coalesce = 15000; /* 15 us */ +} + +static bool rtl_vendor_mode(struct usb_interface *intf) +{ + struct usb_host_interface *alt = intf->cur_altsetting; + + return alt->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC; } static int rtl8152_pre_reset(struct usb_interface *intf) @@ -3560,6 +6075,9 @@ static bool delay_autosuspend(struct r8152 *tp) bool sw_linking = !!netif_carrier_ok(tp->netdev); bool hw_linking = !!(rtl8152_get_speed(tp) & LINK_STATUS); +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36) +#define work_busy(x) 0 +#endif /* This means a linking change occurs and the driver doesn't detect it, * yet. If the driver has disabled tx/rx and hw is linking on, the * device wouldn't wake up by receiving any packet. @@ -3572,8 +6090,6 @@ static bool delay_autosuspend(struct r8152 *tp) */ if (!sw_linking && tp->rtl_ops.in_nway(tp)) return true; - else if (!skb_queue_empty(&tp->tx_queue)) - return true; else return false; } @@ -3670,11 +6186,8 @@ static int rtl8152_resume(struct usb_interface *intf) mutex_lock(&tp->control); - if (!test_bit(SELECTIVE_SUSPEND, &tp->flags)) { - tp->rtl_ops.init(tp); - queue_delayed_work(system_long_wq, &tp->hw_phy_work, 0); + if (!test_bit(SELECTIVE_SUSPEND, &tp->flags)) netif_device_attach(tp->netdev); - } if (netif_running(tp->netdev) && tp->netdev->flags & IFF_UP) { if (test_bit(SELECTIVE_SUSPEND, &tp->flags)) { @@ -3707,6 +6220,10 @@ static int rtl8152_reset_resume(struct usb_interface *intf) struct r8152 *tp = usb_get_intfdata(intf); clear_bit(SELECTIVE_SUSPEND, &tp->flags); + mutex_lock(&tp->control); + tp->rtl_ops.init(tp); + queue_delayed_work(system_long_wq, &tp->hw_phy_work, 0); + mutex_unlock(&tp->control); return rtl8152_resume(intf); } @@ -3714,6 +6231,9 @@ static void rtl8152_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) { struct r8152 *tp = netdev_priv(dev); + if (unlikely(tp->rtk_enable_diag)) + return; + if (usb_autopm_get_interface(tp->intf) < 0) return; @@ -3738,6 +6258,9 @@ static int rtl8152_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) if (!rtl_can_wakeup(tp)) return -EOPNOTSUPP; + if (unlikely(tp->rtk_enable_diag)) + return -EBUSY; + ret = usb_autopm_get_interface(tp->intf); if (ret < 0) goto out_set_wol; @@ -3783,18 +6306,116 @@ static int rtl8152_get_settings(struct net_device *netdev, struct ethtool_cmd *cmd) { struct r8152 *tp = netdev_priv(netdev); - int ret; + u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0; + int ret, advert; - if (!tp->mii.mdio_read) - return -EOPNOTSUPP; + if (unlikely(tp->rtk_enable_diag)) + return -EBUSY; ret = usb_autopm_get_interface(tp->intf); if (ret < 0) goto out; + cmd->supported = + (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | + SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | + SUPPORTED_Autoneg | SUPPORTED_MII); + if (tp->mii.supports_gmii) + cmd->supported |= SUPPORTED_1000baseT_Full; + + /* only supports twisted-pair */ + cmd->port = PORT_MII; + + /* only supports internal transceiver */ + cmd->transceiver = XCVR_INTERNAL; + cmd->phy_address = 32; +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30) + cmd->mdio_support = ETH_MDIO_SUPPORTS_C22; +#endif + cmd->advertising = ADVERTISED_MII; + mutex_lock(&tp->control); - ret = mii_ethtool_gset(&tp->mii, cmd); + bmcr = r8152_mdio_read(tp, MII_BMCR); + bmsr = r8152_mdio_read(tp, MII_BMSR); + if (tp->mii.supports_gmii) { + ctrl1000 = r8152_mdio_read(tp, MII_CTRL1000); + stat1000 = r8152_mdio_read(tp, MII_STAT1000); + } + + advert = r8152_mdio_read(tp, MII_ADVERTISE); + if (advert & ADVERTISE_10HALF) + cmd->advertising |= ADVERTISED_10baseT_Half; + if (advert & ADVERTISE_10FULL) + cmd->advertising |= ADVERTISED_10baseT_Full; + if (advert & ADVERTISE_100HALF) + cmd->advertising |= ADVERTISED_100baseT_Half; + if (advert & ADVERTISE_100FULL) + cmd->advertising |= ADVERTISED_100baseT_Full; + if (advert & ADVERTISE_PAUSE_CAP) + cmd->advertising |= ADVERTISED_Pause; + if (advert & ADVERTISE_PAUSE_ASYM) + cmd->advertising |= ADVERTISED_Asym_Pause; + if (tp->mii.supports_gmii) { + if (ctrl1000 & ADVERTISE_1000HALF) + cmd->advertising |= ADVERTISED_1000baseT_Half; + if (ctrl1000 & ADVERTISE_1000FULL) + cmd->advertising |= ADVERTISED_1000baseT_Full; + } + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31) + if (bmsr & BMSR_ANEGCOMPLETE) { + advert = r8152_mdio_read(tp, MII_LPA); + if (advert & LPA_LPACK) + cmd->lp_advertising |= ADVERTISED_Autoneg; + if (advert & ADVERTISE_10HALF) + cmd->lp_advertising |= + ADVERTISED_10baseT_Half; + if (advert & ADVERTISE_10FULL) + cmd->lp_advertising |= + ADVERTISED_10baseT_Full; + if (advert & ADVERTISE_100HALF) + cmd->lp_advertising |= + ADVERTISED_100baseT_Half; + if (advert & ADVERTISE_100FULL) + cmd->lp_advertising |= + ADVERTISED_100baseT_Full; + + if (tp->mii.supports_gmii) { + if (stat1000 & LPA_1000HALF) + cmd->lp_advertising |= + ADVERTISED_1000baseT_Half; + if (stat1000 & LPA_1000FULL) + cmd->lp_advertising |= + ADVERTISED_1000baseT_Full; + } + } else { + cmd->lp_advertising = 0; + } +#endif + + if (bmcr & BMCR_ANENABLE) { + cmd->advertising |= ADVERTISED_Autoneg; + cmd->autoneg = AUTONEG_ENABLE; + } else { + cmd->autoneg = AUTONEG_DISABLE; + } + + if (netif_carrier_ok(tp->netdev)) { + u8 speed = rtl8152_get_speed(tp); + + if (speed & _100bps) + cmd->speed = SPEED_100; + else if (speed & _10bps) + cmd->speed = SPEED_10; + else if (tp->mii.supports_gmii && (speed & _1000bps)) + cmd->speed = SPEED_1000; + + cmd->duplex = (speed & FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF; + } else { + cmd->speed = 0; + cmd->duplex = 255; + } mutex_unlock(&tp->control); @@ -3809,6 +6430,9 @@ static int rtl8152_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) struct r8152 *tp = netdev_priv(dev); int ret; + if (unlikely(tp->rtk_enable_diag)) + return -EBUSY; + ret = usb_autopm_get_interface(tp->intf); if (ret < 0) goto out; @@ -3846,6 +6470,12 @@ static const char rtl8152_gstrings[][ETH_GSTRING_LEN] = { "tx_underrun", }; +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33) +static int rtl8152_get_sset_count(struct net_device *dev) +{ + return ARRAY_SIZE(rtl8152_gstrings); +} +#else static int rtl8152_get_sset_count(struct net_device *dev, int sset) { switch (sset) { @@ -3855,6 +6485,7 @@ static int rtl8152_get_sset_count(struct net_device *dev, int sset) return -EOPNOTSUPP; } } +#endif static void rtl8152_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, u64 *data) @@ -3862,6 +6493,9 @@ static void rtl8152_get_ethtool_stats(struct net_device *dev, struct r8152 *tp = netdev_priv(dev); struct tally_counter tally; + if (unlikely(tp->rtk_enable_diag)) + return; + if (usb_autopm_get_interface(tp->intf) < 0) return; @@ -3893,6 +6527,7 @@ static void rtl8152_get_strings(struct net_device *dev, u32 stringset, u8 *data) } } +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) static int r8152_get_eee(struct r8152 *tp, struct ethtool_eee *eee) { u32 ocp_data, lp, adv, supported = 0; @@ -3973,12 +6608,29 @@ static int r8153_set_eee(struct r8152 *tp, struct ethtool_eee *eee) return 0; } +static int r8153b_set_eee(struct r8152 *tp, struct ethtool_eee *eee) +{ + u16 val = ethtool_adv_to_mmd_eee_adv_t(eee->advertised); + + r8153b_eee_en(tp, eee->eee_enabled); + + if (!eee->eee_enabled) + val = 0; + + ocp_reg_write(tp, OCP_EEE_ADV, val); + + return 0; +} + static int rtl_ethtool_get_eee(struct net_device *net, struct ethtool_eee *edata) { struct r8152 *tp = netdev_priv(net); int ret; + if (unlikely(tp->rtk_enable_diag)) + return -EBUSY; + ret = usb_autopm_get_interface(tp->intf); if (ret < 0) goto out; @@ -4001,6 +6653,9 @@ rtl_ethtool_set_eee(struct net_device *net, struct ethtool_eee *edata) struct r8152 *tp = netdev_priv(net); int ret; + if (unlikely(tp->rtk_enable_diag)) + return -EBUSY; + ret = usb_autopm_get_interface(tp->intf); if (ret < 0) goto out; @@ -4018,12 +6673,16 @@ rtl_ethtool_set_eee(struct net_device *net, struct ethtool_eee *edata) out: return ret; } +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */ static int rtl8152_nway_reset(struct net_device *dev) { struct r8152 *tp = netdev_priv(dev); int ret; + if (unlikely(tp->rtk_enable_diag)) + return -EBUSY; + ret = usb_autopm_get_interface(tp->intf); if (ret < 0) goto out; @@ -4048,6 +6707,7 @@ static int rtl8152_get_coalesce(struct net_device *netdev, switch (tp->version) { case RTL_VER_01: case RTL_VER_02: + case RTL_VER_07: return -EOPNOTSUPP; default: break; @@ -4067,6 +6727,7 @@ static int rtl8152_set_coalesce(struct net_device *netdev, switch (tp->version) { case RTL_VER_01: case RTL_VER_02: + case RTL_VER_07: return -EOPNOTSUPP; default: break; @@ -4095,7 +6756,7 @@ static int rtl8152_set_coalesce(struct net_device *netdev, return ret; } -static const struct ethtool_ops ops = { +static struct ethtool_ops ops = { .get_drvinfo = rtl8152_get_drvinfo, .get_settings = rtl8152_get_settings, .set_settings = rtl8152_set_settings, @@ -4108,23 +6769,214 @@ static const struct ethtool_ops ops = { .get_strings = rtl8152_get_strings, .get_sset_count = rtl8152_get_sset_count, .get_ethtool_stats = rtl8152_get_ethtool_stats, +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0) + .get_tx_csum = ethtool_op_get_tx_csum, + .set_tx_csum = ethtool_op_set_tx_csum, + .get_sg = ethtool_op_get_sg, + .set_sg = ethtool_op_set_sg, +#ifdef NETIF_F_TSO + .get_tso = ethtool_op_get_tso, + .set_tso = ethtool_op_set_tso, +#endif +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0) */ .get_coalesce = rtl8152_get_coalesce, .set_coalesce = rtl8152_set_coalesce, +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) .get_eee = rtl_ethtool_get_eee, .set_eee = rtl_ethtool_set_eee, +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */ }; +static int rtltool_ioctl(struct r8152 *tp, struct ifreq *ifr) +{ + struct net_device *netdev = tp->netdev; + struct rtltool_cmd my_cmd, *myptr; + struct usb_device_info *uinfo; + struct usb_device *udev; + __le32 ocp_data; + void *buffer; + int ret; + + myptr = (struct rtltool_cmd *)ifr->ifr_data; + if (copy_from_user(&my_cmd, myptr, sizeof(my_cmd))) + return -EFAULT; + + ret = 0; + + switch (my_cmd.cmd) { + case RTLTOOL_PLA_OCP_READ_DWORD: + pla_ocp_read(tp, (u16)my_cmd.offset, sizeof(ocp_data), + &ocp_data); + my_cmd.data = __le32_to_cpu(ocp_data); + + if (copy_to_user(myptr, &my_cmd, sizeof(my_cmd))) { + ret = -EFAULT; + break; + } + break; + + case RTLTOOL_PLA_OCP_WRITE_DWORD: + if (!tp->rtk_enable_diag && net_ratelimit()) + netif_warn(tp, drv, netdev, + "rtk diag isn't enable\n"); + + ocp_data = __cpu_to_le32(my_cmd.data); + pla_ocp_write(tp, (u16)my_cmd.offset, (u16)my_cmd.byteen, + sizeof(ocp_data), &ocp_data); + break; + + case RTLTOOL_USB_OCP_READ_DWORD: + usb_ocp_read(tp, (u16)my_cmd.offset, sizeof(ocp_data), + &ocp_data); + my_cmd.data = __le32_to_cpu(ocp_data); + + if (copy_to_user(myptr, &my_cmd, sizeof(my_cmd))) { + ret = -EFAULT; + break; + } + break; + + + case RTLTOOL_USB_OCP_WRITE_DWORD: + if (!tp->rtk_enable_diag && net_ratelimit()) + netif_warn(tp, drv, netdev, + "rtk diag isn't enable\n"); + + ocp_data = __cpu_to_le32(my_cmd.data); + usb_ocp_write(tp, (u16)my_cmd.offset, (u16)my_cmd.byteen, + sizeof(ocp_data), &ocp_data); + break; + + case RTLTOOL_PLA_OCP_READ: + buffer = kmalloc(my_cmd.data, GFP_KERNEL); + if (!buffer) { + ret = -ENOMEM; + break; + } + + pla_ocp_read(tp, (u16)my_cmd.offset, my_cmd.data, buffer); + + if (copy_to_user(my_cmd.buf, buffer, my_cmd.data)) + ret = -EFAULT; + + kfree(buffer); + break; + + case RTLTOOL_PLA_OCP_WRITE: + if (!tp->rtk_enable_diag && net_ratelimit()) + netif_warn(tp, drv, netdev, + "rtk diag isn't enable\n"); + + buffer = kmalloc(my_cmd.data, GFP_KERNEL); + if (!buffer) { + ret = -ENOMEM; + break; + } + + if (copy_from_user(buffer, my_cmd.buf, my_cmd.data)) { + ret = -EFAULT; + kfree(buffer); + break; + } + + pla_ocp_write(tp, (u16)my_cmd.offset, (u16)my_cmd.byteen, + my_cmd.data, buffer); + kfree(buffer); + break; + + case RTLTOOL_USB_OCP_READ: + buffer = kmalloc(my_cmd.data, GFP_KERNEL); + if (!buffer) { + ret = -ENOMEM; + break; + } + + usb_ocp_read(tp, (u16)my_cmd.offset, my_cmd.data, buffer); + + if (copy_to_user(my_cmd.buf, buffer, my_cmd.data)) + ret = -EFAULT; + + kfree(buffer); + break; + + case RTLTOOL_USB_OCP_WRITE: + if (!tp->rtk_enable_diag && net_ratelimit()) + netif_warn(tp, drv, netdev, + "rtk diag isn't enable\n"); + + buffer = kmalloc(my_cmd.data, GFP_KERNEL); + if (!buffer) { + ret = -ENOMEM; + break; + } + + if (copy_from_user(buffer, my_cmd.buf, my_cmd.data)) { + ret = -EFAULT; + kfree(buffer); + break; + } + + usb_ocp_write(tp, (u16)my_cmd.offset, (u16)my_cmd.byteen, + my_cmd.data, buffer); + kfree(buffer); + break; + + case RTLTOOL_USB_INFO: + uinfo = (struct usb_device_info *)&my_cmd.nic_info; + udev = tp->udev; + uinfo->idVendor = __le16_to_cpu(udev->descriptor.idVendor); + uinfo->idProduct = __le16_to_cpu(udev->descriptor.idProduct); + uinfo->bcdDevice = __le16_to_cpu(udev->descriptor.bcdDevice); + strlcpy(uinfo->devpath, udev->devpath, sizeof(udev->devpath)); + pla_ocp_read(tp, PLA_IDR, sizeof(uinfo->dev_addr), + uinfo->dev_addr); + + if (copy_to_user(myptr, &my_cmd, sizeof(my_cmd))) + ret = -EFAULT; + + break; + + case RTL_ENABLE_USB_DIAG: + ret = usb_autopm_get_interface(tp->intf); + if (ret < 0) + break; + + mutex_lock(&tp->control); + tp->rtk_enable_diag++; + netif_info(tp, drv, netdev, "enable rtk diag %d\n", + tp->rtk_enable_diag); + break; + + case RTL_DISABLE_USB_DIAG: + if (!tp->rtk_enable_diag) { + netif_err(tp, drv, netdev, + "Invalid using rtk diag\n"); + ret = -EPERM; + break; + } + + rtk_disable_diag(tp); + break; + + default: + ret = -EOPNOTSUPP; + break; + } + + return ret; +} + static int rtl8152_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd) { struct r8152 *tp = netdev_priv(netdev); struct mii_ioctl_data *data = if_mii(rq); - int res; + int ret; if (test_bit(RTL8152_UNPLUG, &tp->flags)) return -ENODEV; - res = usb_autopm_get_interface(tp->intf); - if (res < 0) + ret = usb_autopm_get_interface(tp->intf); + if (ret < 0) goto out; switch (cmd) { @@ -4133,6 +6985,11 @@ static int rtl8152_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd) break; case SIOCGMIIREG: + if (unlikely(tp->rtk_enable_diag)) { + ret = -EBUSY; + break; + } + mutex_lock(&tp->control); data->val_out = r8152_mdio_read(tp, data->reg_num); mutex_unlock(&tp->control); @@ -4140,22 +6997,36 @@ static int rtl8152_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd) case SIOCSMIIREG: if (!capable(CAP_NET_ADMIN)) { - res = -EPERM; + ret = -EPERM; break; } + + if (unlikely(tp->rtk_enable_diag)) { + ret = -EBUSY; + break; + } + mutex_lock(&tp->control); r8152_mdio_write(tp, data->reg_num, data->val_in); mutex_unlock(&tp->control); break; + case SIOCDEVPRIVATE: + if (!capable(CAP_NET_ADMIN)) { + ret = -EPERM; + break; + } + ret = rtltool_ioctl(tp, rq); + break; + default: - res = -EOPNOTSUPP; + ret = -EOPNOTSUPP; } usb_autopm_put_interface(tp->intf); out: - return res; + return ret; } static int rtl8152_change_mtu(struct net_device *dev, int new_mtu) @@ -4166,6 +7037,7 @@ static int rtl8152_change_mtu(struct net_device *dev, int new_mtu) switch (tp->version) { case RTL_VER_01: case RTL_VER_02: + case RTL_VER_07: return eth_change_mtu(dev, new_mtu); default: break; @@ -4182,8 +7054,14 @@ static int rtl8152_change_mtu(struct net_device *dev, int new_mtu) dev->mtu = new_mtu; - if (netif_running(dev) && netif_carrier_ok(dev)) - r8153_set_rx_early_size(tp); + if (netif_running(dev)) { + u32 rms = new_mtu + VLAN_ETH_HLEN + CRC_SIZE; + + ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, rms); + + if (netif_carrier_ok(dev)) + r8153_set_rx_early_size(tp); + } mutex_unlock(&tp->control); @@ -4192,19 +7070,27 @@ static int rtl8152_change_mtu(struct net_device *dev, int new_mtu) return ret; } +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29) static const struct net_device_ops rtl8152_netdev_ops = { .ndo_open = rtl8152_open, .ndo_stop = rtl8152_close, .ndo_do_ioctl = rtl8152_ioctl, .ndo_start_xmit = rtl8152_start_xmit, .ndo_tx_timeout = rtl8152_tx_timeout, +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) + .ndo_vlan_rx_register = rtl8152_vlan_rx_register, +#else .ndo_set_features = rtl8152_set_features, +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0) */ .ndo_set_rx_mode = rtl8152_set_rx_mode, .ndo_set_mac_address = rtl8152_set_mac_address, .ndo_change_mtu = rtl8152_change_mtu, .ndo_validate_addr = eth_validate_addr, +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,18,4) .ndo_features_check = rtl8152_features_check, +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,18,4) */ }; +#endif static void r8152b_get_version(struct r8152 *tp) { @@ -4237,6 +7123,17 @@ static void r8152b_get_version(struct r8152 *tp) tp->version = RTL_VER_06; tp->mii.supports_gmii = 1; break; + case 0x4800: + tp->version = RTL_VER_07; + break; + case 0x6000: + tp->version = RTL_VER_08; + tp->mii.supports_gmii = 1; + break; + case 0x6010: + tp->version = RTL_VER_09; + tp->mii.supports_gmii = 1; + break; default: netif_info(tp, probe, tp->netdev, "Unknown version 0x%04x\n", version); @@ -4258,7 +7155,11 @@ static void rtl8153_unload(struct r8152 *tp) if (test_bit(RTL8152_UNPLUG, &tp->flags)) return; - r8153_power_cut_en(tp, false); + tp->rtl_ops.power_cut_en(tp, false); +} + +static void rtl_fake_enable(struct r8152 *tp, bool enable) +{ } static int rtl_ops_init(struct r8152 *tp) @@ -4269,16 +7170,23 @@ static int rtl_ops_init(struct r8152 *tp) switch (tp->version) { case RTL_VER_01: case RTL_VER_02: + case RTL_VER_07: ops->init = r8152b_init; ops->enable = rtl8152_enable; ops->disable = rtl8152_disable; ops->up = rtl8152_up; ops->down = rtl8152_down; ops->unload = rtl8152_unload; +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) ops->eee_get = r8152_get_eee; ops->eee_set = r8152_set_eee; +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */ ops->in_nway = rtl8152_in_nway; ops->hw_phy_cfg = r8152b_hw_phy_cfg; + ops->aldps_enable = r8152_aldps_en; + ops->u1u2_enable = rtl_fake_enable; + ops->u2p3_enable = rtl_fake_enable; + ops->power_cut_en = r8152_power_cut_en; ops->autosuspend_en = rtl_runtime_suspend_enable; break; @@ -4292,13 +7200,40 @@ static int rtl_ops_init(struct r8152 *tp) ops->up = rtl8153_up; ops->down = rtl8153_down; ops->unload = rtl8153_unload; +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) ops->eee_get = r8153_get_eee; ops->eee_set = r8153_set_eee; +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */ ops->in_nway = rtl8153_in_nway; ops->hw_phy_cfg = r8153_hw_phy_cfg; + ops->aldps_enable = r8153_aldps_en; + ops->u1u2_enable = r8153_u1u2en; + ops->u2p3_enable = r8153_u2p3en; + ops->power_cut_en = r8153_power_cut_en; ops->autosuspend_en = rtl8153_runtime_enable; break; + case RTL_VER_08: + case RTL_VER_09: + ops->init = r8153b_init; + ops->enable = rtl8153_enable; + ops->disable = rtl8153_disable; + ops->up = rtl8153_up; + ops->down = rtl8153_down; + ops->unload = rtl8153_unload; +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) + ops->eee_get = r8153_get_eee; + ops->eee_set = r8153b_set_eee; +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0) */ + ops->in_nway = rtl8153_in_nway; + ops->hw_phy_cfg = r8153b_hw_phy_cfg; + ops->aldps_enable = r8153b_aldps_en; + ops->u1u2_enable = r8153b_u1u2en; + ops->u2p3_enable = rtl_fake_enable; + ops->power_cut_en = r8153B_power_cut_en; + ops->autosuspend_en = rtl8153b_runtime_enable; + break; + default: ret = -ENODEV; netif_err(tp, probe, tp->netdev, "Unknown Device\n"); @@ -4316,8 +7251,12 @@ static int rtl8152_probe(struct usb_interface *intf, struct net_device *netdev; int ret; - if (udev->actconfig->desc.bConfigurationValue != 1) { + if (!rtl_vendor_mode(intf)) { +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) + dev_err(&intf->dev, "The kernel too old to set configuration\n"); +#else usb_driver_set_configuration(udev, 1); +#endif return -ENODEV; } @@ -4345,13 +7284,32 @@ static int rtl8152_probe(struct usb_interface *intf, INIT_DELAYED_WORK(&tp->schedule, rtl_work_func_t); INIT_DELAYED_WORK(&tp->hw_phy_work, rtl_hw_phy_work_func_t); +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) + netdev->open = rtl8152_open; + netdev->stop = rtl8152_close; + netdev->get_stats = rtl8152_get_stats; + netdev->hard_start_xmit = rtl8152_start_xmit; + netdev->tx_timeout = rtl8152_tx_timeout; + netdev->change_mtu = rtl8152_change_mtu; + netdev->set_mac_address = rtl8152_set_mac_address; + netdev->do_ioctl = rtl8152_ioctl; + netdev->set_multicast_list = rtl8152_set_rx_mode; + netdev->vlan_rx_register = rtl8152_vlan_rx_register; +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) + netdev->vlan_rx_kill_vid = rtl8152_vlan_rx_kill_vid; +#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) */ +#else netdev->netdev_ops = &rtl8152_netdev_ops; +#endif /* HAVE_NET_DEVICE_OPS */ + netdev->watchdog_timeo = RTL8152_TX_TIMEOUT; netdev->features |= NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_TSO | NETIF_F_FRAGLIST | NETIF_F_IPV6_CSUM | NETIF_F_TSO6 | NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_TX; + +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38) netdev->hw_features = NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_TSO | NETIF_F_FRAGLIST | NETIF_F_IPV6_CSUM | NETIF_F_TSO6 | @@ -4359,14 +7317,14 @@ static int rtl8152_probe(struct usb_interface *intf, netdev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | NETIF_F_IPV6_CSUM | NETIF_F_TSO6; - - if (tp->version == RTL_VER_01) { - netdev->features &= ~NETIF_F_RXCSUM; - netdev->hw_features &= ~NETIF_F_RXCSUM; - } +#endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38) */ netdev->ethtool_ops = &ops; +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26) netif_set_gso_max_size(netdev, RTL_LIMITED_TSO_SIZE); +#else + netdev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6); +#endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25) */ tp->mii.dev = netdev; tp->mii.mdio_read = read_mii_word; @@ -4375,19 +7333,6 @@ static int rtl8152_probe(struct usb_interface *intf, tp->mii.reg_num_mask = 0x1f; tp->mii.phy_id = R8152_PHY_ID; - switch (udev->speed) { - case USB_SPEED_SUPER: - case USB_SPEED_SUPER_PLUS: - tp->coalesce = COALESCE_SUPER; - break; - case USB_SPEED_HIGH: - tp->coalesce = COALESCE_HIGH; - break; - default: - tp->coalesce = COALESCE_SLOW; - break; - } - tp->autoneg = AUTONEG_ENABLE; tp->speed = tp->mii.supports_gmii ? SPEED_1000 : SPEED_100; tp->duplex = DUPLEX_FULL; @@ -4416,7 +7361,10 @@ static int rtl8152_probe(struct usb_interface *intf, else device_set_wakeup_enable(&udev->dev, false); + /* usb_enable_autosuspend(udev); */ + netif_info(tp, probe, netdev, "%s\n", DRIVER_VERSION); + netif_info(tp, probe, netdev, "%s\n", PATENTS); return 0; @@ -4448,28 +7396,40 @@ static void rtl8152_disconnect(struct usb_interface *intf) } #define REALTEK_USB_DEVICE(vend, prod) \ - .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \ - USB_DEVICE_ID_MATCH_INT_CLASS, \ - .idVendor = (vend), \ - .idProduct = (prod), \ - .bInterfaceClass = USB_CLASS_VENDOR_SPEC \ + USB_DEVICE_INTERFACE_CLASS(vend, prod, USB_CLASS_VENDOR_SPEC) \ }, \ { \ - .match_flags = USB_DEVICE_ID_MATCH_INT_INFO | \ - USB_DEVICE_ID_MATCH_DEVICE, \ - .idVendor = (vend), \ - .idProduct = (prod), \ - .bInterfaceClass = USB_CLASS_COMM, \ - .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, \ - .bInterfaceProtocol = USB_CDC_PROTO_NONE + USB_DEVICE_AND_INTERFACE_INFO(vend, prod, USB_CLASS_COMM, \ + USB_CDC_SUBCLASS_ETHERNET, \ + USB_CDC_PROTO_NONE) /* table of devices that work with this driver */ static struct usb_device_id rtl8152_table[] = { + /* Realtek */ + {REALTEK_USB_DEVICE(VENDOR_ID_REALTEK, 0x8050)}, {REALTEK_USB_DEVICE(VENDOR_ID_REALTEK, 0x8152)}, {REALTEK_USB_DEVICE(VENDOR_ID_REALTEK, 0x8153)}, + + /* Samsung */ {REALTEK_USB_DEVICE(VENDOR_ID_SAMSUNG, 0xa101)}, - {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x7205)}, - {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x304f)}, + + /* Lenovo */ + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x304f)}, + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x3052)}, + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x3054)}, + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x3057)}, + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x3062)}, + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x3069)}, + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x7205)}, + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x720a)}, + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x720b)}, + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x720c)}, + {REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x7214)}, + + /* TP-LINK */ + {REALTEK_USB_DEVICE(VENDOR_ID_TPLINK, 0x0601)}, + + /* Nvidia */ {REALTEK_USB_DEVICE(VENDOR_ID_NVIDIA, 0x09ff)}, {} }; @@ -4487,7 +7447,9 @@ static struct usb_driver rtl8152_driver = { .pre_reset = rtl8152_pre_reset, .post_reset = rtl8152_post_reset, .supports_autosuspend = 1, +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0) .disable_hub_initiated_lpm = 1, +#endif }; module_usb_driver(rtl8152_driver); @@ -4495,4 +7457,3 @@ module_usb_driver(rtl8152_driver); MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_DESCRIPTION(DRIVER_DESC); MODULE_LICENSE("GPL"); -MODULE_VERSION(DRIVER_VERSION);