Lines Matching refs:tp
888 void (*init)(struct r8152 *tp);
889 int (*enable)(struct r8152 *tp);
890 void (*disable)(struct r8152 *tp);
891 void (*up)(struct r8152 *tp);
892 void (*down)(struct r8152 *tp);
893 void (*unload)(struct r8152 *tp);
894 int (*eee_get)(struct r8152 *tp, struct ethtool_eee *eee);
895 int (*eee_set)(struct r8152 *tp, struct ethtool_eee *eee);
896 bool (*in_nway)(struct r8152 *tp);
897 void (*hw_phy_cfg)(struct r8152 *tp);
898 void (*autosuspend_en)(struct r8152 *tp, bool enable);
899 void (*change_mtu)(struct r8152 *tp);
927 int (*pre_fw)(struct r8152 *tp);
928 int (*post_fw)(struct r8152 *tp);
1214 static void rtl_set_inaccessible(struct r8152 *tp)
1216 set_bit(RTL8152_INACCESSIBLE, &tp->flags);
1220 static void rtl_set_accessible(struct r8152 *tp)
1222 clear_bit(RTL8152_INACCESSIBLE, &tp->flags);
1227 int r8152_control_msg(struct r8152 *tp, unsigned int pipe, __u8 request,
1231 struct usb_device *udev = tp->udev;
1234 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
1249 tp->reg_access_reset_count = 0;
1263 rtl_set_inaccessible(tp);
1267 * never have to clear this bit since we free/reallocate the whole "tp"
1270 if (!test_bit(PROBED_WITH_NO_ERRORS, &tp->flags)) {
1271 set_bit(PROBE_SHOULD_RETRY, &tp->flags);
1283 if (test_bit(IN_PRE_RESET, &tp->flags))
1286 if (tp->reg_access_reset_count < REGISTER_ACCESS_MAX_RESETS) {
1287 usb_queue_reset_device(tp->intf);
1288 tp->reg_access_reset_count++;
1289 } else if (tp->reg_access_reset_count == REGISTER_ACCESS_MAX_RESETS) {
1299 int get_registers(struct r8152 *tp, u16 value, u16 index, u16 size, void *data)
1308 ret = r8152_control_msg(tp, tp->pipe_ctrl_in,
1323 int set_registers(struct r8152 *tp, u16 value, u16 index, u16 size, void *data)
1332 ret = r8152_control_msg(tp, tp->pipe_ctrl_out,
1341 static void rtl_set_unplug(struct r8152 *tp)
1343 if (tp->udev->state == USB_STATE_NOTATTACHED)
1344 rtl_set_inaccessible(tp);
1347 static int generic_ocp_read(struct r8152 *tp, u16 index, u16 size,
1353 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
1365 ret = get_registers(tp, index, type, limit, data);
1373 ret = get_registers(tp, index, type, size, data);
1385 rtl_set_unplug(tp);
1390 static int generic_ocp_write(struct r8152 *tp, u16 index, u16 byteen,
1397 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
1414 ret = set_registers(tp, index, type | byen, 4, data);
1432 ret = set_registers(tp, index,
1442 ret = set_registers(tp, index,
1457 ret = set_registers(tp, index, type | byen, 4, data);
1462 rtl_set_unplug(tp);
1468 int pla_ocp_read(struct r8152 *tp, u16 index, u16 size, void *data)
1470 return generic_ocp_read(tp, index, size, data, MCU_TYPE_PLA);
1474 int pla_ocp_write(struct r8152 *tp, u16 index, u16 byteen, u16 size, void *data)
1476 return generic_ocp_write(tp, index, byteen, size, data, MCU_TYPE_PLA);
1480 int usb_ocp_write(struct r8152 *tp, u16 index, u16 byteen, u16 size, void *data)
1482 return generic_ocp_write(tp, index, byteen, size, data, MCU_TYPE_USB);
1485 static u32 ocp_read_dword(struct r8152 *tp, u16 type, u16 index)
1489 generic_ocp_read(tp, index, sizeof(data), &data, type);
1494 static void ocp_write_dword(struct r8152 *tp, u16 type, u16 index, u32 data)
1498 generic_ocp_write(tp, index, BYTE_EN_DWORD, sizeof(tmp), &tmp, type);
1501 static u16 ocp_read_word(struct r8152 *tp, u16 type, u16 index)
1511 generic_ocp_read(tp, index, sizeof(tmp), &tmp, type | byen);
1520 static void ocp_write_word(struct r8152 *tp, u16 type, u16 index, u32 data)
1538 generic_ocp_write(tp, index, byen, sizeof(tmp), &tmp, type);
1541 static u8 ocp_read_byte(struct r8152 *tp, u16 type, u16 index)
1549 generic_ocp_read(tp, index, sizeof(tmp), &tmp, type);
1558 static void ocp_write_byte(struct r8152 *tp, u16 type, u16 index, u32 data)
1576 generic_ocp_write(tp, index, byen, sizeof(tmp), &tmp, type);
1579 static u16 ocp_reg_read(struct r8152 *tp, u16 addr)
1584 if (ocp_base != tp->ocp_base) {
1585 ocp_write_word(tp, MCU_TYPE_PLA, PLA_OCP_GPHY_BASE, ocp_base);
1586 tp->ocp_base = ocp_base;
1590 return ocp_read_word(tp, MCU_TYPE_PLA, ocp_index);
1593 static void ocp_reg_write(struct r8152 *tp, u16 addr, u16 data)
1598 if (ocp_base != tp->ocp_base) {
1599 ocp_write_word(tp, MCU_TYPE_PLA, PLA_OCP_GPHY_BASE, ocp_base);
1600 tp->ocp_base = ocp_base;
1604 ocp_write_word(tp, MCU_TYPE_PLA, ocp_index, data);
1607 static inline void r8152_mdio_write(struct r8152 *tp, u32 reg_addr, u32 value)
1609 ocp_reg_write(tp, OCP_BASE_MII + reg_addr * 2, value);
1612 static inline int r8152_mdio_read(struct r8152 *tp, u32 reg_addr)
1614 return ocp_reg_read(tp, OCP_BASE_MII + reg_addr * 2);
1617 static void sram_write(struct r8152 *tp, u16 addr, u16 data)
1619 ocp_reg_write(tp, OCP_SRAM_ADDR, addr);
1620 ocp_reg_write(tp, OCP_SRAM_DATA, data);
1623 static u16 sram_read(struct r8152 *tp, u16 addr)
1625 ocp_reg_write(tp, OCP_SRAM_ADDR, addr);
1626 return ocp_reg_read(tp, OCP_SRAM_DATA);
1631 struct r8152 *tp = netdev_priv(netdev);
1634 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
1640 ret = r8152_mdio_read(tp, reg);
1648 struct r8152 *tp = netdev_priv(netdev);
1650 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
1656 r8152_mdio_write(tp, reg, val);
1660 r8152_submit_rx(struct r8152 *tp, struct rx_agg *agg, gfp_t mem_flags);
1663 rtl8152_set_speed(struct r8152 *tp, u8 autoneg, u32 speed, u8 duplex,
1669 struct r8152 *tp = netdev_priv(netdev);
1677 ret = usb_autopm_get_interface(tp->intf);
1682 mutex_lock(&tp->control);
1686 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
1687 pla_ocp_write(tp, PLA_IDR, BYTE_EN_SIX_BYTES, 8, addr->sa_data);
1688 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
1690 mutex_unlock(&tp->control);
1693 usb_autopm_put_interface(tp->intf);
1707 static int vendor_mac_passthru_addr_read(struct r8152 *tp, struct sockaddr *sa)
1719 if (tp->lenovo_macpassthru) {
1725 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0);
1728 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, EFUSE);
1730 netif_dbg(tp, probe, tp->netdev,
1736 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_MISC_1);
1738 netif_dbg(tp, probe, tp->netdev,
1755 netif_warn(tp, probe, tp->netdev,
1763 netif_warn(tp, probe, tp->netdev,
1769 netif_warn(tp, probe, tp->netdev,
1776 netif_info(tp, probe, tp->netdev,
1784 static int determine_ethernet_addr(struct r8152 *tp, struct sockaddr *sa)
1786 struct net_device *dev = tp->netdev;
1791 ret = eth_platform_get_mac_address(&tp->udev->dev, sa->sa_data);
1793 if (tp->version == RTL_VER_01) {
1794 ret = pla_ocp_read(tp, PLA_IDR, 8, sa->sa_data);
1799 ret = vendor_mac_passthru_addr_read(tp, sa);
1801 ret = pla_ocp_read(tp, PLA_BACKUP, 8,
1807 netif_err(tp, probe, dev, "Get ether addr fail\n");
1809 netif_err(tp, probe, dev, "Invalid ether addr %pM\n",
1813 netif_info(tp, probe, dev, "Random ether addr %pM\n",
1821 static int set_ethernet_addr(struct r8152 *tp, bool in_resume)
1823 struct net_device *dev = tp->netdev;
1827 ret = determine_ethernet_addr(tp, &sa);
1831 if (tp->version == RTL_VER_01)
1844 struct r8152 *tp;
1851 tp = agg->context;
1852 if (!tp)
1855 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
1858 if (!test_bit(WORK_ENABLE, &tp->flags))
1861 netdev = tp->netdev;
1868 usb_mark_last_busy(tp->udev);
1875 spin_lock_irqsave(&tp->rx_lock, flags);
1876 list_add_tail(&agg->list, &tp->rx_done);
1877 spin_unlock_irqrestore(&tp->rx_lock, flags);
1878 napi_schedule(&tp->napi);
1881 rtl_set_unplug(tp);
1882 netif_device_detach(tp->netdev);
1886 spin_lock_irqsave(&tp->rx_lock, flags);
1887 list_add_tail(&agg->list, &tp->rx_done);
1888 spin_unlock_irqrestore(&tp->rx_lock, flags);
1889 set_bit(RX_EPROTO, &tp->flags);
1890 schedule_delayed_work(&tp->schedule, 1);
1904 r8152_submit_rx(tp, agg, GFP_ATOMIC);
1912 struct r8152 *tp;
1920 tp = agg->context;
1921 if (!tp)
1924 netdev = tp->netdev;
1935 spin_lock_irqsave(&tp->tx_lock, flags);
1936 list_add_tail(&agg->list, &tp->tx_free);
1937 spin_unlock_irqrestore(&tp->tx_lock, flags);
1939 usb_autopm_put_interface_async(tp->intf);
1944 if (!test_bit(WORK_ENABLE, &tp->flags))
1947 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
1950 if (!skb_queue_empty(&tp->tx_queue))
1951 tasklet_schedule(&tp->tx_tl);
1956 struct r8152 *tp;
1961 tp = urb->context;
1962 if (!tp)
1965 if (!test_bit(WORK_ENABLE, &tp->flags))
1968 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
1976 netif_device_detach(tp->netdev);
1980 netif_info(tp, intr, tp->netdev,
1985 netif_info(tp, intr, tp->netdev,
1990 netif_info(tp, intr, tp->netdev, "intr status %d\n", status);
1996 if (!netif_carrier_ok(tp->netdev)) {
1997 set_bit(RTL8152_LINK_CHG, &tp->flags);
1998 schedule_delayed_work(&tp->schedule, 0);
2001 if (netif_carrier_ok(tp->netdev)) {
2002 netif_stop_queue(tp->netdev);
2003 set_bit(RTL8152_LINK_CHG, &tp->flags);
2004 schedule_delayed_work(&tp->schedule, 0);
2011 rtl_set_unplug(tp);
2012 netif_device_detach(tp->netdev);
2014 netif_err(tp, intr, tp->netdev,
2029 static void free_rx_agg(struct r8152 *tp, struct rx_agg *agg)
2037 atomic_dec(&tp->rx_count);
2040 static struct rx_agg *alloc_rx_agg(struct r8152 *tp, gfp_t mflags)
2042 struct net_device *netdev = tp->netdev;
2044 unsigned int order = get_order(tp->rx_buf_sz);
2062 rx_agg->context = tp;
2066 spin_lock_irqsave(&tp->rx_lock, flags);
2067 list_add_tail(&rx_agg->info_list, &tp->rx_info);
2068 spin_unlock_irqrestore(&tp->rx_lock, flags);
2070 atomic_inc(&tp->rx_count);
2081 static void free_all_mem(struct r8152 *tp)
2087 spin_lock_irqsave(&tp->rx_lock, flags);
2089 list_for_each_entry_safe(agg, agg_next, &tp->rx_info, info_list)
2090 free_rx_agg(tp, agg);
2092 spin_unlock_irqrestore(&tp->rx_lock, flags);
2094 WARN_ON(atomic_read(&tp->rx_count));
2097 usb_free_urb(tp->tx_info[i].urb);
2098 tp->tx_info[i].urb = NULL;
2100 kfree(tp->tx_info[i].buffer);
2101 tp->tx_info[i].buffer = NULL;
2102 tp->tx_info[i].head = NULL;
2105 usb_free_urb(tp->intr_urb);
2106 tp->intr_urb = NULL;
2108 kfree(tp->intr_buff);
2109 tp->intr_buff = NULL;
2112 static int alloc_all_mem(struct r8152 *tp)
2114 struct net_device *netdev = tp->netdev;
2115 struct usb_interface *intf = tp->intf;
2122 spin_lock_init(&tp->rx_lock);
2123 spin_lock_init(&tp->tx_lock);
2124 INIT_LIST_HEAD(&tp->rx_info);
2125 INIT_LIST_HEAD(&tp->tx_free);
2126 INIT_LIST_HEAD(&tp->rx_done);
2127 skb_queue_head_init(&tp->tx_queue);
2128 skb_queue_head_init(&tp->rx_queue);
2129 atomic_set(&tp->rx_count, 0);
2132 if (!alloc_rx_agg(tp, GFP_KERNEL))
2158 INIT_LIST_HEAD(&tp->tx_info[i].list);
2159 tp->tx_info[i].context = tp;
2160 tp->tx_info[i].urb = urb;
2161 tp->tx_info[i].buffer = buf;
2162 tp->tx_info[i].head = tx_agg_align(buf);
2164 list_add_tail(&tp->tx_info[i].list, &tp->tx_free);
2167 tp->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
2168 if (!tp->intr_urb)
2171 tp->intr_buff = kmalloc(INTBUFSIZE, GFP_KERNEL);
2172 if (!tp->intr_buff)
2175 tp->intr_interval = (int)ep_intr->desc.bInterval;
2176 usb_fill_int_urb(tp->intr_urb, tp->udev, tp->pipe_intr,
2177 tp->intr_buff, INTBUFSIZE, intr_callback,
2178 tp, tp->intr_interval);
2183 free_all_mem(tp);
2187 static struct tx_agg *r8152_get_tx_agg(struct r8152 *tp)
2192 if (list_empty(&tp->tx_free))
2195 spin_lock_irqsave(&tp->tx_lock, flags);
2196 if (!list_empty(&tp->tx_free)) {
2199 cursor = tp->tx_free.next;
2203 spin_unlock_irqrestore(&tp->tx_lock, flags);
2212 static void r8152_csum_workaround(struct r8152 *tp, struct sk_buff *skb,
2216 netdev_features_t features = tp->netdev->features;
2243 stats = &tp->netdev->stats;
2268 static int r8152_tx_csum(struct r8152 *tp, struct tx_desc *desc,
2283 netif_warn(tp, tx_err, tp->netdev,
2316 netif_warn(tp, tx_err, tp->netdev,
2356 static int r8152_tx_agg_fill(struct r8152 *tp, struct tx_agg *agg)
2358 struct sk_buff_head skb_head, *tx_queue = &tp->tx_queue;
2391 if (r8152_tx_csum(tp, tx_desc, skb, skb->len)) {
2392 r8152_csum_workaround(tp, skb, &skb_head);
2402 struct net_device_stats *stats = &tp->netdev->stats;
2418 if (tp->dell_tb_rx_agg_bug)
2428 netif_tx_lock(tp->netdev);
2430 if (netif_queue_stopped(tp->netdev) &&
2431 skb_queue_len(&tp->tx_queue) < tp->tx_qlen)
2432 netif_wake_queue(tp->netdev);
2434 netif_tx_unlock(tp->netdev);
2436 ret = usb_autopm_get_interface_async(tp->intf);
2440 usb_fill_bulk_urb(agg->urb, tp->udev, tp->pipe_out,
2446 usb_autopm_put_interface_async(tp->intf);
2452 static u8 r8152_rx_csum(struct r8152 *tp, struct rx_desc *rx_desc)
2457 if (!(tp->netdev->features & NETIF_F_RXCSUM))
2481 static inline bool rx_count_exceed(struct r8152 *tp)
2483 return atomic_read(&tp->rx_count) > RTL8152_MAX_RX;
2491 static struct rx_agg *rtl_get_free_rx(struct r8152 *tp, gfp_t mflags)
2496 spin_lock_irqsave(&tp->rx_lock, flags);
2498 list_for_each_entry_safe(agg, agg_next, &tp->rx_used, list) {
2505 if (rx_count_exceed(tp)) {
2507 free_rx_agg(tp, agg);
2513 spin_unlock_irqrestore(&tp->rx_lock, flags);
2515 if (!agg_free && atomic_read(&tp->rx_count) < tp->rx_pending)
2516 agg_free = alloc_rx_agg(tp, mflags);
2521 static int rx_bottom(struct r8152 *tp, int budget)
2526 struct napi_struct *napi = &tp->napi;
2528 if (!skb_queue_empty(&tp->rx_queue)) {
2530 struct sk_buff *skb = __skb_dequeue(&tp->rx_queue);
2531 struct net_device *netdev = tp->netdev;
2546 if (list_empty(&tp->rx_done) || work_done >= budget)
2549 clear_bit(RX_EPROTO, &tp->flags);
2551 spin_lock_irqsave(&tp->rx_lock, flags);
2552 list_splice_init(&tp->rx_done, &rx_queue);
2553 spin_unlock_irqrestore(&tp->rx_lock, flags);
2578 agg_free = rtl_get_free_rx(tp, GFP_ATOMIC);
2585 struct net_device *netdev = tp->netdev;
2590 WARN_ON_ONCE(skb_queue_len(&tp->rx_queue) >= 1000);
2603 if (!agg_free || tp->rx_copybreak > pkt_len)
2606 rx_frag_head_sz = tp->rx_copybreak;
2614 skb->ip_summed = r8152_rx_csum(tp, rx_desc);
2635 __skb_queue_tail(&tp->rx_queue, skb);
2648 spin_lock_irqsave(&tp->rx_lock, flags);
2650 list_add(&agg_free->list, &tp->rx_used);
2652 list_add_tail(&agg->list, &tp->rx_used);
2656 spin_unlock_irqrestore(&tp->rx_lock, flags);
2661 ret = r8152_submit_rx(tp, agg, GFP_ATOMIC);
2670 spin_lock_irqsave(&tp->rx_lock, flags);
2671 list_splice(&rx_queue, &tp->rx_done);
2672 spin_unlock_irqrestore(&tp->rx_lock, flags);
2679 static void tx_bottom(struct r8152 *tp)
2684 struct net_device *netdev = tp->netdev;
2687 if (skb_queue_empty(&tp->tx_queue))
2690 agg = r8152_get_tx_agg(tp);
2694 res = r8152_tx_agg_fill(tp, agg);
2699 rtl_set_unplug(tp);
2705 netif_warn(tp, tx_err, netdev,
2709 spin_lock_irqsave(&tp->tx_lock, flags);
2710 list_add_tail(&agg->list, &tp->tx_free);
2711 spin_unlock_irqrestore(&tp->tx_lock, flags);
2718 struct r8152 *tp = from_tasklet(tp, t, tx_tl);
2720 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
2723 if (!test_bit(WORK_ENABLE, &tp->flags))
2728 if (!netif_carrier_ok(tp->netdev))
2731 clear_bit(SCHEDULE_TASKLET, &tp->flags);
2733 tx_bottom(tp);
2738 struct r8152 *tp = container_of(napi, struct r8152, napi);
2744 work_done = rx_bottom(tp, budget);
2749 if (!list_empty(&tp->rx_done))
2758 int r8152_submit_rx(struct r8152 *tp, struct rx_agg *agg, gfp_t mem_flags)
2763 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags) ||
2764 !test_bit(WORK_ENABLE, &tp->flags) || !netif_carrier_ok(tp->netdev))
2767 usb_fill_bulk_urb(agg->urb, tp->udev, tp->pipe_in,
2768 agg->buffer, tp->rx_buf_sz,
2773 rtl_set_unplug(tp);
2774 netif_device_detach(tp->netdev);
2780 spin_lock_irqsave(&tp->rx_lock, flags);
2781 list_add_tail(&agg->list, &tp->rx_done);
2782 spin_unlock_irqrestore(&tp->rx_lock, flags);
2784 netif_err(tp, rx_err, tp->netdev,
2787 napi_schedule(&tp->napi);
2793 static void rtl_drop_queued_tx(struct r8152 *tp)
2795 struct net_device_stats *stats = &tp->netdev->stats;
2796 struct sk_buff_head skb_head, *tx_queue = &tp->tx_queue;
2815 struct r8152 *tp = netdev_priv(netdev);
2817 netif_warn(tp, tx_err, netdev, "Tx timeout\n");
2819 usb_queue_reset_device(tp->intf);
2824 struct r8152 *tp = netdev_priv(netdev);
2827 set_bit(RTL8152_SET_RX_MODE, &tp->flags);
2828 schedule_delayed_work(&tp->schedule, 0);
2834 struct r8152 *tp = netdev_priv(netdev);
2840 ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
2846 netif_notice(tp, link, netdev, "Promiscuous mode enabled\n");
2876 pla_ocp_write(tp, PLA_MAR, BYTE_EN_DWORD, sizeof(tmp), tmp);
2877 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
2900 struct r8152 *tp = netdev_priv(netdev);
2904 skb_queue_tail(&tp->tx_queue, skb);
2906 if (!list_empty(&tp->tx_free)) {
2907 if (test_bit(SELECTIVE_SUSPEND, &tp->flags)) {
2908 set_bit(SCHEDULE_TASKLET, &tp->flags);
2909 schedule_delayed_work(&tp->schedule, 0);
2911 usb_mark_last_busy(tp->udev);
2912 tasklet_schedule(&tp->tx_tl);
2914 } else if (skb_queue_len(&tp->tx_queue) > tp->tx_qlen) {
2921 static void r8152b_reset_packet_filter(struct r8152 *tp)
2925 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_FMC);
2927 ocp_write_word(tp, MCU_TYPE_PLA, PLA_FMC, ocp_data);
2929 ocp_write_word(tp, MCU_TYPE_PLA, PLA_FMC, ocp_data);
2932 static void rtl8152_nic_reset(struct r8152 *tp)
2937 switch (tp->version) {
2941 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CR);
2943 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CR, ocp_data);
2945 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_BMU_RESET);
2947 ocp_write_word(tp, MCU_TYPE_USB, USB_BMU_RESET, ocp_data);
2949 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
2951 ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
2953 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CR);
2955 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CR, ocp_data);
2957 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_BMU_RESET);
2959 ocp_write_word(tp, MCU_TYPE_USB, USB_BMU_RESET, ocp_data);
2961 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
2963 ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
2967 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CR, CR_RST);
2970 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
2972 if (!(ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CR) & CR_RST))
2980 static void set_tx_qlen(struct r8152 *tp)
2982 tp->tx_qlen = agg_buf_sz / (mtu_to_size(tp->netdev->mtu) + sizeof(struct tx_desc));
2985 static inline u16 rtl8152_get_speed(struct r8152 *tp)
2987 return ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHYSTATUS);
2990 static void rtl_eee_plus_en(struct r8152 *tp, bool enable)
2994 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR);
2999 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR, ocp_data);
3002 static void rtl_set_eee_plus(struct r8152 *tp)
3004 if (rtl8152_get_speed(tp) & _10bps)
3005 rtl_eee_plus_en(tp, true);
3007 rtl_eee_plus_en(tp, false);
3010 static void rxdy_gated_en(struct r8152 *tp, bool enable)
3014 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MISC_1);
3019 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MISC_1, ocp_data);
3022 static int rtl_start_rx(struct r8152 *tp)
3031 spin_lock_irqsave(&tp->rx_lock, flags);
3033 INIT_LIST_HEAD(&tp->rx_done);
3034 INIT_LIST_HEAD(&tp->rx_used);
3036 list_splice_init(&tp->rx_info, &tmp_list);
3038 spin_unlock_irqrestore(&tp->rx_lock, flags);
3045 spin_lock_irqsave(&tp->rx_lock, flags);
3046 list_add_tail(&agg->list, &tp->rx_used);
3047 spin_unlock_irqrestore(&tp->rx_lock, flags);
3049 spin_lock_irqsave(&tp->rx_lock, flags);
3050 list_add_tail(&agg->list, &tp->rx_done);
3051 spin_unlock_irqrestore(&tp->rx_lock, flags);
3053 ret = r8152_submit_rx(tp, agg, GFP_KERNEL);
3057 spin_lock_irqsave(&tp->rx_lock, flags);
3058 WARN_ON(!list_empty(&tp->rx_info));
3059 list_splice(&tmp_list, &tp->rx_info);
3060 spin_unlock_irqrestore(&tp->rx_lock, flags);
3065 static int rtl_stop_rx(struct r8152 *tp)
3079 spin_lock_irqsave(&tp->rx_lock, flags);
3080 list_splice_init(&tp->rx_info, &tmp_list);
3081 spin_unlock_irqrestore(&tp->rx_lock, flags);
3088 free_rx_agg(tp, agg);
3094 spin_lock_irqsave(&tp->rx_lock, flags);
3095 WARN_ON(!list_empty(&tp->rx_info));
3096 list_splice(&tmp_list, &tp->rx_info);
3097 spin_unlock_irqrestore(&tp->rx_lock, flags);
3099 while (!skb_queue_empty(&tp->rx_queue))
3100 dev_kfree_skb(__skb_dequeue(&tp->rx_queue));
3105 static void rtl_set_ifg(struct r8152 *tp, u16 speed)
3109 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR1);
3113 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TCR1, ocp_data);
3115 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4);
3117 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4, ocp_data);
3120 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TCR1, ocp_data);
3122 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4);
3124 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4, ocp_data);
3128 static inline void r8153b_rx_agg_chg_indicate(struct r8152 *tp)
3130 ocp_write_byte(tp, MCU_TYPE_USB, USB_UPT_RXDMA_OWN,
3134 static int rtl_enable(struct r8152 *tp)
3138 r8152b_reset_packet_filter(tp);
3140 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CR);
3142 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CR, ocp_data);
3144 switch (tp->version) {
3154 r8153b_rx_agg_chg_indicate(tp);
3158 rxdy_gated_en(tp, false);
3163 static int rtl8152_enable(struct r8152 *tp)
3165 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
3168 set_tx_qlen(tp);
3169 rtl_set_eee_plus(tp);
3171 return rtl_enable(tp);
3174 static void r8153_set_rx_early_timeout(struct r8152 *tp)
3176 u32 ocp_data = tp->coalesce / 8;
3178 switch (tp->version) {
3183 ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_TIMEOUT,
3193 ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_TIMEOUT,
3195 ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EXTRA_AGGR_TMR,
3204 ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_TIMEOUT,
3206 ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EXTRA_AGGR_TMR,
3215 static void r8153_set_rx_early_size(struct r8152 *tp)
3217 u32 ocp_data = tp->rx_buf_sz - rx_reserved_size(tp->netdev->mtu);
3219 switch (tp->version) {
3224 ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_SIZE,
3230 ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_SIZE,
3239 ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_SIZE,
3248 static int rtl8153_enable(struct r8152 *tp)
3252 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
3255 set_tx_qlen(tp);
3256 rtl_set_eee_plus(tp);
3257 r8153_set_rx_early_timeout(tp);
3258 r8153_set_rx_early_size(tp);
3260 rtl_set_ifg(tp, rtl8152_get_speed(tp));
3262 switch (tp->version) {
3265 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_TASK);
3267 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_TASK, ocp_data);
3270 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_TASK, ocp_data);
3276 return rtl_enable(tp);
3279 static void rtl_disable(struct r8152 *tp)
3284 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags)) {
3285 rtl_drop_queued_tx(tp);
3289 ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
3291 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
3293 rtl_drop_queued_tx(tp);
3296 usb_kill_urb(tp->tx_info[i].urb);
3298 rxdy_gated_en(tp, true);
3301 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
3303 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
3310 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
3312 if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR0) & TCR0_TX_EMPTY)
3317 rtl_stop_rx(tp);
3319 rtl8152_nic_reset(tp);
3322 static void r8152_power_cut_en(struct r8152 *tp, bool enable)
3326 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_UPS_CTRL);
3331 ocp_write_word(tp, MCU_TYPE_USB, USB_UPS_CTRL, ocp_data);
3333 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_PM_CTRL_STATUS);
3335 ocp_write_word(tp, MCU_TYPE_USB, USB_PM_CTRL_STATUS, ocp_data);
3338 static void rtl_rx_vlan_en(struct r8152 *tp, bool enable)
3342 switch (tp->version) {
3353 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CPCR);
3358 ocp_write_word(tp, MCU_TYPE_PLA, PLA_CPCR, ocp_data);
3368 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_RCR1);
3373 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RCR1, ocp_data);
3382 struct r8152 *tp = netdev_priv(dev);
3385 ret = usb_autopm_get_interface(tp->intf);
3389 mutex_lock(&tp->control);
3393 rtl_rx_vlan_en(tp, true);
3395 rtl_rx_vlan_en(tp, false);
3398 mutex_unlock(&tp->control);
3400 usb_autopm_put_interface(tp->intf);
3408 static u32 __rtl_get_wol(struct r8152 *tp)
3413 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG34);
3417 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG5);
3425 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CFG_WOL);
3432 static void __rtl_set_wol(struct r8152 *tp, u32 wolopts)
3436 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
3438 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG34);
3442 ocp_write_word(tp, MCU_TYPE_PLA, PLA_CONFIG34, ocp_data);
3444 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG5);
3452 ocp_write_word(tp, MCU_TYPE_PLA, PLA_CONFIG5, ocp_data);
3454 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
3456 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CFG_WOL);
3460 ocp_write_word(tp, MCU_TYPE_PLA, PLA_CFG_WOL, ocp_data);
3463 device_set_wakeup_enable(&tp->udev->dev, true);
3465 device_set_wakeup_enable(&tp->udev->dev, false);
3468 static void r8153_mac_clk_speed_down(struct r8152 *tp, bool enable)
3470 u32 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2);
3478 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2, ocp_data);
3481 static void r8156_mac_clk_spd(struct r8152 *tp, bool enable)
3488 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL,
3491 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2);
3494 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2, ocp_data);
3496 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2);
3498 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2, ocp_data);
3502 static void r8153_u1u2en(struct r8152 *tp, bool enable)
3511 usb_ocp_write(tp, USB_TOLERANCE, BYTE_EN_SIX_BYTES, sizeof(u1u2), u1u2);
3514 static void r8153b_u1u2en(struct r8152 *tp, bool enable)
3518 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_LPM_CONFIG);
3524 ocp_write_word(tp, MCU_TYPE_USB, USB_LPM_CONFIG, ocp_data);
3527 static void r8153_u2p3en(struct r8152 *tp, bool enable)
3531 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_U2P3_CTRL);
3536 ocp_write_word(tp, MCU_TYPE_USB, USB_U2P3_CTRL, ocp_data);
3539 static void r8153b_ups_flags(struct r8152 *tp)
3543 if (tp->ups_info.green)
3546 if (tp->ups_info.aldps)
3549 if (tp->ups_info.eee)
3552 if (tp->ups_info.flow_control)
3555 if (tp->ups_info.eee_ckdiv)
3558 if (tp->ups_info.eee_cmod_lv)
3561 if (tp->ups_info.r_tune)
3564 if (tp->ups_info._10m_ckdiv)
3567 if (tp->ups_info.eee_plloff_100)
3570 if (tp->ups_info.eee_plloff_giga)
3573 if (tp->ups_info._250m_ckdiv)
3576 if (tp->ups_info.ctap_short_off)
3579 switch (tp->ups_info.speed_duplex) {
3611 ocp_write_dword(tp, MCU_TYPE_USB, USB_UPS_FLAGS, ups_flags);
3614 static void r8156_ups_flags(struct r8152 *tp)
3618 if (tp->ups_info.green)
3621 if (tp->ups_info.aldps)
3624 if (tp->ups_info.eee)
3627 if (tp->ups_info.flow_control)
3630 if (tp->ups_info.eee_ckdiv)
3633 if (tp->ups_info._10m_ckdiv)
3636 if (tp->ups_info.eee_plloff_100)
3639 if (tp->ups_info.eee_plloff_giga)
3642 if (tp->ups_info._250m_ckdiv)
3645 switch (tp->ups_info.speed_duplex) {
3680 switch (tp->ups_info.lite_mode) {
3693 ocp_write_dword(tp, MCU_TYPE_USB, USB_UPS_FLAGS, ups_flags);
3696 static void rtl_green_en(struct r8152 *tp, bool enable)
3700 data = sram_read(tp, SRAM_GREEN_CFG);
3705 sram_write(tp, SRAM_GREEN_CFG, data);
3707 tp->ups_info.green = enable;
3710 static void r8153b_green_en(struct r8152 *tp, bool enable)
3713 sram_write(tp, 0x8045, 0); /* 10M abiq&ldvbias */
3714 sram_write(tp, 0x804d, 0x1222); /* 100M short abiq&ldvbias */
3715 sram_write(tp, 0x805d, 0x0022); /* 1000M short abiq&ldvbias */
3717 sram_write(tp, 0x8045, 0x2444); /* 10M abiq&ldvbias */
3718 sram_write(tp, 0x804d, 0x2444); /* 100M short abiq&ldvbias */
3719 sram_write(tp, 0x805d, 0x2444); /* 1000M short abiq&ldvbias */
3722 rtl_green_en(tp, true);
3725 static u16 r8153_phy_status(struct r8152 *tp, u16 desired)
3731 data = ocp_reg_read(tp, OCP_PHY_STATUS);
3742 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
3749 static void r8153b_ups_en(struct r8152 *tp, bool enable)
3751 u32 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_POWER_CUT);
3754 r8153b_ups_flags(tp);
3757 ocp_write_byte(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data);
3759 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_MISC_2);
3761 ocp_write_byte(tp, MCU_TYPE_USB, USB_MISC_2, ocp_data);
3764 ocp_write_byte(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data);
3766 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_MISC_2);
3768 ocp_write_byte(tp, MCU_TYPE_USB, USB_MISC_2, ocp_data);
3770 if (ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0) & PCUT_STATUS) {
3774 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
3776 if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) &
3782 tp->rtl_ops.hw_phy_cfg(tp);
3784 rtl8152_set_speed(tp, tp->autoneg, tp->speed,
3785 tp->duplex, tp->advertising);
3790 static void r8153c_ups_en(struct r8152 *tp, bool enable)
3792 u32 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_POWER_CUT);
3795 r8153b_ups_flags(tp);
3798 ocp_write_byte(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data);
3800 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_MISC_2);
3803 ocp_write_byte(tp, MCU_TYPE_USB, USB_MISC_2, ocp_data);
3806 ocp_write_byte(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data);
3808 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_MISC_2);
3810 ocp_write_byte(tp, MCU_TYPE_USB, USB_MISC_2, ocp_data);
3812 if (ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0) & PCUT_STATUS) {
3816 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
3818 if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) &
3824 tp->rtl_ops.hw_phy_cfg(tp);
3826 rtl8152_set_speed(tp, tp->autoneg, tp->speed,
3827 tp->duplex, tp->advertising);
3830 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
3832 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG34);
3834 ocp_write_word(tp, MCU_TYPE_PLA, PLA_CONFIG34, ocp_data);
3836 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
3840 static void r8156_ups_en(struct r8152 *tp, bool enable)
3842 u32 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_POWER_CUT);
3845 r8156_ups_flags(tp);
3848 ocp_write_byte(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data);
3850 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_MISC_2);
3852 ocp_write_byte(tp, MCU_TYPE_USB, USB_MISC_2, ocp_data);
3854 switch (tp->version) {
3857 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_UPHY_XTAL);
3859 ocp_write_byte(tp, MCU_TYPE_USB, USB_UPHY_XTAL, ocp_data);
3866 ocp_write_byte(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data);
3868 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_MISC_2);
3870 ocp_write_byte(tp, MCU_TYPE_USB, USB_MISC_2, ocp_data);
3872 if (ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0) & PCUT_STATUS) {
3873 tp->rtl_ops.hw_phy_cfg(tp);
3875 rtl8152_set_speed(tp, tp->autoneg, tp->speed,
3876 tp->duplex, tp->advertising);
3881 static void r8153_power_cut_en(struct r8152 *tp, bool enable)
3885 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_POWER_CUT);
3890 ocp_write_word(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data);
3892 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0);
3894 ocp_write_word(tp, MCU_TYPE_USB, USB_MISC_0, ocp_data);
3897 static void r8153b_power_cut_en(struct r8152 *tp, bool enable)
3901 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_POWER_CUT);
3906 ocp_write_word(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data);
3908 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0);
3910 ocp_write_word(tp, MCU_TYPE_USB, USB_MISC_0, ocp_data);
3913 static void r8153_queue_wake(struct r8152 *tp, bool enable)
3917 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_INDICATE_FALG);
3922 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_INDICATE_FALG, ocp_data);
3924 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_SUSPEND_FLAG);
3926 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_SUSPEND_FLAG, ocp_data);
3928 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS);
3930 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS, ocp_data);
3933 static bool rtl_can_wakeup(struct r8152 *tp)
3935 struct usb_device *udev = tp->udev;
3940 static void rtl_runtime_suspend_enable(struct r8152 *tp, bool enable)
3945 __rtl_set_wol(tp, WAKE_ANY);
3947 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
3949 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG34);
3951 ocp_write_word(tp, MCU_TYPE_PLA, PLA_CONFIG34, ocp_data);
3953 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
3957 __rtl_set_wol(tp, tp->saved_wolopts);
3959 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
3961 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG34);
3963 ocp_write_word(tp, MCU_TYPE_PLA, PLA_CONFIG34, ocp_data);
3965 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
3969 static void rtl8153_runtime_enable(struct r8152 *tp, bool enable)
3972 r8153_u1u2en(tp, false);
3973 r8153_u2p3en(tp, false);
3974 rtl_runtime_suspend_enable(tp, true);
3976 rtl_runtime_suspend_enable(tp, false);
3978 switch (tp->version) {
3985 r8153_u2p3en(tp, true);
3989 r8153_u1u2en(tp, true);
3993 static void rtl8153b_runtime_enable(struct r8152 *tp, bool enable)
3996 r8153_queue_wake(tp, true);
3997 r8153b_u1u2en(tp, false);
3998 r8153_u2p3en(tp, false);
3999 rtl_runtime_suspend_enable(tp, true);
4000 r8153b_ups_en(tp, true);
4002 r8153b_ups_en(tp, false);
4003 r8153_queue_wake(tp, false);
4004 rtl_runtime_suspend_enable(tp, false);
4005 if (tp->udev->speed >= USB_SPEED_SUPER)
4006 r8153b_u1u2en(tp, true);
4010 static void rtl8153c_runtime_enable(struct r8152 *tp, bool enable)
4013 r8153_queue_wake(tp, true);
4014 r8153b_u1u2en(tp, false);
4015 r8153_u2p3en(tp, false);
4016 rtl_runtime_suspend_enable(tp, true);
4017 r8153c_ups_en(tp, true);
4019 r8153c_ups_en(tp, false);
4020 r8153_queue_wake(tp, false);
4021 rtl_runtime_suspend_enable(tp, false);
4022 r8153b_u1u2en(tp, true);
4026 static void rtl8156_runtime_enable(struct r8152 *tp, bool enable)
4029 r8153_queue_wake(tp, true);
4030 r8153b_u1u2en(tp, false);
4031 r8153_u2p3en(tp, false);
4032 rtl_runtime_suspend_enable(tp, true);
4034 r8153_queue_wake(tp, false);
4035 rtl_runtime_suspend_enable(tp, false);
4036 r8153_u2p3en(tp, true);
4037 if (tp->udev->speed >= USB_SPEED_SUPER)
4038 r8153b_u1u2en(tp, true);
4042 static void r8153_teredo_off(struct r8152 *tp)
4046 switch (tp->version) {
4054 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG);
4057 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, ocp_data);
4073 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, 0xff);
4077 ocp_write_word(tp, MCU_TYPE_PLA, PLA_WDT6_CTRL, WDT6_SET_MODE);
4078 ocp_write_word(tp, MCU_TYPE_PLA, PLA_REALWOW_TIMER, 0);
4079 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_TEREDO_TIMER, 0);
4082 static void rtl_reset_bmu(struct r8152 *tp)
4086 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_BMU_RESET);
4088 ocp_write_byte(tp, MCU_TYPE_USB, USB_BMU_RESET, ocp_data);
4090 ocp_write_byte(tp, MCU_TYPE_USB, USB_BMU_RESET, ocp_data);
4094 static void rtl_clear_bp(struct r8152 *tp, u16 type)
4099 switch (tp->version) {
4108 ocp_write_word(tp, MCU_TYPE_USB, USB_BP2_EN, 0);
4117 ocp_write_byte(tp, type, PLA_BP_EN, 0);
4126 ocp_write_word(tp, type, USB_BP2_EN, 0);
4131 generic_ocp_write(tp, PLA_BP_0, BYTE_EN_DWORD, bp_num << 1, bp, type);
4135 ocp_write_word(tp, type, PLA_BP_BA, 0);
4138 static inline void rtl_reset_ocp_base(struct r8152 *tp)
4140 tp->ocp_base = -1;
4143 static int rtl_phy_patch_request(struct r8152 *tp, bool request, bool wait)
4148 data = ocp_reg_read(tp, OCP_PHY_PATCH_CMD);
4156 ocp_reg_write(tp, OCP_PHY_PATCH_CMD, data);
4161 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
4165 ocp_data = ocp_reg_read(tp, OCP_PHY_PATCH_STAT);
4171 !(ocp_reg_read(tp, OCP_PHY_PATCH_STAT) & PATCH_READY)) {
4172 dev_err(&tp->intf->dev, "PHY patch request fail\n");
4173 rtl_phy_patch_request(tp, false, false);
4180 static void rtl_patch_key_set(struct r8152 *tp, u16 key_addr, u16 patch_key)
4183 sram_write(tp, key_addr, patch_key);
4184 sram_write(tp, SRAM_PHY_LOCK, PHY_PATCH_LOCK);
4188 sram_write(tp, 0x0000, 0x0000);
4190 data = ocp_reg_read(tp, OCP_PHY_LOCK);
4192 ocp_reg_write(tp, OCP_PHY_LOCK, data);
4194 sram_write(tp, key_addr, 0x0000);
4201 rtl_pre_ram_code(struct r8152 *tp, u16 key_addr, u16 patch_key, bool wait)
4203 if (rtl_phy_patch_request(tp, true, wait))
4206 rtl_patch_key_set(tp, key_addr, patch_key);
4211 static int rtl_post_ram_code(struct r8152 *tp, u16 key_addr, bool wait)
4213 rtl_patch_key_set(tp, key_addr, 0);
4215 rtl_phy_patch_request(tp, false, wait);
4220 static bool rtl8152_is_fw_phy_speed_up_ok(struct r8152 *tp, struct fw_phy_speed_up *phy)
4226 switch (tp->version) {
4250 dev_err(&tp->intf->dev, "invalid fw_offset\n");
4256 dev_err(&tp->intf->dev, "invalid block length\n");
4261 dev_err(&tp->intf->dev, "invalid register to load firmware\n");
4270 static bool rtl8152_is_fw_phy_ver_ok(struct r8152 *tp, struct fw_phy_ver *ver)
4274 switch (tp->version) {
4286 dev_err(&tp->intf->dev, "invalid block length\n");
4291 dev_err(&tp->intf->dev, "invalid phy ver addr\n");
4300 static bool rtl8152_is_fw_phy_fixup_ok(struct r8152 *tp, struct fw_phy_fixup *fix)
4304 switch (tp->version) {
4316 dev_err(&tp->intf->dev, "invalid block length\n");
4322 dev_err(&tp->intf->dev, "invalid phy fixup\n");
4331 static bool rtl8152_is_fw_phy_union_ok(struct r8152 *tp, struct fw_phy_union *phy)
4337 switch (tp->version) {
4351 dev_err(&tp->intf->dev, "invalid fw_offset\n");
4357 dev_err(&tp->intf->dev, "invalid block length\n");
4362 dev_err(&tp->intf->dev, "invalid pre_num %d\n", phy->pre_num);
4367 dev_err(&tp->intf->dev, "invalid bp_num %d\n", phy->bp_num);
4376 static bool rtl8152_is_fw_phy_nc_ok(struct r8152 *tp, struct fw_phy_nc *phy)
4382 switch (tp->version) {
4398 dev_err(&tp->intf->dev, "fw_offset too small\n");
4404 dev_err(&tp->intf->dev, "invalid fw_offset\n");
4410 dev_err(&tp->intf->dev, "invalid block length\n");
4415 dev_err(&tp->intf->dev, "invalid register to load firmware\n");
4420 dev_err(&tp->intf->dev, "invalid base address register\n");
4425 dev_err(&tp->intf->dev,
4431 dev_err(&tp->intf->dev,
4437 dev_err(&tp->intf->dev,
4443 dev_err(&tp->intf->dev, "invalid break point number\n");
4452 static bool rtl8152_is_fw_mac_ok(struct r8152 *tp, struct fw_mac *mac)
4461 switch (tp->version) {
4498 switch (tp->version) {
4534 dev_err(&tp->intf->dev, "fw_offset too small\n");
4540 dev_err(&tp->intf->dev, "invalid fw_offset\n");
4546 dev_err(&tp->intf->dev, "invalid block length\n");
4551 dev_err(&tp->intf->dev, "invalid register to load firmware\n");
4556 dev_err(&tp->intf->dev, "invalid base address register\n");
4561 dev_err(&tp->intf->dev, "invalid enabled mask register\n");
4566 dev_err(&tp->intf->dev,
4572 dev_err(&tp->intf->dev, "invalid break point number\n");
4578 dev_err(&tp->intf->dev, "unused bp%u is not zero\n", i);
4592 static long rtl8152_fw_verify_checksum(struct r8152 *tp,
4609 dev_err(&tp->intf->dev, "digestsize incorrect (%u)\n",
4629 dev_err(&tp->intf->dev, "checksum fail\n");
4639 static long rtl8152_check_firmware(struct r8152 *tp, struct rtl_fw *rtl_fw)
4648 dev_err(&tp->intf->dev, "file too small\n");
4652 ret = rtl8152_fw_verify_checksum(tp, fw_hdr, fw->size);
4673 dev_err(&tp->intf->dev,
4678 if (!rtl8152_is_fw_mac_ok(tp, (struct fw_mac *)block)) {
4679 dev_err(&tp->intf->dev,
4687 dev_err(&tp->intf->dev,
4692 if (!rtl8152_is_fw_mac_ok(tp, (struct fw_mac *)block)) {
4693 dev_err(&tp->intf->dev,
4707 dev_err(&tp->intf->dev,
4713 dev_err(&tp->intf->dev,
4722 dev_err(&tp->intf->dev,
4728 dev_err(&tp->intf->dev,
4737 dev_err(&tp->intf->dev,
4743 dev_err(&tp->intf->dev,
4748 if (!rtl8152_is_fw_phy_nc_ok(tp, (struct fw_phy_nc *)block)) {
4749 dev_err(&tp->intf->dev,
4762 dev_err(&tp->intf->dev, "PHY_UNION_NC out of order\n");
4767 dev_err(&tp->intf->dev, "multiple PHY_UNION_NC encountered\n");
4771 if (!rtl8152_is_fw_phy_union_ok(tp, (struct fw_phy_union *)block)) {
4772 dev_err(&tp->intf->dev, "check PHY_UNION_NC failed\n");
4783 dev_err(&tp->intf->dev, "PHY_UNION_NC1 out of order\n");
4788 dev_err(&tp->intf->dev, "multiple PHY NC1 encountered\n");
4792 if (!rtl8152_is_fw_phy_union_ok(tp, (struct fw_phy_union *)block)) {
4793 dev_err(&tp->intf->dev, "check PHY_UNION_NC1 failed\n");
4803 dev_err(&tp->intf->dev, "PHY_UNION_NC2 out of order\n");
4808 dev_err(&tp->intf->dev, "multiple PHY NC2 encountered\n");
4812 if (!rtl8152_is_fw_phy_union_ok(tp, (struct fw_phy_union *)block)) {
4813 dev_err(&tp->intf->dev, "check PHY_UNION_NC2 failed\n");
4822 dev_err(&tp->intf->dev, "PHY_UNION_UC2 out of order\n");
4827 dev_err(&tp->intf->dev, "multiple PHY UC2 encountered\n");
4831 if (!rtl8152_is_fw_phy_union_ok(tp, (struct fw_phy_union *)block)) {
4832 dev_err(&tp->intf->dev, "check PHY_UNION_UC2 failed\n");
4840 dev_err(&tp->intf->dev, "PHY_UNION_UC out of order\n");
4845 dev_err(&tp->intf->dev, "multiple PHY UC encountered\n");
4849 if (!rtl8152_is_fw_phy_union_ok(tp, (struct fw_phy_union *)block)) {
4850 dev_err(&tp->intf->dev, "check PHY_UNION_UC failed\n");
4856 if (!rtl8152_is_fw_phy_union_ok(tp, (struct fw_phy_union *)block)) {
4857 dev_err(&tp->intf->dev, "check RTL_FW_PHY_UNION_MISC failed\n");
4862 if (!rtl8152_is_fw_phy_fixup_ok(tp, (struct fw_phy_fixup *)block)) {
4863 dev_err(&tp->intf->dev, "check PHY fixup failed\n");
4869 dev_err(&tp->intf->dev, "multiple PHY firmware encountered");
4873 if (!rtl8152_is_fw_phy_speed_up_ok(tp, (struct fw_phy_speed_up *)block)) {
4874 dev_err(&tp->intf->dev, "check PHY speed up failed\n");
4887 dev_err(&tp->intf->dev, "Invalid order to set PHY version\n");
4892 dev_err(&tp->intf->dev, "multiple PHY version encountered");
4896 if (!rtl8152_is_fw_phy_ver_ok(tp, (struct fw_phy_ver *)block)) {
4897 dev_err(&tp->intf->dev, "check PHY version failed\n");
4903 dev_warn(&tp->intf->dev, "Unknown type %u is found\n",
4914 dev_err(&tp->intf->dev, "without PHY_STOP\n");
4923 static void rtl_ram_code_speed_up(struct r8152 *tp, struct fw_phy_speed_up *phy, bool wait)
4928 rtl_reset_ocp_base(tp);
4930 if (sram_read(tp, SRAM_GPHY_FW_VER) >= __le16_to_cpu(phy->version)) {
4931 dev_dbg(&tp->intf->dev, "PHY firmware has been the newest\n");
4939 if (rtl_phy_patch_request(tp, true, wait))
4951 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_GPHY_CTRL);
4953 ocp_write_word(tp, MCU_TYPE_USB, USB_GPHY_CTRL, ocp_data);
4955 generic_ocp_write(tp, __le16_to_cpu(phy->fw_reg), 0xff, size, data, MCU_TYPE_USB);
4960 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_POL_GPIO_CTRL);
4962 ocp_write_word(tp, MCU_TYPE_PLA, PLA_POL_GPIO_CTRL, ocp_data);
4965 if (!(ocp_read_word(tp, MCU_TYPE_PLA, PLA_POL_GPIO_CTRL) & POL_GPHY_PATCH))
4970 dev_err(&tp->intf->dev, "ram code speedup mode timeout\n");
4975 rtl_reset_ocp_base(tp);
4977 rtl_phy_patch_request(tp, false, wait);
4979 if (sram_read(tp, SRAM_GPHY_FW_VER) == __le16_to_cpu(phy->version))
4980 dev_dbg(&tp->intf->dev, "successfully applied %s\n", phy->info);
4982 dev_err(&tp->intf->dev, "ram code speedup mode fail\n");
4985 static int rtl8152_fw_phy_ver(struct r8152 *tp, struct fw_phy_ver *phy_ver)
4992 rtl_reset_ocp_base(tp);
4994 if (sram_read(tp, ver_addr) >= ver) {
4995 dev_dbg(&tp->intf->dev, "PHY firmware has been the newest\n");
4999 sram_write(tp, ver_addr, ver);
5001 dev_dbg(&tp->intf->dev, "PHY firmware version %x\n", ver);
5006 static void rtl8152_fw_phy_fixup(struct r8152 *tp, struct fw_phy_fixup *fix)
5010 rtl_reset_ocp_base(tp);
5013 data = ocp_reg_read(tp, addr);
5032 ocp_reg_write(tp, addr, data);
5034 dev_dbg(&tp->intf->dev, "applied ocp %x %x\n", addr, data);
5037 static void rtl8152_fw_phy_union_apply(struct r8152 *tp, struct fw_phy_union *phy)
5043 rtl_reset_ocp_base(tp);
5047 sram_write(tp, __le16_to_cpu(phy->pre_set[i].addr),
5055 ocp_reg_write(tp, OCP_SRAM_ADDR, __le16_to_cpu(phy->fw_reg));
5057 ocp_reg_write(tp, OCP_SRAM_DATA, __le16_to_cpu(data[i]));
5061 sram_write(tp, __le16_to_cpu(phy->bp[i].addr), __le16_to_cpu(phy->bp[i].data));
5064 sram_write(tp, __le16_to_cpu(phy->bp_en.addr), __le16_to_cpu(phy->bp_en.data));
5066 dev_dbg(&tp->intf->dev, "successfully applied %s\n", phy->info);
5069 static void rtl8152_fw_phy_nc_apply(struct r8152 *tp, struct fw_phy_nc *phy)
5075 rtl_reset_ocp_base(tp);
5078 sram_write(tp, mode_reg, __le16_to_cpu(phy->mode_pre));
5079 sram_write(tp, __le16_to_cpu(phy->ba_reg),
5087 ocp_reg_write(tp, OCP_SRAM_ADDR, __le16_to_cpu(phy->fw_reg));
5089 ocp_reg_write(tp, OCP_SRAM_DATA, __le16_to_cpu(data[i]));
5091 sram_write(tp, __le16_to_cpu(phy->patch_en_addr),
5097 sram_write(tp, bp_index, __le16_to_cpu(phy->bp[i]));
5101 sram_write(tp, mode_reg, __le16_to_cpu(phy->mode_post));
5103 dev_dbg(&tp->intf->dev, "successfully applied %s\n", phy->info);
5106 static void rtl8152_fw_mac_apply(struct r8152 *tp, struct fw_mac *mac)
5124 if (fw_ver_reg && ocp_read_byte(tp, MCU_TYPE_USB, fw_ver_reg) >= mac->fw_ver_data) {
5125 dev_dbg(&tp->intf->dev, "%s firmware has been the newest\n", type ? "PLA" : "USB");
5129 rtl_clear_bp(tp, type);
5134 if (tp->version == RTL_VER_04 && type == MCU_TYPE_PLA &&
5135 !(ocp_read_word(tp, MCU_TYPE_PLA, PLA_MACDBG_POST) & DEBUG_OE)) {
5136 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MACDBG_PRE, DEBUG_LTSSM);
5137 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MACDBG_POST, DEBUG_LTSSM);
5146 generic_ocp_write(tp, __le16_to_cpu(mac->fw_reg), 0xff, length, data,
5149 ocp_write_word(tp, type, __le16_to_cpu(mac->bp_ba_addr),
5152 generic_ocp_write(tp, __le16_to_cpu(mac->bp_start), BYTE_EN_DWORD,
5157 ocp_write_word(tp, type, bp_en_addr,
5161 ocp_write_byte(tp, MCU_TYPE_USB, fw_ver_reg,
5164 dev_dbg(&tp->intf->dev, "successfully applied %s\n", mac->info);
5167 static void rtl8152_apply_firmware(struct r8152 *tp, bool power_cut)
5169 struct rtl_fw *rtl_fw = &tp->rtl_fw;
5183 rtl_fw->pre_fw(tp);
5193 rtl8152_fw_mac_apply(tp, (struct fw_mac *)block);
5200 rtl_pre_ram_code(tp, key_addr, __le16_to_cpu(key->key_data), !power_cut);
5206 rtl_post_ram_code(tp, key_addr, !power_cut);
5209 rtl8152_fw_phy_nc_apply(tp, (struct fw_phy_nc *)block);
5212 patch_phy = rtl8152_fw_phy_ver(tp, (struct fw_phy_ver *)block);
5221 rtl8152_fw_phy_union_apply(tp, (struct fw_phy_union *)block);
5225 rtl8152_fw_phy_fixup(tp, (struct fw_phy_fixup *)block);
5228 rtl_ram_code_speed_up(tp, (struct fw_phy_speed_up *)block, !power_cut);
5239 rtl_fw->post_fw(tp);
5241 rtl_reset_ocp_base(tp);
5243 dev_info(&tp->intf->dev, "load %s successfully\n", rtl_fw->version);
5246 static void rtl8152_release_firmware(struct r8152 *tp)
5248 struct rtl_fw *rtl_fw = &tp->rtl_fw;
5256 static int rtl8152_request_firmware(struct r8152 *tp)
5258 struct rtl_fw *rtl_fw = &tp->rtl_fw;
5262 dev_info(&tp->intf->dev, "skip request firmware\n");
5267 rc = request_firmware(&rtl_fw->fw, rtl_fw->fw_name, &tp->intf->dev);
5271 rc = rtl8152_check_firmware(tp, rtl_fw);
5279 dev_warn(&tp->intf->dev,
5287 static void r8152_aldps_en(struct r8152 *tp, bool enable)
5290 ocp_reg_write(tp, OCP_ALDPS_CONFIG, ENPWRSAVE | ENPDNPS |
5293 ocp_reg_write(tp, OCP_ALDPS_CONFIG, ENPDNPS | LINKENA |
5299 static inline void r8152_mmd_indirect(struct r8152 *tp, u16 dev, u16 reg)
5301 ocp_reg_write(tp, OCP_EEE_AR, FUN_ADDR | dev);
5302 ocp_reg_write(tp, OCP_EEE_DATA, reg);
5303 ocp_reg_write(tp, OCP_EEE_AR, FUN_DATA | dev);
5306 static u16 r8152_mmd_read(struct r8152 *tp, u16 dev, u16 reg)
5310 r8152_mmd_indirect(tp, dev, reg);
5311 data = ocp_reg_read(tp, OCP_EEE_DATA);
5312 ocp_reg_write(tp, OCP_EEE_AR, 0x0000);
5317 static void r8152_mmd_write(struct r8152 *tp, u16 dev, u16 reg, u16 data)
5319 r8152_mmd_indirect(tp, dev, reg);
5320 ocp_reg_write(tp, OCP_EEE_DATA, data);
5321 ocp_reg_write(tp, OCP_EEE_AR, 0x0000);
5324 static void r8152_eee_en(struct r8152 *tp, bool enable)
5329 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEE_CR);
5330 config1 = ocp_reg_read(tp, OCP_EEE_CONFIG1) & ~sd_rise_time_mask;
5331 config2 = ocp_reg_read(tp, OCP_EEE_CONFIG2);
5332 config3 = ocp_reg_read(tp, OCP_EEE_CONFIG3) & ~fast_snr_mask;
5349 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEE_CR, ocp_data);
5350 ocp_reg_write(tp, OCP_EEE_CONFIG1, config1);
5351 ocp_reg_write(tp, OCP_EEE_CONFIG2, config2);
5352 ocp_reg_write(tp, OCP_EEE_CONFIG3, config3);
5355 static void r8153_eee_en(struct r8152 *tp, bool enable)
5360 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEE_CR);
5361 config = ocp_reg_read(tp, OCP_EEE_CFG);
5371 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEE_CR, ocp_data);
5372 ocp_reg_write(tp, OCP_EEE_CFG, config);
5374 tp->ups_info.eee = enable;
5377 static void r8156_eee_en(struct r8152 *tp, bool enable)
5381 r8153_eee_en(tp, enable);
5383 config = ocp_reg_read(tp, OCP_EEE_ADV2);
5390 ocp_reg_write(tp, OCP_EEE_ADV2, config);
5393 static void rtl_eee_enable(struct r8152 *tp, bool enable)
5395 switch (tp->version) {
5400 r8152_eee_en(tp, true);
5401 r8152_mmd_write(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
5402 tp->eee_adv);
5404 r8152_eee_en(tp, false);
5405 r8152_mmd_write(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV, 0);
5416 r8153_eee_en(tp, true);
5417 ocp_reg_write(tp, OCP_EEE_ADV, tp->eee_adv);
5419 r8153_eee_en(tp, false);
5420 ocp_reg_write(tp, OCP_EEE_ADV, 0);
5429 r8156_eee_en(tp, true);
5430 ocp_reg_write(tp, OCP_EEE_ADV, tp->eee_adv);
5432 r8156_eee_en(tp, false);
5433 ocp_reg_write(tp, OCP_EEE_ADV, 0);
5441 static void r8152b_enable_fc(struct r8152 *tp)
5445 anar = r8152_mdio_read(tp, MII_ADVERTISE);
5447 r8152_mdio_write(tp, MII_ADVERTISE, anar);
5449 tp->ups_info.flow_control = true;
5452 static void rtl8152_disable(struct r8152 *tp)
5454 r8152_aldps_en(tp, false);
5455 rtl_disable(tp);
5456 r8152_aldps_en(tp, true);
5459 static void r8152b_hw_phy_cfg(struct r8152 *tp)
5461 rtl8152_apply_firmware(tp, false);
5462 rtl_eee_enable(tp, tp->eee_en);
5463 r8152_aldps_en(tp, true);
5464 r8152b_enable_fc(tp);
5466 set_bit(PHY_RESET, &tp->flags);
5469 static void wait_oob_link_list_ready(struct r8152 *tp)
5475 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
5477 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
5484 static void r8156b_wait_loading_flash(struct r8152 *tp)
5486 if ((ocp_read_word(tp, MCU_TYPE_PLA, PLA_GPHY_CTRL) & GPHY_FLASH) &&
5487 !(ocp_read_word(tp, MCU_TYPE_USB, USB_GPHY_CTRL) & BYPASS_FLASH)) {
5491 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
5493 if (ocp_read_word(tp, MCU_TYPE_USB, USB_GPHY_CTRL) & GPHY_PATCH_DONE)
5500 static void r8152b_exit_oob(struct r8152 *tp)
5504 ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
5506 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
5508 rxdy_gated_en(tp, true);
5509 r8153_teredo_off(tp);
5510 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
5511 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CR, 0x00);
5513 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
5515 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
5517 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
5519 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
5521 wait_oob_link_list_ready(tp);
5523 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
5525 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
5527 wait_oob_link_list_ready(tp);
5529 rtl8152_nic_reset(tp);
5532 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_NORMAL);
5534 if (tp->udev->speed == USB_SPEED_FULL ||
5535 tp->udev->speed == USB_SPEED_LOW) {
5537 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1,
5539 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2,
5543 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1,
5545 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2,
5550 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_TXFIFO_CTRL, TXFIFO_THR_NORMAL2);
5552 ocp_write_byte(tp, MCU_TYPE_USB, USB_TX_AGG, TX_AGG_MAX_THRESHOLD);
5553 ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_BUF_TH, RX_THR_HIGH);
5554 ocp_write_dword(tp, MCU_TYPE_USB, USB_TX_DMA,
5557 rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX);
5559 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8152_RMS);
5561 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR0);
5563 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TCR0, ocp_data);
5566 static void r8152b_enter_oob(struct r8152 *tp)
5570 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
5572 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
5574 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_OOB);
5575 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1, RXFIFO_THR2_OOB);
5576 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2, RXFIFO_THR3_OOB);
5578 rtl_disable(tp);
5580 wait_oob_link_list_ready(tp);
5582 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
5584 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
5586 wait_oob_link_list_ready(tp);
5588 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8152_RMS);
5590 rtl_rx_vlan_en(tp, true);
5592 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_BDC_CR);
5594 ocp_write_word(tp, MCU_TYPE_PLA, PLA_BDC_CR, ocp_data);
5596 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
5598 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
5600 rxdy_gated_en(tp, false);
5602 ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
5604 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
5607 static int r8153_pre_firmware_1(struct r8152 *tp)
5613 u32 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_WDT1_CTRL);
5615 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
5625 static int r8153_post_firmware_1(struct r8152 *tp)
5628 if (ocp_read_byte(tp, MCU_TYPE_USB, USB_CSTMR) & FORCE_SUPER)
5629 ocp_write_word(tp, MCU_TYPE_USB, USB_BP_4, BP4_SUPER_ONLY);
5632 ocp_write_word(tp, MCU_TYPE_PLA, PLA_UPHY_TIMER, 36000 / 16);
5637 static int r8153_pre_firmware_2(struct r8152 *tp)
5641 r8153_pre_firmware_1(tp);
5643 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_FIX_EN0);
5645 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_FIX_EN0, ocp_data);
5650 static int r8153_post_firmware_2(struct r8152 *tp)
5655 if (ocp_read_byte(tp, MCU_TYPE_USB, USB_CSTMR) & FORCE_SUPER) {
5656 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_BP_EN);
5658 ocp_write_word(tp, MCU_TYPE_PLA, PLA_BP_EN, ocp_data);
5662 ocp_write_word(tp, MCU_TYPE_PLA, PLA_UPHY_TIMER, 36000 / 16);
5665 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS, U3P3_CHECK_EN | 4);
5667 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_FIX_EN0);
5669 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_FIX_EN0, ocp_data);
5671 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_USB2PHY);
5673 ocp_write_byte(tp, MCU_TYPE_USB, USB_USB2PHY, ocp_data);
5678 static int r8153_post_firmware_3(struct r8152 *tp)
5682 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_USB2PHY);
5684 ocp_write_byte(tp, MCU_TYPE_USB, USB_USB2PHY, ocp_data);
5686 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_FIX_EN1);
5688 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_FIX_EN1, ocp_data);
5693 static int r8153b_pre_firmware_1(struct r8152 *tp)
5696 ocp_write_word(tp, MCU_TYPE_USB, USB_FC_TIMER,
5702 static int r8153b_post_firmware_1(struct r8152 *tp)
5707 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_MISC_1);
5709 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_BP_EN);
5711 ocp_write_word(tp, MCU_TYPE_PLA, PLA_BP_EN, ocp_data);
5714 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_CTRL);
5716 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_CTRL, ocp_data);
5718 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_TASK);
5720 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_TASK, ocp_data);
5722 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_FIX_EN1);
5724 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_FIX_EN1, ocp_data);
5729 static int r8153c_post_firmware_1(struct r8152 *tp)
5733 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_CTRL);
5735 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_CTRL, ocp_data);
5737 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_TASK);
5739 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_TASK, ocp_data);
5744 static int r8156a_post_firmware_1(struct r8152 *tp)
5748 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_FIX_EN1);
5750 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_FIX_EN1, ocp_data);
5753 ocp_write_dword(tp, MCU_TYPE_USB, USB_UPHY3_MDCMDIO, 0x4026840e);
5754 ocp_write_dword(tp, MCU_TYPE_USB, USB_UPHY3_MDCMDIO, 0x4001acc9);
5759 static void r8153_aldps_en(struct r8152 *tp, bool enable)
5763 data = ocp_reg_read(tp, OCP_POWER_CFG);
5766 ocp_reg_write(tp, OCP_POWER_CFG, data);
5771 ocp_reg_write(tp, OCP_POWER_CFG, data);
5773 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
5776 if (ocp_read_word(tp, MCU_TYPE_PLA, 0xe000) & 0x0100)
5781 tp->ups_info.aldps = enable;
5784 static void r8153_hw_phy_cfg(struct r8152 *tp)
5790 r8153_aldps_en(tp, false);
5793 rtl_eee_enable(tp, false);
5795 rtl8152_apply_firmware(tp, false);
5797 if (tp->version == RTL_VER_03) {
5798 data = ocp_reg_read(tp, OCP_EEE_CFG);
5800 ocp_reg_write(tp, OCP_EEE_CFG, data);
5803 data = ocp_reg_read(tp, OCP_POWER_CFG);
5805 ocp_reg_write(tp, OCP_POWER_CFG, data);
5807 data = ocp_reg_read(tp, OCP_DOWN_SPEED);
5809 ocp_reg_write(tp, OCP_DOWN_SPEED, data);
5810 data = ocp_reg_read(tp, OCP_POWER_CFG);
5812 ocp_reg_write(tp, OCP_POWER_CFG, data);
5813 sram_write(tp, SRAM_IMPEDANCE, 0x0b13);
5815 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
5817 ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
5820 sram_write(tp, SRAM_LPF_CFG, 0xf70f);
5823 sram_write(tp, SRAM_10M_AMP1, 0x00af);
5824 sram_write(tp, SRAM_10M_AMP2, 0x0208);
5826 if (tp->eee_en)
5827 rtl_eee_enable(tp, true);
5829 r8153_aldps_en(tp, true);
5830 r8152b_enable_fc(tp);
5832 switch (tp->version) {
5839 r8153_u2p3en(tp, true);
5843 set_bit(PHY_RESET, &tp->flags);
5846 static u32 r8152_efuse_read(struct r8152 *tp, u8 addr)
5850 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EFUSE_CMD, EFUSE_READ_CMD | addr);
5851 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EFUSE_CMD);
5853 ocp_data |= ocp_read_word(tp, MCU_TYPE_PLA, PLA_EFUSE_DATA);
5858 static void r8153b_hw_phy_cfg(struct r8152 *tp)
5863 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0);
5866 ocp_write_word(tp, MCU_TYPE_USB, USB_MISC_0, ocp_data);
5870 r8153_aldps_en(tp, false);
5873 rtl_eee_enable(tp, false);
5876 ocp_write_word(tp, MCU_TYPE_USB, USB_U1U2_TIMER, 500);
5878 data = r8153_phy_status(tp, 0);
5883 rtl8152_apply_firmware(tp, true);
5885 data = r8152_mdio_read(tp, MII_BMCR);
5887 r8152_mdio_write(tp, MII_BMCR, data);
5891 rtl8152_apply_firmware(tp, false);
5895 r8153b_green_en(tp, test_bit(GREEN_ETHERNET, &tp->flags));
5897 data = sram_read(tp, SRAM_GREEN_CFG);
5899 sram_write(tp, SRAM_GREEN_CFG, data);
5900 data = ocp_reg_read(tp, OCP_NCTL_CFG);
5902 ocp_reg_write(tp, OCP_NCTL_CFG, data);
5909 ocp_data = r8152_efuse_read(tp, 0x7d);
5912 ocp_reg_write(tp, OCP_ADC_IOFFSET, data);
5918 ocp_data = ocp_reg_read(tp, 0xc426);
5924 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_UPS_CFG);
5926 ocp_write_word(tp, MCU_TYPE_USB, USB_UPS_CFG, ocp_data);
5929 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
5931 ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
5934 if (!rtl_phy_patch_request(tp, true, true)) {
5935 data = ocp_reg_read(tp, OCP_POWER_CFG);
5937 ocp_reg_write(tp, OCP_POWER_CFG, data);
5938 tp->ups_info.eee_ckdiv = true;
5940 data = ocp_reg_read(tp, OCP_DOWN_SPEED);
5942 ocp_reg_write(tp, OCP_DOWN_SPEED, data);
5943 tp->ups_info.eee_cmod_lv = true;
5944 tp->ups_info._10m_ckdiv = true;
5945 tp->ups_info.eee_plloff_giga = true;
5947 ocp_reg_write(tp, OCP_SYSCLK_CFG, 0);
5948 ocp_reg_write(tp, OCP_SYSCLK_CFG, clk_div_expo(5));
5949 tp->ups_info._250m_ckdiv = true;
5951 rtl_phy_patch_request(tp, false, true);
5954 if (tp->eee_en)
5955 rtl_eee_enable(tp, true);
5957 r8153_aldps_en(tp, true);
5958 r8152b_enable_fc(tp);
5960 set_bit(PHY_RESET, &tp->flags);
5963 static void r8153c_hw_phy_cfg(struct r8152 *tp)
5965 r8153b_hw_phy_cfg(tp);
5967 tp->ups_info.r_tune = true;
5970 static void rtl8153_change_mtu(struct r8152 *tp)
5972 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, mtu_to_size(tp->netdev->mtu));
5973 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_MTPS, MTPS_JUMBO);
5976 static void r8153_first_init(struct r8152 *tp)
5980 rxdy_gated_en(tp, true);
5981 r8153_teredo_off(tp);
5983 ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
5985 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
5987 rtl8152_nic_reset(tp);
5988 rtl_reset_bmu(tp);
5990 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
5992 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
5994 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
5996 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
5998 wait_oob_link_list_ready(tp);
6000 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
6002 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
6004 wait_oob_link_list_ready(tp);
6006 rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX);
6008 rtl8153_change_mtu(tp);
6010 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR0);
6012 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TCR0, ocp_data);
6014 rtl8152_nic_reset(tp);
6017 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_NORMAL);
6018 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1, RXFIFO_THR2_NORMAL);
6019 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2, RXFIFO_THR3_NORMAL);
6021 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_TXFIFO_CTRL, TXFIFO_THR_NORMAL2);
6024 static void r8153_enter_oob(struct r8152 *tp)
6028 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
6030 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
6033 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_OOB);
6034 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1, RXFIFO_THR2_OOB);
6035 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2, RXFIFO_THR3_OOB);
6037 rtl_disable(tp);
6038 rtl_reset_bmu(tp);
6040 wait_oob_link_list_ready(tp);
6042 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
6044 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
6046 wait_oob_link_list_ready(tp);
6048 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, 1522);
6049 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_MTPS, MTPS_DEFAULT);
6051 switch (tp->version) {
6056 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG);
6058 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, ocp_data);
6068 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_WAKE_BASE, 0x00ff);
6075 rtl_rx_vlan_en(tp, true);
6077 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_BDC_CR);
6079 ocp_write_word(tp, MCU_TYPE_PLA, PLA_BDC_CR, ocp_data);
6081 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
6083 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
6085 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
6087 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
6089 rxdy_gated_en(tp, false);
6091 ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
6093 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
6096 static void rtl8153_disable(struct r8152 *tp)
6098 r8153_aldps_en(tp, false);
6099 rtl_disable(tp);
6100 rtl_reset_bmu(tp);
6101 r8153_aldps_en(tp, true);
6104 static u32 fc_pause_on_auto(struct r8152 *tp)
6106 return (ALIGN(mtu_to_size(tp->netdev->mtu), 1024) + 6 * 1024);
6109 static u32 fc_pause_off_auto(struct r8152 *tp)
6111 return (ALIGN(mtu_to_size(tp->netdev->mtu), 1024) + 14 * 1024);
6114 static void r8156_fc_parameter(struct r8152 *tp)
6116 u32 pause_on = tp->fc_pause_on ? tp->fc_pause_on : fc_pause_on_auto(tp);
6117 u32 pause_off = tp->fc_pause_off ? tp->fc_pause_off : fc_pause_off_auto(tp);
6119 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_FULL, pause_on / 16);
6120 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_EMPTY, pause_off / 16);
6123 static int rtl8156_enable(struct r8152 *tp)
6128 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
6131 r8156_fc_parameter(tp);
6132 set_tx_qlen(tp);
6133 rtl_set_eee_plus(tp);
6134 r8153_set_rx_early_timeout(tp);
6135 r8153_set_rx_early_size(tp);
6137 speed = rtl8152_get_speed(tp);
6138 rtl_set_ifg(tp, speed);
6140 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4);
6145 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4, ocp_data);
6148 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEE_TXTWSYS, 0x11);
6150 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEE_TXTWSYS, 0x3d);
6152 if (tp->udev->speed == USB_SPEED_HIGH) {
6154 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_L1_CTRL);
6160 ocp_write_word(tp, MCU_TYPE_USB, USB_L1_CTRL, ocp_data);
6163 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_TASK);
6165 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_TASK, ocp_data);
6168 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_TASK, ocp_data);
6170 return rtl_enable(tp);
6173 static void rtl8156_disable(struct r8152 *tp)
6175 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_FULL, 0);
6176 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_EMPTY, 0);
6178 rtl8153_disable(tp);
6181 static int rtl8156b_enable(struct r8152 *tp)
6186 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
6189 set_tx_qlen(tp);
6190 rtl_set_eee_plus(tp);
6192 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_RX_AGGR_NUM);
6194 ocp_write_word(tp, MCU_TYPE_USB, USB_RX_AGGR_NUM, ocp_data);
6196 r8153_set_rx_early_timeout(tp);
6197 r8153_set_rx_early_size(tp);
6199 speed = rtl8152_get_speed(tp);
6200 rtl_set_ifg(tp, speed);
6202 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4);
6207 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4, ocp_data);
6209 if (tp->udev->speed == USB_SPEED_HIGH) {
6210 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_L1_CTRL);
6216 ocp_write_word(tp, MCU_TYPE_USB, USB_L1_CTRL, ocp_data);
6219 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_TASK);
6221 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_TASK, ocp_data);
6224 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_TASK, ocp_data);
6226 return rtl_enable(tp);
6229 static int rtl8152_set_speed(struct r8152 *tp, u8 autoneg, u32 speed, u8 duplex,
6244 tp->ups_info.speed_duplex = FORCE_10M_FULL;
6246 tp->ups_info.speed_duplex = FORCE_10M_HALF;
6253 tp->ups_info.speed_duplex = FORCE_100M_FULL;
6255 tp->ups_info.speed_duplex = FORCE_100M_HALF;
6259 if (tp->mii.supports_gmii) {
6261 tp->ups_info.speed_duplex = NWAY_1000M_FULL;
6271 tp->mii.full_duplex = 1;
6273 tp->mii.full_duplex = 0;
6275 tp->mii.force_media = 1;
6283 if (tp->mii.supports_gmii) {
6286 if (tp->support_2500full)
6293 orig = r8152_mdio_read(tp, MII_ADVERTISE);
6298 tp->ups_info.speed_duplex = NWAY_10M_HALF;
6302 tp->ups_info.speed_duplex = NWAY_10M_FULL;
6307 tp->ups_info.speed_duplex = NWAY_100M_HALF;
6311 tp->ups_info.speed_duplex = NWAY_100M_FULL;
6315 r8152_mdio_write(tp, MII_ADVERTISE, new1);
6316 tp->mii.advertising = new1;
6319 if (tp->mii.supports_gmii) {
6320 orig = r8152_mdio_read(tp, MII_CTRL1000);
6326 tp->ups_info.speed_duplex = NWAY_1000M_FULL;
6330 r8152_mdio_write(tp, MII_CTRL1000, new1);
6333 if (tp->support_2500full) {
6334 orig = ocp_reg_read(tp, OCP_10GBT_CTRL);
6339 tp->ups_info.speed_duplex = NWAY_2500M_FULL;
6343 ocp_reg_write(tp, OCP_10GBT_CTRL, new1);
6348 tp->mii.force_media = 0;
6351 if (test_and_clear_bit(PHY_RESET, &tp->flags))
6354 r8152_mdio_write(tp, MII_BMCR, bmcr);
6361 if ((r8152_mdio_read(tp, MII_BMCR) & BMCR_RESET) == 0)
6370 static void rtl8152_up(struct r8152 *tp)
6372 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
6375 r8152_aldps_en(tp, false);
6376 r8152b_exit_oob(tp);
6377 r8152_aldps_en(tp, true);
6380 static void rtl8152_down(struct r8152 *tp)
6382 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags)) {
6383 rtl_drop_queued_tx(tp);
6387 r8152_power_cut_en(tp, false);
6388 r8152_aldps_en(tp, false);
6389 r8152b_enter_oob(tp);
6390 r8152_aldps_en(tp, true);
6393 static void rtl8153_up(struct r8152 *tp)
6397 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
6400 r8153_u1u2en(tp, false);
6401 r8153_u2p3en(tp, false);
6402 r8153_aldps_en(tp, false);
6403 r8153_first_init(tp);
6405 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CONFIG6);
6407 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CONFIG6, ocp_data);
6409 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_LWAKE_CTRL_REG);
6411 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_LWAKE_CTRL_REG, ocp_data);
6413 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_SSPHYLINK1);
6415 ocp_write_word(tp, MCU_TYPE_USB, USB_SSPHYLINK1, ocp_data);
6417 r8153_aldps_en(tp, true);
6419 switch (tp->version) {
6426 r8153_u2p3en(tp, true);
6430 r8153_u1u2en(tp, true);
6433 static void rtl8153_down(struct r8152 *tp)
6437 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags)) {
6438 rtl_drop_queued_tx(tp);
6442 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CONFIG6);
6444 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CONFIG6, ocp_data);
6446 r8153_u1u2en(tp, false);
6447 r8153_u2p3en(tp, false);
6448 r8153_power_cut_en(tp, false);
6449 r8153_aldps_en(tp, false);
6450 r8153_enter_oob(tp);
6451 r8153_aldps_en(tp, true);
6454 static void rtl8153b_up(struct r8152 *tp)
6458 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
6461 r8153b_u1u2en(tp, false);
6462 r8153_u2p3en(tp, false);
6463 r8153_aldps_en(tp, false);
6465 r8153_first_init(tp);
6466 ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_BUF_TH, RX_THR_B);
6468 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3);
6470 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3, ocp_data);
6472 r8153_aldps_en(tp, true);
6474 if (tp->udev->speed >= USB_SPEED_SUPER)
6475 r8153b_u1u2en(tp, true);
6478 static void rtl8153b_down(struct r8152 *tp)
6482 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags)) {
6483 rtl_drop_queued_tx(tp);
6487 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3);
6489 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3, ocp_data);
6491 r8153b_u1u2en(tp, false);
6492 r8153_u2p3en(tp, false);
6493 r8153b_power_cut_en(tp, false);
6494 r8153_aldps_en(tp, false);
6495 r8153_enter_oob(tp);
6496 r8153_aldps_en(tp, true);
6499 static void rtl8153c_change_mtu(struct r8152 *tp)
6501 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, mtu_to_size(tp->netdev->mtu));
6502 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_MTPS, 10 * 1024 / 64);
6504 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TXFIFO_CTRL, 512 / 64);
6509 if (tp->netdev->mtu < 8000)
6510 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TXFIFO_FULL, 2048 / 8);
6512 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TXFIFO_FULL, 900 / 8);
6515 static void rtl8153c_up(struct r8152 *tp)
6519 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
6522 r8153b_u1u2en(tp, false);
6523 r8153_u2p3en(tp, false);
6524 r8153_aldps_en(tp, false);
6526 rxdy_gated_en(tp, true);
6527 r8153_teredo_off(tp);
6529 ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
6531 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
6533 rtl8152_nic_reset(tp);
6534 rtl_reset_bmu(tp);
6536 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
6538 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
6540 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
6542 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
6544 wait_oob_link_list_ready(tp);
6546 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
6548 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
6550 wait_oob_link_list_ready(tp);
6552 rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX);
6554 rtl8153c_change_mtu(tp);
6556 rtl8152_nic_reset(tp);
6559 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, 0x02);
6560 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_RXFIFO_FULL, 0x08);
6561 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1, RXFIFO_THR2_NORMAL);
6562 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2, RXFIFO_THR3_NORMAL);
6564 ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_BUF_TH, RX_THR_B);
6566 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
6568 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG34);
6570 ocp_write_word(tp, MCU_TYPE_PLA, PLA_CONFIG34, ocp_data);
6572 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
6574 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3);
6576 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3, ocp_data);
6578 r8153_aldps_en(tp, true);
6579 r8153b_u1u2en(tp, true);
6582 static void rtl8156_change_mtu(struct r8152 *tp)
6584 u32 rx_max_size = mtu_to_size(tp->netdev->mtu);
6586 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, rx_max_size);
6587 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_MTPS, MTPS_JUMBO);
6588 r8156_fc_parameter(tp);
6591 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TXFIFO_CTRL, 512 / 64);
6592 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TXFIFO_FULL,
6596 static void rtl8156_up(struct r8152 *tp)
6600 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
6603 r8153b_u1u2en(tp, false);
6604 r8153_u2p3en(tp, false);
6605 r8153_aldps_en(tp, false);
6607 rxdy_gated_en(tp, true);
6608 r8153_teredo_off(tp);
6610 ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
6612 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
6614 rtl8152_nic_reset(tp);
6615 rtl_reset_bmu(tp);
6617 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
6619 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
6621 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
6623 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
6625 rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX);
6627 rtl8156_change_mtu(tp);
6629 switch (tp->version) {
6633 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_BMU_CONFIG);
6635 ocp_write_word(tp, MCU_TYPE_USB, USB_BMU_CONFIG, ocp_data);
6642 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_FULL);
6645 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_FULL, ocp_data);
6647 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3);
6649 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3, ocp_data);
6651 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_SPEED_OPTION);
6653 ocp_write_word(tp, MCU_TYPE_USB, USB_SPEED_OPTION, ocp_data);
6655 ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_BUF_TH, 0x00600400);
6657 if (tp->saved_wolopts != __rtl_get_wol(tp)) {
6658 netif_warn(tp, ifup, tp->netdev, "wol setting is changed\n");
6659 __rtl_set_wol(tp, tp->saved_wolopts);
6662 r8153_aldps_en(tp, true);
6663 r8153_u2p3en(tp, true);
6665 if (tp->udev->speed >= USB_SPEED_SUPER)
6666 r8153b_u1u2en(tp, true);
6669 static void rtl8156_down(struct r8152 *tp)
6673 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags)) {
6674 rtl_drop_queued_tx(tp);
6678 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3);
6680 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3, ocp_data);
6682 r8153b_u1u2en(tp, false);
6683 r8153_u2p3en(tp, false);
6684 r8153b_power_cut_en(tp, false);
6685 r8153_aldps_en(tp, false);
6687 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
6689 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
6692 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_FULL, 64 / 16);
6693 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_FULL, 1024 / 16);
6694 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_EMPTY, 4096 / 16);
6696 rtl_disable(tp);
6697 rtl_reset_bmu(tp);
6699 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, 1522);
6700 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_MTPS, MTPS_DEFAULT);
6706 ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_WAKE_BASE, 0x00ff);
6708 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
6710 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
6712 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
6714 ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
6716 rtl_rx_vlan_en(tp, true);
6717 rxdy_gated_en(tp, false);
6719 ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
6721 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
6723 r8153_aldps_en(tp, true);
6726 static bool rtl8152_in_nway(struct r8152 *tp)
6730 ocp_write_word(tp, MCU_TYPE_PLA, PLA_OCP_GPHY_BASE, 0x2000);
6731 tp->ocp_base = 0x2000;
6732 ocp_write_byte(tp, MCU_TYPE_PLA, 0xb014, 0x4c); /* phy state */
6733 nway_state = ocp_read_word(tp, MCU_TYPE_PLA, 0xb01a);
6742 static bool rtl8153_in_nway(struct r8152 *tp)
6744 u16 phy_state = ocp_reg_read(tp, OCP_PHY_STATE) & 0xff;
6752 static void r8156_mdio_force_mode(struct r8152 *tp)
6760 data = ocp_reg_read(tp, 0xa5b4);
6763 ocp_reg_write(tp, 0xa5b4, data);
6767 static void set_carrier(struct r8152 *tp)
6769 struct net_device *netdev = tp->netdev;
6770 struct napi_struct *napi = &tp->napi;
6773 speed = rtl8152_get_speed(tp);
6777 tp->rtl_ops.enable(tp);
6781 rtl_start_rx(tp);
6782 clear_bit(RTL8152_SET_RX_MODE, &tp->flags);
6786 netif_info(tp, link, netdev, "carrier on\n");
6788 skb_queue_len(&tp->tx_queue) < tp->tx_qlen) {
6794 tasklet_disable(&tp->tx_tl);
6796 tp->rtl_ops.disable(tp);
6798 tasklet_enable(&tp->tx_tl);
6799 netif_info(tp, link, netdev, "carrier off\n");
6806 struct r8152 *tp = container_of(work, struct r8152, schedule.work);
6811 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags) || !netif_running(tp->netdev))
6814 if (usb_autopm_get_interface(tp->intf) < 0)
6817 if (!test_bit(WORK_ENABLE, &tp->flags))
6820 if (!mutex_trylock(&tp->control)) {
6821 schedule_delayed_work(&tp->schedule, 0);
6825 if (test_and_clear_bit(RTL8152_LINK_CHG, &tp->flags))
6826 set_carrier(tp);
6828 if (test_and_clear_bit(RTL8152_SET_RX_MODE, &tp->flags))
6829 _rtl8152_set_rx_mode(tp->netdev);
6832 if (test_and_clear_bit(SCHEDULE_TASKLET, &tp->flags) &&
6833 netif_carrier_ok(tp->netdev))
6834 tasklet_schedule(&tp->tx_tl);
6836 if (test_and_clear_bit(RX_EPROTO, &tp->flags) &&
6837 !list_empty(&tp->rx_done))
6838 napi_schedule(&tp->napi);
6840 mutex_unlock(&tp->control);
6843 usb_autopm_put_interface(tp->intf);
6848 struct r8152 *tp = container_of(work, struct r8152, hw_phy_work.work);
6850 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
6853 if (usb_autopm_get_interface(tp->intf) < 0)
6856 mutex_lock(&tp->control);
6858 if (rtl8152_request_firmware(tp) == -ENODEV && tp->rtl_fw.retry) {
6859 tp->rtl_fw.retry = false;
6860 tp->rtl_fw.fw = NULL;
6864 queue_delayed_work(system_long_wq, &tp->hw_phy_work, HZ * 10);
6868 tp->rtl_ops.hw_phy_cfg(tp);
6870 rtl8152_set_speed(tp, tp->autoneg, tp->speed, tp->duplex,
6871 tp->advertising);
6874 mutex_unlock(&tp->control);
6876 usb_autopm_put_interface(tp->intf);
6883 struct r8152 *tp = container_of(nb, struct r8152, pm_notifier);
6888 usb_autopm_get_interface(tp->intf);
6893 usb_autopm_put_interface(tp->intf);
6908 struct r8152 *tp = netdev_priv(netdev);
6911 if (work_busy(&tp->hw_phy_work.work) & WORK_BUSY_PENDING) {
6912 cancel_delayed_work_sync(&tp->hw_phy_work);
6913 rtl_hw_phy_work_func_t(&tp->hw_phy_work.work);
6916 res = alloc_all_mem(tp);
6920 res = usb_autopm_get_interface(tp->intf);
6924 mutex_lock(&tp->control);
6926 tp->rtl_ops.up(tp);
6930 set_bit(WORK_ENABLE, &tp->flags);
6932 res = usb_submit_urb(tp->intr_urb, GFP_KERNEL);
6935 netif_device_detach(tp->netdev);
6936 netif_warn(tp, ifup, netdev, "intr_urb submit failed: %d\n",
6940 napi_enable(&tp->napi);
6941 tasklet_enable(&tp->tx_tl);
6943 mutex_unlock(&tp->control);
6945 usb_autopm_put_interface(tp->intf);
6947 tp->pm_notifier.notifier_call = rtl_notifier;
6948 register_pm_notifier(&tp->pm_notifier);
6953 mutex_unlock(&tp->control);
6954 usb_autopm_put_interface(tp->intf);
6956 free_all_mem(tp);
6963 struct r8152 *tp = netdev_priv(netdev);
6967 unregister_pm_notifier(&tp->pm_notifier);
6969 tasklet_disable(&tp->tx_tl);
6970 clear_bit(WORK_ENABLE, &tp->flags);
6971 usb_kill_urb(tp->intr_urb);
6972 cancel_delayed_work_sync(&tp->schedule);
6973 napi_disable(&tp->napi);
6976 res = usb_autopm_get_interface(tp->intf);
6977 if (res < 0 || test_bit(RTL8152_INACCESSIBLE, &tp->flags)) {
6978 rtl_drop_queued_tx(tp);
6979 rtl_stop_rx(tp);
6981 mutex_lock(&tp->control);
6983 tp->rtl_ops.down(tp);
6985 mutex_unlock(&tp->control);
6989 usb_autopm_put_interface(tp->intf);
6991 free_all_mem(tp);
6996 static void rtl_tally_reset(struct r8152 *tp)
7000 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_RSTTALLY);
7002 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RSTTALLY, ocp_data);
7005 static void r8152b_init(struct r8152 *tp)
7010 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
7013 data = r8152_mdio_read(tp, MII_BMCR);
7016 r8152_mdio_write(tp, MII_BMCR, data);
7019 r8152_aldps_en(tp, false);
7021 if (tp->version == RTL_VER_01) {
7022 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE);
7024 ocp_write_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE, ocp_data);
7027 r8152_power_cut_en(tp, false);
7029 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
7031 ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
7032 ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL);
7035 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL, ocp_data);
7038 ocp_write_word(tp, MCU_TYPE_PLA, PLA_GPHY_INTR_IMR, ocp_data);
7040 rtl_tally_reset(tp);
7043 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
7045 ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
7048 static void r8153_init(struct r8152 *tp)
7054 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
7057 r8153_u1u2en(tp, false);
7060 if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) &
7065 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
7069 data = r8153_phy_status(tp, 0);
7071 if (tp->version == RTL_VER_03 || tp->version == RTL_VER_04 ||
7072 tp->version == RTL_VER_05)
7073 ocp_reg_write(tp, OCP_ADC_CFG, CKADSEL_L | ADC_EN | EN_EMI_L);
7075 data = r8152_mdio_read(tp, MII_BMCR);
7078 r8152_mdio_write(tp, MII_BMCR, data);
7081 data = r8153_phy_status(tp, PHY_STAT_LAN_ON);
7083 r8153_u2p3en(tp, false);
7085 if (tp->version == RTL_VER_04) {
7086 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_SSPHYLINK2);
7089 ocp_write_word(tp, MCU_TYPE_USB, USB_SSPHYLINK2, ocp_data);
7091 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_USB2PHY);
7093 ocp_write_byte(tp, MCU_TYPE_USB, USB_USB2PHY, ocp_data);
7094 } else if (tp->version == RTL_VER_05) {
7095 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_DMY_REG0);
7097 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_DMY_REG0, ocp_data);
7099 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY1);
7100 if (ocp_read_word(tp, MCU_TYPE_USB, USB_BURST_SIZE) == 0)
7104 ocp_write_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY1, ocp_data);
7105 } else if (tp->version == RTL_VER_06) {
7106 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY1);
7107 if (ocp_read_word(tp, MCU_TYPE_USB, USB_BURST_SIZE) == 0)
7111 ocp_write_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY1, ocp_data);
7113 r8153_queue_wake(tp, false);
7115 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS);
7116 if (rtl8152_get_speed(tp) & LINK_STATUS)
7121 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS, ocp_data);
7124 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY2);
7126 ocp_write_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY2, ocp_data);
7128 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_WDT11_CTRL);
7130 ocp_write_word(tp, MCU_TYPE_USB, USB_WDT11_CTRL, ocp_data);
7132 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE);
7134 ocp_write_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE, ocp_data);
7137 if (tp->version == RTL_VER_04 && tp->udev->speed < USB_SPEED_SUPER)
7141 ocp_write_byte(tp, MCU_TYPE_USB, USB_LPM_CTRL, ocp_data);
7143 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_AFE_CTRL2);
7146 ocp_write_word(tp, MCU_TYPE_USB, USB_AFE_CTRL2, ocp_data);
7148 ocp_write_word(tp, MCU_TYPE_USB, USB_CONNECT_TIMER, 0x0001);
7150 r8153_power_cut_en(tp, false);
7151 rtl_runtime_suspend_enable(tp, false);
7152 r8153_mac_clk_speed_down(tp, false);
7153 r8153_u1u2en(tp, true);
7154 usb_enable_lpm(tp->udev);
7156 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CONFIG6);
7158 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CONFIG6, ocp_data);
7160 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_LWAKE_CTRL_REG);
7162 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_LWAKE_CTRL_REG, ocp_data);
7165 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
7167 if (tp->dell_tb_rx_agg_bug)
7170 ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
7172 rtl_tally_reset(tp);
7174 switch (tp->udev->speed) {
7177 tp->coalesce = COALESCE_SUPER;
7180 tp->coalesce = COALESCE_HIGH;
7183 tp->coalesce = COALESCE_SLOW;
7188 static void r8153b_init(struct r8152 *tp)
7194 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
7197 r8153b_u1u2en(tp, false);
7200 if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) &
7205 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
7209 data = r8153_phy_status(tp, 0);
7211 data = r8152_mdio_read(tp, MII_BMCR);
7214 r8152_mdio_write(tp, MII_BMCR, data);
7217 data = r8153_phy_status(tp, PHY_STAT_LAN_ON);
7219 r8153_u2p3en(tp, false);
7222 ocp_write_word(tp, MCU_TYPE_USB, USB_MSC_TIMER, 0x0fff);
7224 r8153b_power_cut_en(tp, false);
7225 r8153b_ups_en(tp, false);
7226 r8153_queue_wake(tp, false);
7227 rtl_runtime_suspend_enable(tp, false);
7229 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS);
7230 if (rtl8152_get_speed(tp) & LINK_STATUS)
7235 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS, ocp_data);
7237 if (tp->udev->speed >= USB_SPEED_SUPER)
7238 r8153b_u1u2en(tp, true);
7240 usb_enable_lpm(tp->udev);
7243 r8153_mac_clk_speed_down(tp, true);
7245 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3);
7247 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3, ocp_data);
7249 if (tp->version == RTL_VER_09) {
7251 if (ocp_read_byte(tp, MCU_TYPE_PLA, 0xdc00) & BIT(5)) {
7252 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
7254 ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
7258 set_bit(GREEN_ETHERNET, &tp->flags);
7261 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
7263 ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
7265 rtl_tally_reset(tp);
7267 tp->coalesce = 15000; /* 15 us */
7270 static void r8153c_init(struct r8152 *tp)
7276 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
7279 r8153b_u1u2en(tp, false);
7282 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
7283 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG5);
7285 ocp_write_word(tp, MCU_TYPE_PLA, PLA_CONFIG5, ocp_data);
7286 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, 0xcbf0);
7288 ocp_write_word(tp, MCU_TYPE_USB, 0xcbf0, ocp_data);
7291 if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) &
7296 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
7300 data = r8153_phy_status(tp, 0);
7302 data = r8152_mdio_read(tp, MII_BMCR);
7305 r8152_mdio_write(tp, MII_BMCR, data);
7308 data = r8153_phy_status(tp, PHY_STAT_LAN_ON);
7310 r8153_u2p3en(tp, false);
7313 ocp_write_word(tp, MCU_TYPE_USB, USB_MSC_TIMER, 0x0fff);
7315 r8153b_power_cut_en(tp, false);
7316 r8153c_ups_en(tp, false);
7317 r8153_queue_wake(tp, false);
7318 rtl_runtime_suspend_enable(tp, false);
7320 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS);
7321 if (rtl8152_get_speed(tp) & LINK_STATUS)
7327 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS, ocp_data);
7329 r8153b_u1u2en(tp, true);
7331 usb_enable_lpm(tp->udev);
7334 r8153_mac_clk_speed_down(tp, true);
7336 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_MISC_2);
7338 ocp_write_byte(tp, MCU_TYPE_USB, USB_MISC_2, ocp_data);
7340 set_bit(GREEN_ETHERNET, &tp->flags);
7343 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
7345 ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
7347 rtl_tally_reset(tp);
7349 tp->coalesce = 15000; /* 15 us */
7352 static void r8156_hw_phy_cfg(struct r8152 *tp)
7357 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0);
7360 ocp_write_word(tp, MCU_TYPE_USB, USB_MISC_0, ocp_data);
7363 data = r8153_phy_status(tp, 0);
7366 rtl8152_apply_firmware(tp, true);
7368 data = ocp_reg_read(tp, 0xa468);
7370 ocp_reg_write(tp, 0xa468, data);
7375 rtl8152_apply_firmware(tp, false);
7380 r8153_aldps_en(tp, false);
7383 rtl_eee_enable(tp, false);
7385 data = r8153_phy_status(tp, PHY_STAT_LAN_ON);
7388 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
7390 ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
7392 switch (tp->version) {
7394 data = ocp_reg_read(tp, 0xad40);
7397 ocp_reg_write(tp, 0xad40, data);
7399 data = ocp_reg_read(tp, 0xad4e);
7401 ocp_reg_write(tp, 0xad4e, data);
7402 data = ocp_reg_read(tp, 0xad16);
7405 ocp_reg_write(tp, 0xad16, data);
7406 data = ocp_reg_read(tp, 0xad32);
7409 ocp_reg_write(tp, 0xad32, data);
7410 data = ocp_reg_read(tp, 0xac08);
7412 ocp_reg_write(tp, 0xac08, data);
7413 data = ocp_reg_read(tp, 0xac8a);
7416 ocp_reg_write(tp, 0xac8a, data);
7417 data = ocp_reg_read(tp, 0xad18);
7419 ocp_reg_write(tp, 0xad18, data);
7420 data = ocp_reg_read(tp, 0xad1a);
7422 ocp_reg_write(tp, 0xad1a, data);
7423 data = ocp_reg_read(tp, 0xad1c);
7425 ocp_reg_write(tp, 0xad1c, data);
7427 data = sram_read(tp, 0x80ea);
7430 sram_write(tp, 0x80ea, data);
7431 data = sram_read(tp, 0x80eb);
7434 sram_write(tp, 0x80eb, data);
7435 data = sram_read(tp, 0x80f8);
7438 sram_write(tp, 0x80f8, data);
7439 data = sram_read(tp, 0x80f1);
7442 sram_write(tp, 0x80f1, data);
7444 data = sram_read(tp, 0x80fe);
7447 sram_write(tp, 0x80fe, data);
7448 data = sram_read(tp, 0x8102);
7451 sram_write(tp, 0x8102, data);
7452 data = sram_read(tp, 0x8015);
7455 sram_write(tp, 0x8015, data);
7456 data = sram_read(tp, 0x8100);
7459 sram_write(tp, 0x8100, data);
7460 data = sram_read(tp, 0x8014);
7463 sram_write(tp, 0x8014, data);
7464 data = sram_read(tp, 0x8016);
7467 sram_write(tp, 0x8016, data);
7468 data = sram_read(tp, 0x80dc);
7471 sram_write(tp, 0x80dc, data);
7472 data = sram_read(tp, 0x80df);
7474 sram_write(tp, 0x80df, data);
7475 data = sram_read(tp, 0x80e1);
7477 sram_write(tp, 0x80e1, data);
7479 data = ocp_reg_read(tp, 0xbf06);
7482 ocp_reg_write(tp, 0xbf06, data);
7484 sram_write(tp, 0x819f, 0xddb6);
7486 ocp_reg_write(tp, 0xbc34, 0x5555);
7487 data = ocp_reg_read(tp, 0xbf0a);
7490 ocp_reg_write(tp, 0xbf0a, data);
7492 data = ocp_reg_read(tp, 0xbd2c);
7494 ocp_reg_write(tp, 0xbd2c, data);
7497 data = ocp_reg_read(tp, 0xad16);
7499 ocp_reg_write(tp, 0xad16, data);
7500 data = ocp_reg_read(tp, 0xad32);
7503 ocp_reg_write(tp, 0xad32, data);
7504 data = ocp_reg_read(tp, 0xac08);
7506 ocp_reg_write(tp, 0xac08, data);
7507 data = ocp_reg_read(tp, 0xacc0);
7510 ocp_reg_write(tp, 0xacc0, data);
7511 data = ocp_reg_read(tp, 0xad40);
7514 ocp_reg_write(tp, 0xad40, data);
7515 data = ocp_reg_read(tp, 0xac14);
7517 ocp_reg_write(tp, 0xac14, data);
7518 data = ocp_reg_read(tp, 0xac80);
7520 ocp_reg_write(tp, 0xac80, data);
7521 data = ocp_reg_read(tp, 0xac5e);
7524 ocp_reg_write(tp, 0xac5e, data);
7525 ocp_reg_write(tp, 0xad4c, 0x00a8);
7526 ocp_reg_write(tp, 0xac5c, 0x01ff);
7527 data = ocp_reg_read(tp, 0xac8a);
7530 ocp_reg_write(tp, 0xac8a, data);
7531 ocp_reg_write(tp, 0xb87c, 0x8157);
7532 data = ocp_reg_read(tp, 0xb87e);
7535 ocp_reg_write(tp, 0xb87e, data);
7536 ocp_reg_write(tp, 0xb87c, 0x8159);
7537 data = ocp_reg_read(tp, 0xb87e);
7540 ocp_reg_write(tp, 0xb87e, data);
7543 ocp_reg_write(tp, 0xb87c, 0x80a2);
7544 ocp_reg_write(tp, 0xb87e, 0x0153);
7545 ocp_reg_write(tp, 0xb87c, 0x809c);
7546 ocp_reg_write(tp, 0xb87e, 0x0153);
7549 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEE_TXTWSYS_2P5G, 0x0056);
7551 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_USB_CFG);
7553 ocp_write_word(tp, MCU_TYPE_PLA, PLA_USB_CFG, ocp_data);
7555 sram_write(tp, 0x8257, 0x020f); /* XG PLL */
7556 sram_write(tp, 0x80ea, 0x7843); /* GIGA Master */
7558 if (rtl_phy_patch_request(tp, true, true))
7562 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4);
7564 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4, ocp_data);
7566 data = ocp_reg_read(tp, OCP_DOWN_SPEED);
7569 ocp_reg_write(tp, OCP_DOWN_SPEED, data);
7570 tp->ups_info._10m_ckdiv = true;
7571 tp->ups_info.eee_plloff_100 = false;
7572 tp->ups_info.eee_plloff_giga = false;
7574 data = ocp_reg_read(tp, OCP_POWER_CFG);
7576 ocp_reg_write(tp, OCP_POWER_CFG, data);
7577 tp->ups_info.eee_ckdiv = false;
7579 ocp_reg_write(tp, OCP_SYSCLK_CFG, 0);
7580 ocp_reg_write(tp, OCP_SYSCLK_CFG, sysclk_div_expo(5));
7581 tp->ups_info._250m_ckdiv = false;
7583 rtl_phy_patch_request(tp, false, true);
7586 data = ocp_reg_read(tp, 0xd068);
7588 ocp_reg_write(tp, 0xd068, data);
7591 data = sram_read(tp, 0x81a2);
7593 sram_write(tp, 0x81a2, data);
7594 data = ocp_reg_read(tp, 0xb54c);
7597 ocp_reg_write(tp, 0xb54c, data);
7600 data = ocp_reg_read(tp, 0xa454);
7602 ocp_reg_write(tp, 0xa454, data);
7605 data = ocp_reg_read(tp, OCP_10GBT_CTRL);
7607 ocp_reg_write(tp, OCP_10GBT_CTRL, data);
7608 data = ocp_reg_read(tp, 0xad4e);
7610 ocp_reg_write(tp, 0xad4e, data);
7611 data = ocp_reg_read(tp, 0xa86a);
7613 ocp_reg_write(tp, 0xa86a, data);
7616 if ((ocp_read_word(tp, MCU_TYPE_USB, USB_UPS_CFG) & MID_REVERSE) &&
7617 (ocp_reg_read(tp, 0xd068) & BIT(1))) {
7620 data = ocp_reg_read(tp, 0xd068);
7623 ocp_reg_write(tp, 0xd068, data);
7624 swap_a = ocp_reg_read(tp, 0xd06a);
7627 ocp_reg_write(tp, 0xd068, data);
7628 swap_b = ocp_reg_read(tp, 0xd06a);
7630 ocp_reg_write(tp, 0xd068, data);
7631 ocp_reg_write(tp, 0xd06a,
7634 ocp_reg_write(tp, 0xd068, data);
7635 ocp_reg_write(tp, 0xd06a,
7639 ocp_reg_write(tp, 0xd068, data);
7640 swap_a = ocp_reg_read(tp, 0xd06a);
7643 ocp_reg_write(tp, 0xd068, data);
7644 swap_b = ocp_reg_read(tp, 0xd06a);
7647 ocp_reg_write(tp, 0xd068, data);
7648 ocp_reg_write(tp, 0xd06a,
7652 ocp_reg_write(tp, 0xd068, data);
7653 ocp_reg_write(tp, 0xd06a,
7655 swap_a = ocp_reg_read(tp, 0xbd5a);
7656 swap_b = ocp_reg_read(tp, 0xbd5c);
7657 ocp_reg_write(tp, 0xbd5a, (swap_a & ~0x1f1f) |
7660 ocp_reg_write(tp, 0xbd5c, (swap_b & ~0x1f1f) |
7663 swap_a = ocp_reg_read(tp, 0xbc18);
7664 swap_b = ocp_reg_read(tp, 0xbc1a);
7665 ocp_reg_write(tp, 0xbc18, (swap_a & ~0x1f1f) |
7668 ocp_reg_write(tp, 0xbc1a, (swap_b & ~0x1f1f) |
7674 data = ocp_reg_read(tp, OCP_INTR_EN);
7676 ocp_reg_write(tp, OCP_INTR_EN, data);
7682 rtl_green_en(tp, test_bit(GREEN_ETHERNET, &tp->flags));
7684 data = ocp_reg_read(tp, 0xa428);
7686 ocp_reg_write(tp, 0xa428, data);
7687 data = ocp_reg_read(tp, 0xa5ea);
7689 ocp_reg_write(tp, 0xa5ea, data);
7690 tp->ups_info.lite_mode = 0;
7692 if (tp->eee_en)
7693 rtl_eee_enable(tp, true);
7695 r8153_aldps_en(tp, true);
7696 r8152b_enable_fc(tp);
7697 r8153_u2p3en(tp, true);
7699 set_bit(PHY_RESET, &tp->flags);
7702 static void r8156b_hw_phy_cfg(struct r8152 *tp)
7707 switch (tp->version) {
7709 ocp_reg_write(tp, 0xbf86, 0x9000);
7710 data = ocp_reg_read(tp, 0xc402);
7712 ocp_reg_write(tp, 0xc402, data);
7714 ocp_reg_write(tp, 0xc402, data);
7715 ocp_reg_write(tp, 0xbd86, 0x1010);
7716 ocp_reg_write(tp, 0xbd88, 0x1010);
7717 data = ocp_reg_read(tp, 0xbd4e);
7720 ocp_reg_write(tp, 0xbd4e, data);
7721 data = ocp_reg_read(tp, 0xbf46);
7724 ocp_reg_write(tp, 0xbf46, data);
7728 r8156b_wait_loading_flash(tp);
7734 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0);
7737 ocp_write_word(tp, MCU_TYPE_USB, USB_MISC_0, ocp_data);
7740 data = r8153_phy_status(tp, 0);
7743 rtl8152_apply_firmware(tp, true);
7745 data = ocp_reg_read(tp, 0xa466);
7747 ocp_reg_write(tp, 0xa466, data);
7749 data = ocp_reg_read(tp, 0xa468);
7751 ocp_reg_write(tp, 0xa468, data);
7756 rtl8152_apply_firmware(tp, false);
7760 data = r8152_mdio_read(tp, MII_BMCR);
7763 r8152_mdio_write(tp, MII_BMCR, data);
7767 r8153_aldps_en(tp, false);
7770 rtl_eee_enable(tp, false);
7772 data = r8153_phy_status(tp, PHY_STAT_LAN_ON);
7775 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
7777 ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
7779 switch (tp->version) {
7781 data = ocp_reg_read(tp, 0xbc08);
7783 ocp_reg_write(tp, 0xbc08, data);
7785 data = sram_read(tp, 0x8fff);
7788 sram_write(tp, 0x8fff, data);
7790 data = ocp_reg_read(tp, 0xacda);
7792 ocp_reg_write(tp, 0xacda, data);
7793 data = ocp_reg_read(tp, 0xacde);
7795 ocp_reg_write(tp, 0xacde, data);
7796 ocp_reg_write(tp, 0xac8c, 0x0ffc);
7797 ocp_reg_write(tp, 0xac46, 0xb7b4);
7798 ocp_reg_write(tp, 0xac50, 0x0fbc);
7799 ocp_reg_write(tp, 0xac3c, 0x9240);
7800 ocp_reg_write(tp, 0xac4e, 0x0db4);
7801 ocp_reg_write(tp, 0xacc6, 0x0707);
7802 ocp_reg_write(tp, 0xacc8, 0xa0d3);
7803 ocp_reg_write(tp, 0xad08, 0x0007);
7805 ocp_reg_write(tp, 0xb87c, 0x8560);
7806 ocp_reg_write(tp, 0xb87e, 0x19cc);
7807 ocp_reg_write(tp, 0xb87c, 0x8562);
7808 ocp_reg_write(tp, 0xb87e, 0x19cc);
7809 ocp_reg_write(tp, 0xb87c, 0x8564);
7810 ocp_reg_write(tp, 0xb87e, 0x19cc);
7811 ocp_reg_write(tp, 0xb87c, 0x8566);
7812 ocp_reg_write(tp, 0xb87e, 0x147d);
7813 ocp_reg_write(tp, 0xb87c, 0x8568);
7814 ocp_reg_write(tp, 0xb87e, 0x147d);
7815 ocp_reg_write(tp, 0xb87c, 0x856a);
7816 ocp_reg_write(tp, 0xb87e, 0x147d);
7817 ocp_reg_write(tp, 0xb87c, 0x8ffe);
7818 ocp_reg_write(tp, 0xb87e, 0x0907);
7819 ocp_reg_write(tp, 0xb87c, 0x80d6);
7820 ocp_reg_write(tp, 0xb87e, 0x2801);
7821 ocp_reg_write(tp, 0xb87c, 0x80f2);
7822 ocp_reg_write(tp, 0xb87e, 0x2801);
7823 ocp_reg_write(tp, 0xb87c, 0x80f4);
7824 ocp_reg_write(tp, 0xb87e, 0x6077);
7825 ocp_reg_write(tp, 0xb506, 0x01e7);
7827 ocp_reg_write(tp, 0xb87c, 0x8013);
7828 ocp_reg_write(tp, 0xb87e, 0x0700);
7829 ocp_reg_write(tp, 0xb87c, 0x8fb9);
7830 ocp_reg_write(tp, 0xb87e, 0x2801);
7831 ocp_reg_write(tp, 0xb87c, 0x8fba);
7832 ocp_reg_write(tp, 0xb87e, 0x0100);
7833 ocp_reg_write(tp, 0xb87c, 0x8fbc);
7834 ocp_reg_write(tp, 0xb87e, 0x1900);
7835 ocp_reg_write(tp, 0xb87c, 0x8fbe);
7836 ocp_reg_write(tp, 0xb87e, 0xe100);
7837 ocp_reg_write(tp, 0xb87c, 0x8fc0);
7838 ocp_reg_write(tp, 0xb87e, 0x0800);
7839 ocp_reg_write(tp, 0xb87c, 0x8fc2);
7840 ocp_reg_write(tp, 0xb87e, 0xe500);
7841 ocp_reg_write(tp, 0xb87c, 0x8fc4);
7842 ocp_reg_write(tp, 0xb87e, 0x0f00);
7843 ocp_reg_write(tp, 0xb87c, 0x8fc6);
7844 ocp_reg_write(tp, 0xb87e, 0xf100);
7845 ocp_reg_write(tp, 0xb87c, 0x8fc8);
7846 ocp_reg_write(tp, 0xb87e, 0x0400);
7847 ocp_reg_write(tp, 0xb87c, 0x8fca);
7848 ocp_reg_write(tp, 0xb87e, 0xf300);
7849 ocp_reg_write(tp, 0xb87c, 0x8fcc);
7850 ocp_reg_write(tp, 0xb87e, 0xfd00);
7851 ocp_reg_write(tp, 0xb87c, 0x8fce);
7852 ocp_reg_write(tp, 0xb87e, 0xff00);
7853 ocp_reg_write(tp, 0xb87c, 0x8fd0);
7854 ocp_reg_write(tp, 0xb87e, 0xfb00);
7855 ocp_reg_write(tp, 0xb87c, 0x8fd2);
7856 ocp_reg_write(tp, 0xb87e, 0x0100);
7857 ocp_reg_write(tp, 0xb87c, 0x8fd4);
7858 ocp_reg_write(tp, 0xb87e, 0xf400);
7859 ocp_reg_write(tp, 0xb87c, 0x8fd6);
7860 ocp_reg_write(tp, 0xb87e, 0xff00);
7861 ocp_reg_write(tp, 0xb87c, 0x8fd8);
7862 ocp_reg_write(tp, 0xb87e, 0xf600);
7864 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_USB_CFG);
7866 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_USB_CFG, ocp_data);
7867 ocp_reg_write(tp, 0xb87c, 0x813d);
7868 ocp_reg_write(tp, 0xb87e, 0x390e);
7869 ocp_reg_write(tp, 0xb87c, 0x814f);
7870 ocp_reg_write(tp, 0xb87e, 0x790e);
7871 ocp_reg_write(tp, 0xb87c, 0x80b0);
7872 ocp_reg_write(tp, 0xb87e, 0x0f31);
7873 data = ocp_reg_read(tp, 0xbf4c);
7875 ocp_reg_write(tp, 0xbf4c, data);
7876 data = ocp_reg_read(tp, 0xbcca);
7878 ocp_reg_write(tp, 0xbcca, data);
7879 ocp_reg_write(tp, 0xb87c, 0x8141);
7880 ocp_reg_write(tp, 0xb87e, 0x320e);
7881 ocp_reg_write(tp, 0xb87c, 0x8153);
7882 ocp_reg_write(tp, 0xb87e, 0x720e);
7883 ocp_reg_write(tp, 0xb87c, 0x8529);
7884 ocp_reg_write(tp, 0xb87e, 0x050e);
7885 data = ocp_reg_read(tp, OCP_EEE_CFG);
7887 ocp_reg_write(tp, OCP_EEE_CFG, data);
7889 sram_write(tp, 0x816c, 0xc4a0);
7890 sram_write(tp, 0x8170, 0xc4a0);
7891 sram_write(tp, 0x8174, 0x04a0);
7892 sram_write(tp, 0x8178, 0x04a0);
7893 sram_write(tp, 0x817c, 0x0719);
7894 sram_write(tp, 0x8ff4, 0x0400);
7895 sram_write(tp, 0x8ff1, 0x0404);
7897 ocp_reg_write(tp, 0xbf4a, 0x001b);
7898 ocp_reg_write(tp, 0xb87c, 0x8033);
7899 ocp_reg_write(tp, 0xb87e, 0x7c13);
7900 ocp_reg_write(tp, 0xb87c, 0x8037);
7901 ocp_reg_write(tp, 0xb87e, 0x7c13);
7902 ocp_reg_write(tp, 0xb87c, 0x803b);
7903 ocp_reg_write(tp, 0xb87e, 0xfc32);
7904 ocp_reg_write(tp, 0xb87c, 0x803f);
7905 ocp_reg_write(tp, 0xb87e, 0x7c13);
7906 ocp_reg_write(tp, 0xb87c, 0x8043);
7907 ocp_reg_write(tp, 0xb87e, 0x7c13);
7908 ocp_reg_write(tp, 0xb87c, 0x8047);
7909 ocp_reg_write(tp, 0xb87e, 0x7c13);
7911 ocp_reg_write(tp, 0xb87c, 0x8145);
7912 ocp_reg_write(tp, 0xb87e, 0x370e);
7913 ocp_reg_write(tp, 0xb87c, 0x8157);
7914 ocp_reg_write(tp, 0xb87e, 0x770e);
7915 ocp_reg_write(tp, 0xb87c, 0x8169);
7916 ocp_reg_write(tp, 0xb87e, 0x0d0a);
7917 ocp_reg_write(tp, 0xb87c, 0x817b);
7918 ocp_reg_write(tp, 0xb87e, 0x1d0a);
7920 data = sram_read(tp, 0x8217);
7923 sram_write(tp, 0x8217, data);
7924 data = sram_read(tp, 0x821a);
7927 sram_write(tp, 0x821a, data);
7928 sram_write(tp, 0x80da, 0x0403);
7929 data = sram_read(tp, 0x80dc);
7932 sram_write(tp, 0x80dc, data);
7933 sram_write(tp, 0x80b3, 0x0384);
7934 sram_write(tp, 0x80b7, 0x2007);
7935 data = sram_read(tp, 0x80ba);
7938 sram_write(tp, 0x80ba, data);
7939 sram_write(tp, 0x80b5, 0xf009);
7940 data = sram_read(tp, 0x80bd);
7943 sram_write(tp, 0x80bd, data);
7944 sram_write(tp, 0x80c7, 0xf083);
7945 sram_write(tp, 0x80dd, 0x03f0);
7946 data = sram_read(tp, 0x80df);
7949 sram_write(tp, 0x80df, data);
7950 sram_write(tp, 0x80cb, 0x2007);
7951 data = sram_read(tp, 0x80ce);
7954 sram_write(tp, 0x80ce, data);
7955 sram_write(tp, 0x80c9, 0x8009);
7956 data = sram_read(tp, 0x80d1);
7959 sram_write(tp, 0x80d1, data);
7960 sram_write(tp, 0x80a3, 0x200a);
7961 sram_write(tp, 0x80a5, 0xf0ad);
7962 sram_write(tp, 0x809f, 0x6073);
7963 sram_write(tp, 0x80a1, 0x000b);
7964 data = sram_read(tp, 0x80a9);
7967 sram_write(tp, 0x80a9, data);
7969 if (rtl_phy_patch_request(tp, true, true))
7972 data = ocp_reg_read(tp, 0xb896);
7974 ocp_reg_write(tp, 0xb896, data);
7975 data = ocp_reg_read(tp, 0xb892);
7977 ocp_reg_write(tp, 0xb892, data);
7978 ocp_reg_write(tp, 0xb88e, 0xc23e);
7979 ocp_reg_write(tp, 0xb890, 0x0000);
7980 ocp_reg_write(tp, 0xb88e, 0xc240);
7981 ocp_reg_write(tp, 0xb890, 0x0103);
7982 ocp_reg_write(tp, 0xb88e, 0xc242);
7983 ocp_reg_write(tp, 0xb890, 0x0507);
7984 ocp_reg_write(tp, 0xb88e, 0xc244);
7985 ocp_reg_write(tp, 0xb890, 0x090b);
7986 ocp_reg_write(tp, 0xb88e, 0xc246);
7987 ocp_reg_write(tp, 0xb890, 0x0c0e);
7988 ocp_reg_write(tp, 0xb88e, 0xc248);
7989 ocp_reg_write(tp, 0xb890, 0x1012);
7990 ocp_reg_write(tp, 0xb88e, 0xc24a);
7991 ocp_reg_write(tp, 0xb890, 0x1416);
7992 data = ocp_reg_read(tp, 0xb896);
7994 ocp_reg_write(tp, 0xb896, data);
7996 rtl_phy_patch_request(tp, false, true);
7998 data = ocp_reg_read(tp, 0xa86a);
8000 ocp_reg_write(tp, 0xa86a, data);
8001 data = ocp_reg_read(tp, 0xa6f0);
8003 ocp_reg_write(tp, 0xa6f0, data);
8005 ocp_reg_write(tp, 0xbfa0, 0xd70d);
8006 ocp_reg_write(tp, 0xbfa2, 0x4100);
8007 ocp_reg_write(tp, 0xbfa4, 0xe868);
8008 ocp_reg_write(tp, 0xbfa6, 0xdc59);
8009 ocp_reg_write(tp, 0xb54c, 0x3c18);
8010 data = ocp_reg_read(tp, 0xbfa4);
8012 ocp_reg_write(tp, 0xbfa4, data);
8013 data = sram_read(tp, 0x817d);
8015 sram_write(tp, 0x817d, data);
8019 data = ocp_reg_read(tp, 0xac46);
8022 ocp_reg_write(tp, 0xac46, data);
8023 data = ocp_reg_read(tp, 0xad30);
8026 ocp_reg_write(tp, 0xad30, data);
8030 ocp_reg_write(tp, 0xb87c, 0x80f5);
8031 ocp_reg_write(tp, 0xb87e, 0x760e);
8032 ocp_reg_write(tp, 0xb87c, 0x8107);
8033 ocp_reg_write(tp, 0xb87e, 0x360e);
8034 ocp_reg_write(tp, 0xb87c, 0x8551);
8035 data = ocp_reg_read(tp, 0xb87e);
8038 ocp_reg_write(tp, 0xb87e, data);
8041 data = ocp_reg_read(tp, 0xbf00);
8044 ocp_reg_write(tp, 0xbf00, data);
8045 data = ocp_reg_read(tp, 0xbf46);
8048 ocp_reg_write(tp, 0xbf46, data);
8051 sram_write(tp, 0x8044, 0x2417);
8052 sram_write(tp, 0x804a, 0x2417);
8053 sram_write(tp, 0x8050, 0x2417);
8054 sram_write(tp, 0x8056, 0x2417);
8055 sram_write(tp, 0x805c, 0x2417);
8056 sram_write(tp, 0x8062, 0x2417);
8057 sram_write(tp, 0x8068, 0x2417);
8058 sram_write(tp, 0x806e, 0x2417);
8059 sram_write(tp, 0x8074, 0x2417);
8060 sram_write(tp, 0x807a, 0x2417);
8063 data = ocp_reg_read(tp, 0xbf84);
8066 ocp_reg_write(tp, 0xbf84, data);
8073 data = ocp_reg_read(tp, OCP_INTR_EN);
8075 ocp_reg_write(tp, OCP_INTR_EN, data);
8077 if (rtl_phy_patch_request(tp, true, true))
8080 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4);
8082 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4, ocp_data);
8084 data = ocp_reg_read(tp, OCP_DOWN_SPEED);
8087 ocp_reg_write(tp, OCP_DOWN_SPEED, data);
8088 tp->ups_info._10m_ckdiv = true;
8089 tp->ups_info.eee_plloff_100 = false;
8090 tp->ups_info.eee_plloff_giga = false;
8092 data = ocp_reg_read(tp, OCP_POWER_CFG);
8094 ocp_reg_write(tp, OCP_POWER_CFG, data);
8095 tp->ups_info.eee_ckdiv = false;
8097 rtl_phy_patch_request(tp, false, true);
8099 rtl_green_en(tp, test_bit(GREEN_ETHERNET, &tp->flags));
8101 data = ocp_reg_read(tp, 0xa428);
8103 ocp_reg_write(tp, 0xa428, data);
8104 data = ocp_reg_read(tp, 0xa5ea);
8106 ocp_reg_write(tp, 0xa5ea, data);
8107 tp->ups_info.lite_mode = 0;
8109 if (tp->eee_en)
8110 rtl_eee_enable(tp, true);
8112 r8153_aldps_en(tp, true);
8113 r8152b_enable_fc(tp);
8114 r8153_u2p3en(tp, true);
8116 set_bit(PHY_RESET, &tp->flags);
8119 static void r8156_init(struct r8152 *tp)
8125 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
8128 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_ECM_OP);
8130 ocp_write_byte(tp, MCU_TYPE_USB, USB_ECM_OP, ocp_data);
8132 ocp_write_word(tp, MCU_TYPE_USB, USB_SPEED_OPTION, 0);
8134 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_ECM_OPTION);
8136 ocp_write_word(tp, MCU_TYPE_USB, USB_ECM_OPTION, ocp_data);
8138 r8153b_u1u2en(tp, false);
8141 if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) &
8146 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
8150 data = r8153_phy_status(tp, 0);
8152 data = ocp_reg_read(tp, 0xa468);
8154 ocp_reg_write(tp, 0xa468, data);
8157 data = r8152_mdio_read(tp, MII_BMCR);
8160 r8152_mdio_write(tp, MII_BMCR, data);
8163 data = r8153_phy_status(tp, PHY_STAT_LAN_ON);
8166 r8153_u2p3en(tp, false);
8169 ocp_write_word(tp, MCU_TYPE_USB, USB_MSC_TIMER, 0x0fff);
8172 ocp_write_word(tp, MCU_TYPE_USB, USB_U1U2_TIMER, 500);
8174 r8153b_power_cut_en(tp, false);
8175 r8156_ups_en(tp, false);
8176 r8153_queue_wake(tp, false);
8177 rtl_runtime_suspend_enable(tp, false);
8179 if (tp->udev->speed >= USB_SPEED_SUPER)
8180 r8153b_u1u2en(tp, true);
8182 usb_enable_lpm(tp->udev);
8184 r8156_mac_clk_spd(tp, true);
8186 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3);
8188 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3, ocp_data);
8190 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS);
8191 if (rtl8152_get_speed(tp) & LINK_STATUS)
8196 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS, ocp_data);
8198 set_bit(GREEN_ETHERNET, &tp->flags);
8201 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
8203 ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
8205 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_BMU_CONFIG);
8207 ocp_write_byte(tp, MCU_TYPE_USB, USB_BMU_CONFIG, ocp_data);
8209 r8156_mdio_force_mode(tp);
8210 rtl_tally_reset(tp);
8212 tp->coalesce = 15000; /* 15 us */
8215 static void r8156b_init(struct r8152 *tp)
8221 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
8224 ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_ECM_OP);
8226 ocp_write_byte(tp, MCU_TYPE_USB, USB_ECM_OP, ocp_data);
8228 ocp_write_word(tp, MCU_TYPE_USB, USB_SPEED_OPTION, 0);
8230 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_ECM_OPTION);
8232 ocp_write_word(tp, MCU_TYPE_USB, USB_ECM_OPTION, ocp_data);
8234 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_U2P3_CTRL);
8236 ocp_write_word(tp, MCU_TYPE_USB, USB_U2P3_CTRL, ocp_data);
8238 r8153b_u1u2en(tp, false);
8240 switch (tp->version) {
8243 r8156b_wait_loading_flash(tp);
8250 if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) &
8255 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
8259 data = r8153_phy_status(tp, 0);
8261 data = ocp_reg_read(tp, 0xa468);
8263 ocp_reg_write(tp, 0xa468, data);
8265 data = ocp_reg_read(tp, 0xa466);
8267 ocp_reg_write(tp, 0xa466, data);
8270 data = r8152_mdio_read(tp, MII_BMCR);
8273 r8152_mdio_write(tp, MII_BMCR, data);
8276 data = r8153_phy_status(tp, PHY_STAT_LAN_ON);
8278 r8153_u2p3en(tp, false);
8281 ocp_write_word(tp, MCU_TYPE_USB, USB_MSC_TIMER, 0x0fff);
8284 ocp_write_word(tp, MCU_TYPE_USB, USB_U1U2_TIMER, 500);
8286 r8153b_power_cut_en(tp, false);
8287 r8156_ups_en(tp, false);
8288 r8153_queue_wake(tp, false);
8289 rtl_runtime_suspend_enable(tp, false);
8291 if (tp->udev->speed >= USB_SPEED_SUPER)
8292 r8153b_u1u2en(tp, true);
8294 usb_enable_lpm(tp->udev);
8296 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_RCR);
8298 ocp_write_word(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
8300 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CPCR);
8302 ocp_write_word(tp, MCU_TYPE_PLA, PLA_CPCR, ocp_data);
8305 ocp_write_word(tp, MCU_TYPE_USB, USB_FC_TIMER,
8308 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_CTRL);
8309 if (!(ocp_read_word(tp, MCU_TYPE_PLA, PLA_POL_GPIO_CTRL) & DACK_DET_EN))
8312 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_CTRL, ocp_data);
8314 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_FW_TASK);
8316 ocp_write_word(tp, MCU_TYPE_USB, USB_FW_TASK, ocp_data);
8318 r8156_mac_clk_spd(tp, true);
8320 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3);
8322 ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3, ocp_data);
8324 ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS);
8325 if (rtl8152_get_speed(tp) & LINK_STATUS)
8330 ocp_write_word(tp, MCU_TYPE_PLA, PLA_EXTRA_STATUS, ocp_data);
8332 set_bit(GREEN_ETHERNET, &tp->flags);
8335 ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
8337 ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
8339 r8156_mdio_force_mode(tp);
8340 rtl_tally_reset(tp);
8342 tp->coalesce = 15000; /* 15 us */
8378 struct r8152 *tp = usb_get_intfdata(intf);
8383 if (!tp || !test_bit(PROBED_WITH_NO_ERRORS, &tp->flags))
8386 netdev = tp->netdev;
8391 tasklet_disable(&tp->tx_tl);
8392 clear_bit(WORK_ENABLE, &tp->flags);
8393 usb_kill_urb(tp->intr_urb);
8394 cancel_delayed_work_sync(&tp->schedule);
8395 napi_disable(&tp->napi);
8397 mutex_lock(&tp->control);
8398 set_bit(IN_PRE_RESET, &tp->flags);
8399 tp->rtl_ops.disable(tp);
8400 clear_bit(IN_PRE_RESET, &tp->flags);
8401 mutex_unlock(&tp->control);
8409 struct r8152 *tp = usb_get_intfdata(intf);
8413 if (!tp || !test_bit(PROBED_WITH_NO_ERRORS, &tp->flags))
8416 rtl_set_accessible(tp);
8419 if (determine_ethernet_addr(tp, &sa) >= 0)
8420 dev_set_mac_address (tp->netdev, &sa, NULL);
8422 netdev = tp->netdev;
8426 set_bit(WORK_ENABLE, &tp->flags);
8428 mutex_lock(&tp->control);
8429 tp->rtl_ops.enable(tp);
8430 rtl_start_rx(tp);
8432 mutex_unlock(&tp->control);
8435 napi_enable(&tp->napi);
8436 tasklet_enable(&tp->tx_tl);
8438 usb_submit_urb(tp->intr_urb, GFP_KERNEL);
8440 if (!list_empty(&tp->rx_done))
8441 napi_schedule(&tp->napi);
8448 static bool delay_autosuspend(struct r8152 *tp)
8450 bool sw_linking = !!netif_carrier_ok(tp->netdev);
8451 bool hw_linking = !!(rtl8152_get_speed(tp) & LINK_STATUS);
8457 if (work_busy(&tp->schedule.work) || sw_linking != hw_linking)
8463 if (!sw_linking && tp->rtl_ops.in_nway(tp))
8465 else if (!skb_queue_empty(&tp->tx_queue))
8471 static int rtl8152_runtime_resume(struct r8152 *tp)
8473 struct net_device *netdev = tp->netdev;
8476 struct napi_struct *napi = &tp->napi;
8478 tp->rtl_ops.autosuspend_en(tp, false);
8480 set_bit(WORK_ENABLE, &tp->flags);
8483 if (rtl8152_get_speed(tp) & LINK_STATUS) {
8484 rtl_start_rx(tp);
8487 tp->rtl_ops.disable(tp);
8488 netif_info(tp, link, netdev, "linking down\n");
8493 clear_bit(SELECTIVE_SUSPEND, &tp->flags);
8496 if (!list_empty(&tp->rx_done))
8497 napi_schedule(&tp->napi);
8499 usb_submit_urb(tp->intr_urb, GFP_NOIO);
8502 tp->rtl_ops.autosuspend_en(tp, false);
8504 clear_bit(SELECTIVE_SUSPEND, &tp->flags);
8510 static int rtl8152_system_resume(struct r8152 *tp)
8512 struct net_device *netdev = tp->netdev;
8517 tp->rtl_ops.up(tp);
8519 set_bit(WORK_ENABLE, &tp->flags);
8520 usb_submit_urb(tp->intr_urb, GFP_NOIO);
8526 static int rtl8152_runtime_suspend(struct r8152 *tp)
8528 struct net_device *netdev = tp->netdev;
8531 if (!tp->rtl_ops.autosuspend_en)
8534 set_bit(SELECTIVE_SUSPEND, &tp->flags);
8537 if (netif_running(netdev) && test_bit(WORK_ENABLE, &tp->flags)) {
8543 rcr = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
8545 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
8546 rxdy_gated_en(tp, true);
8547 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA,
8550 rxdy_gated_en(tp, false);
8551 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, rcr);
8552 clear_bit(SELECTIVE_SUSPEND, &tp->flags);
8559 clear_bit(WORK_ENABLE, &tp->flags);
8560 usb_kill_urb(tp->intr_urb);
8562 tp->rtl_ops.autosuspend_en(tp, true);
8565 struct napi_struct *napi = &tp->napi;
8568 rtl_stop_rx(tp);
8569 rxdy_gated_en(tp, false);
8570 ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, rcr);
8574 if (delay_autosuspend(tp)) {
8575 rtl8152_runtime_resume(tp);
8584 static int rtl8152_system_suspend(struct r8152 *tp)
8586 struct net_device *netdev = tp->netdev;
8590 if (netif_running(netdev) && test_bit(WORK_ENABLE, &tp->flags)) {
8591 struct napi_struct *napi = &tp->napi;
8593 clear_bit(WORK_ENABLE, &tp->flags);
8594 usb_kill_urb(tp->intr_urb);
8595 tasklet_disable(&tp->tx_tl);
8597 cancel_delayed_work_sync(&tp->schedule);
8598 tp->rtl_ops.down(tp);
8600 tasklet_enable(&tp->tx_tl);
8608 struct r8152 *tp = usb_get_intfdata(intf);
8611 mutex_lock(&tp->control);
8614 ret = rtl8152_runtime_suspend(tp);
8616 ret = rtl8152_system_suspend(tp);
8618 mutex_unlock(&tp->control);
8625 struct r8152 *tp = usb_get_intfdata(intf);
8628 mutex_lock(&tp->control);
8630 rtl_reset_ocp_base(tp);
8632 if (test_bit(SELECTIVE_SUSPEND, &tp->flags))
8633 ret = rtl8152_runtime_resume(tp);
8635 ret = rtl8152_system_resume(tp);
8637 mutex_unlock(&tp->control);
8644 struct r8152 *tp = usb_get_intfdata(intf);
8646 clear_bit(SELECTIVE_SUSPEND, &tp->flags);
8647 rtl_reset_ocp_base(tp);
8648 tp->rtl_ops.init(tp);
8649 queue_delayed_work(system_long_wq, &tp->hw_phy_work, 0);
8650 set_ethernet_addr(tp, true);
8656 struct r8152 *tp = netdev_priv(dev);
8658 if (usb_autopm_get_interface(tp->intf) < 0)
8661 if (!rtl_can_wakeup(tp)) {
8665 mutex_lock(&tp->control);
8667 wol->wolopts = __rtl_get_wol(tp);
8668 mutex_unlock(&tp->control);
8671 usb_autopm_put_interface(tp->intf);
8676 struct r8152 *tp = netdev_priv(dev);
8679 if (!rtl_can_wakeup(tp))
8685 ret = usb_autopm_get_interface(tp->intf);
8689 mutex_lock(&tp->control);
8691 __rtl_set_wol(tp, wol->wolopts);
8692 tp->saved_wolopts = wol->wolopts & WAKE_ANY;
8694 mutex_unlock(&tp->control);
8696 usb_autopm_put_interface(tp->intf);
8704 struct r8152 *tp = netdev_priv(dev);
8706 return tp->msg_enable;
8711 struct r8152 *tp = netdev_priv(dev);
8713 tp->msg_enable = value;
8719 struct r8152 *tp = netdev_priv(netdev);
8723 usb_make_path(tp->udev, info->bus_info, sizeof(info->bus_info));
8724 if (!IS_ERR_OR_NULL(tp->rtl_fw.fw))
8725 strscpy(info->fw_version, tp->rtl_fw.version,
8733 struct r8152 *tp = netdev_priv(netdev);
8736 if (!tp->mii.mdio_read)
8739 ret = usb_autopm_get_interface(tp->intf);
8743 mutex_lock(&tp->control);
8745 mii_ethtool_get_link_ksettings(&tp->mii, cmd);
8748 cmd->link_modes.supported, tp->support_2500full);
8750 if (tp->support_2500full) {
8753 ocp_reg_read(tp, OCP_10GBT_CTRL) & MDIO_AN_10GBT_CTRL_ADV2_5G);
8757 ocp_reg_read(tp, OCP_10GBT_STAT) & MDIO_AN_10GBT_STAT_LP2_5G);
8759 if (is_speed_2500(rtl8152_get_speed(tp)))
8763 mutex_unlock(&tp->control);
8765 usb_autopm_put_interface(tp->intf);
8774 struct r8152 *tp = netdev_priv(dev);
8778 ret = usb_autopm_get_interface(tp->intf);
8810 mutex_lock(&tp->control);
8812 ret = rtl8152_set_speed(tp, cmd->base.autoneg, cmd->base.speed,
8815 tp->autoneg = cmd->base.autoneg;
8816 tp->speed = cmd->base.speed;
8817 tp->duplex = cmd->base.duplex;
8818 tp->advertising = advertising;
8821 mutex_unlock(&tp->control);
8823 usb_autopm_put_interface(tp->intf);
8858 struct r8152 *tp = netdev_priv(dev);
8861 if (usb_autopm_get_interface(tp->intf) < 0)
8864 generic_ocp_read(tp, PLA_TALLYCNT, sizeof(tally), &tally, MCU_TYPE_PLA);
8866 usb_autopm_put_interface(tp->intf);
8892 static int r8152_get_eee(struct r8152 *tp, struct ethtool_eee *eee)
8897 val = r8152_mmd_read(tp, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
8900 val = r8152_mmd_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
8903 val = r8152_mmd_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
8906 eee->eee_enabled = tp->eee_en;
8909 eee->advertised = tp->eee_adv;
8915 static int r8152_set_eee(struct r8152 *tp, struct ethtool_eee *eee)
8919 tp->eee_en = eee->eee_enabled;
8920 tp->eee_adv = val;
8922 rtl_eee_enable(tp, tp->eee_en);
8927 static int r8153_get_eee(struct r8152 *tp, struct ethtool_eee *eee)
8932 val = ocp_reg_read(tp, OCP_EEE_ABLE);
8935 val = ocp_reg_read(tp, OCP_EEE_ADV);
8938 val = ocp_reg_read(tp, OCP_EEE_LPABLE);
8941 eee->eee_enabled = tp->eee_en;
8944 eee->advertised = tp->eee_adv;
8953 struct r8152 *tp = netdev_priv(net);
8956 if (!tp->rtl_ops.eee_get) {
8961 ret = usb_autopm_get_interface(tp->intf);
8965 mutex_lock(&tp->control);
8967 ret = tp->rtl_ops.eee_get(tp, edata);
8969 mutex_unlock(&tp->control);
8971 usb_autopm_put_interface(tp->intf);
8980 struct r8152 *tp = netdev_priv(net);
8983 if (!tp->rtl_ops.eee_set) {
8988 ret = usb_autopm_get_interface(tp->intf);
8992 mutex_lock(&tp->control);
8994 ret = tp->rtl_ops.eee_set(tp, edata);
8996 ret = mii_nway_restart(&tp->mii);
8998 mutex_unlock(&tp->control);
9000 usb_autopm_put_interface(tp->intf);
9008 struct r8152 *tp = netdev_priv(dev);
9011 ret = usb_autopm_get_interface(tp->intf);
9015 mutex_lock(&tp->control);
9017 ret = mii_nway_restart(&tp->mii);
9019 mutex_unlock(&tp->control);
9021 usb_autopm_put_interface(tp->intf);
9032 struct r8152 *tp = netdev_priv(netdev);
9034 switch (tp->version) {
9043 coalesce->rx_coalesce_usecs = tp->coalesce;
9053 struct r8152 *tp = netdev_priv(netdev);
9056 switch (tp->version) {
9068 ret = usb_autopm_get_interface(tp->intf);
9072 mutex_lock(&tp->control);
9074 if (tp->coalesce != coalesce->rx_coalesce_usecs) {
9075 tp->coalesce = coalesce->rx_coalesce_usecs;
9079 napi_disable(&tp->napi);
9080 tp->rtl_ops.disable(tp);
9081 tp->rtl_ops.enable(tp);
9082 rtl_start_rx(tp);
9083 clear_bit(RTL8152_SET_RX_MODE, &tp->flags);
9085 napi_enable(&tp->napi);
9090 mutex_unlock(&tp->control);
9092 usb_autopm_put_interface(tp->intf);
9100 struct r8152 *tp = netdev_priv(netdev);
9104 *(u32 *)d = tp->rx_copybreak;
9117 struct r8152 *tp = netdev_priv(netdev);
9124 netif_err(tp, rx_err, netdev,
9129 if (tp->rx_copybreak != val) {
9131 mutex_lock(&tp->control);
9132 napi_disable(&tp->napi);
9133 tp->rx_copybreak = val;
9134 napi_enable(&tp->napi);
9135 mutex_unlock(&tp->control);
9137 tp->rx_copybreak = val;
9153 struct r8152 *tp = netdev_priv(netdev);
9156 ring->rx_pending = tp->rx_pending;
9164 struct r8152 *tp = netdev_priv(netdev);
9169 if (tp->rx_pending != ring->rx_pending) {
9171 mutex_lock(&tp->control);
9172 napi_disable(&tp->napi);
9173 tp->rx_pending = ring->rx_pending;
9174 napi_enable(&tp->napi);
9175 mutex_unlock(&tp->control);
9177 tp->rx_pending = ring->rx_pending;
9186 struct r8152 *tp = netdev_priv(netdev);
9190 if (usb_autopm_get_interface(tp->intf) < 0)
9193 mutex_lock(&tp->control);
9195 bmcr = r8152_mdio_read(tp, MII_BMCR);
9196 lcladv = r8152_mdio_read(tp, MII_ADVERTISE);
9197 rmtadv = r8152_mdio_read(tp, MII_LPA);
9199 mutex_unlock(&tp->control);
9201 usb_autopm_put_interface(tp->intf);
9223 struct r8152 *tp = netdev_priv(netdev);
9228 ret = usb_autopm_get_interface(tp->intf);
9232 mutex_lock(&tp->control);
9234 if (pause->autoneg && !(r8152_mdio_read(tp, MII_BMCR) & BMCR_ANENABLE)) {
9245 old = r8152_mdio_read(tp, MII_ADVERTISE);
9248 r8152_mdio_write(tp, MII_ADVERTISE, new1);
9251 mutex_unlock(&tp->control);
9252 usb_autopm_put_interface(tp->intf);
9285 struct r8152 *tp = netdev_priv(netdev);
9289 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
9292 res = usb_autopm_get_interface(tp->intf);
9302 mutex_lock(&tp->control);
9303 data->val_out = r8152_mdio_read(tp, data->reg_num);
9304 mutex_unlock(&tp->control);
9312 mutex_lock(&tp->control);
9313 r8152_mdio_write(tp, data->reg_num, data->val_in);
9314 mutex_unlock(&tp->control);
9321 usb_autopm_put_interface(tp->intf);
9329 struct r8152 *tp = netdev_priv(dev);
9332 switch (tp->version) {
9342 ret = usb_autopm_get_interface(tp->intf);
9346 mutex_lock(&tp->control);
9351 if (tp->rtl_ops.change_mtu)
9352 tp->rtl_ops.change_mtu(tp);
9356 napi_disable(&tp->napi);
9357 tasklet_disable(&tp->tx_tl);
9358 tp->rtl_ops.disable(tp);
9359 tp->rtl_ops.enable(tp);
9360 rtl_start_rx(tp);
9361 tasklet_enable(&tp->tx_tl);
9362 napi_enable(&tp->napi);
9368 mutex_unlock(&tp->control);
9370 usb_autopm_put_interface(tp->intf);
9389 static void rtl8152_unload(struct r8152 *tp)
9391 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
9394 if (tp->version != RTL_VER_01)
9395 r8152_power_cut_en(tp, true);
9398 static void rtl8153_unload(struct r8152 *tp)
9400 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
9403 r8153_power_cut_en(tp, false);
9406 static void rtl8153b_unload(struct r8152 *tp)
9408 if (test_bit(RTL8152_INACCESSIBLE, &tp->flags))
9411 r8153b_power_cut_en(tp, false);
9414 static int rtl_ops_init(struct r8152 *tp)
9416 struct rtl_ops *ops = &tp->rtl_ops;
9419 switch (tp->version) {
9434 tp->rx_buf_sz = 16 * 1024;
9435 tp->eee_en = true;
9436 tp->eee_adv = MDIO_EEE_100TX;
9455 if (tp->udev->speed < USB_SPEED_SUPER)
9456 tp->rx_buf_sz = 16 * 1024;
9458 tp->rx_buf_sz = 32 * 1024;
9459 tp->eee_en = true;
9460 tp->eee_adv = MDIO_EEE_1000T | MDIO_EEE_100TX;
9477 tp->rx_buf_sz = 32 * 1024;
9478 tp->eee_en = true;
9479 tp->eee_adv = MDIO_EEE_1000T | MDIO_EEE_100TX;
9483 tp->eee_en = true;
9484 tp->eee_adv = MDIO_EEE_1000T | MDIO_EEE_100TX;
9499 tp->rx_buf_sz = 48 * 1024;
9500 tp->support_2500full = 1;
9505 tp->support_2500full = 1;
9508 tp->eee_en = true;
9509 tp->eee_adv = MDIO_EEE_1000T | MDIO_EEE_100TX;
9522 tp->rx_buf_sz = 48 * 1024;
9538 tp->rx_buf_sz = 32 * 1024;
9539 tp->eee_en = true;
9540 tp->eee_adv = MDIO_EEE_1000T | MDIO_EEE_100TX;
9545 dev_err(&tp->intf->dev, "Unknown Device\n");
9568 static int rtl_fw_init(struct r8152 *tp)
9570 struct rtl_fw *rtl_fw = &tp->rtl_fw;
9572 switch (tp->version) {
9743 struct r8152 *tp;
9755 tp = netdev_priv(netdev);
9756 tp->msg_enable = 0x7FFF;
9758 tp->udev = udev;
9759 tp->netdev = netdev;
9760 tp->intf = intf;
9761 tp->version = version;
9763 tp->pipe_ctrl_in = usb_rcvctrlpipe(udev, 0);
9764 tp->pipe_ctrl_out = usb_sndctrlpipe(udev, 0);
9765 tp->pipe_in = usb_rcvbulkpipe(udev, 1);
9766 tp->pipe_out = usb_sndbulkpipe(udev, 2);
9767 tp->pipe_intr = usb_rcvintpipe(udev, 3);
9773 tp->mii.supports_gmii = 0;
9776 tp->mii.supports_gmii = 1;
9780 ret = rtl_ops_init(tp);
9784 rtl_fw_init(tp);
9786 mutex_init(&tp->control);
9787 INIT_DELAYED_WORK(&tp->schedule, rtl_work_func_t);
9788 INIT_DELAYED_WORK(&tp->hw_phy_work, rtl_hw_phy_work_func_t);
9789 tasklet_setup(&tp->tx_tl, bottom_half);
9790 tasklet_disable(&tp->tx_tl);
9807 if (tp->version == RTL_VER_01) {
9812 tp->lenovo_macpassthru = rtl8152_supports_lenovo_macpassthru(udev);
9818 tp->dell_tb_rx_agg_bug = 1;
9826 switch (tp->version) {
9853 tp->mii.dev = netdev;
9854 tp->mii.mdio_read = read_mii_word;
9855 tp->mii.mdio_write = write_mii_word;
9856 tp->mii.phy_id_mask = 0x3f;
9857 tp->mii.reg_num_mask = 0x1f;
9858 tp->mii.phy_id = R8152_PHY_ID;
9860 tp->autoneg = AUTONEG_ENABLE;
9861 tp->speed = SPEED_100;
9862 tp->advertising = RTL_ADVERTISED_10_HALF | RTL_ADVERTISED_10_FULL |
9864 if (tp->mii.supports_gmii) {
9865 if (tp->support_2500full &&
9866 tp->udev->speed >= USB_SPEED_SUPER) {
9867 tp->speed = SPEED_2500;
9868 tp->advertising |= RTL_ADVERTISED_2500_FULL;
9870 tp->speed = SPEED_1000;
9872 tp->advertising |= RTL_ADVERTISED_1000_FULL;
9874 tp->duplex = DUPLEX_FULL;
9876 tp->rx_copybreak = RTL8152_RXFG_HEADSZ;
9877 tp->rx_pending = 10 * RTL8152_MAX_RX;
9881 if (!rtl_can_wakeup(tp))
9882 __rtl_set_wol(tp, 0);
9884 tp->saved_wolopts = __rtl_get_wol(tp);
9886 tp->rtl_ops.init(tp);
9889 tp->rtl_fw.retry = true;
9891 queue_delayed_work(system_long_wq, &tp->hw_phy_work, 0);
9892 set_ethernet_addr(tp, false);
9894 usb_set_intfdata(intf, tp);
9896 netif_napi_add(netdev, &tp->napi, r8152_poll);
9904 if (tp->saved_wolopts)
9912 if (test_bit(PROBE_SHOULD_RETRY, &tp->flags))
9915 set_bit(PROBED_WITH_NO_ERRORS, &tp->flags);
9916 netif_info(tp, probe, netdev, "%s\n", DRIVER_VERSION);
9924 tasklet_kill(&tp->tx_tl);
9925 cancel_delayed_work_sync(&tp->hw_phy_work);
9926 if (tp->rtl_ops.unload)
9927 tp->rtl_ops.unload(tp);
9928 rtl8152_release_firmware(tp);
9931 if (test_bit(PROBE_SHOULD_RETRY, &tp->flags))
9973 struct r8152 *tp = usb_get_intfdata(intf);
9976 if (tp) {
9977 rtl_set_unplug(tp);
9979 unregister_netdev(tp->netdev);
9980 tasklet_kill(&tp->tx_tl);
9981 cancel_delayed_work_sync(&tp->hw_phy_work);
9982 if (tp->rtl_ops.unload)
9983 tp->rtl_ops.unload(tp);
9984 rtl8152_release_firmware(tp);
9985 free_netdev(tp->netdev);