diff options
Diffstat (limited to 'drivers')
43 files changed, 569 insertions, 414 deletions
diff --git a/drivers/isdn/mISDN/dsp_cmx.c b/drivers/isdn/mISDN/dsp_cmx.c index d4b6f01a3f0e..6d2088fbaf69 100644 --- a/drivers/isdn/mISDN/dsp_cmx.c +++ b/drivers/isdn/mISDN/dsp_cmx.c | |||
| @@ -1676,9 +1676,9 @@ dsp_cmx_send(void *arg) | |||
| 1676 | #ifdef CMX_CONF_DEBUG | 1676 | #ifdef CMX_CONF_DEBUG |
| 1677 | if (conf->software && members > 1) | 1677 | if (conf->software && members > 1) |
| 1678 | #else | 1678 | #else |
| 1679 | if (conf->software && members > 2) | 1679 | if (conf->software && members > 2) |
| 1680 | #endif | 1680 | #endif |
| 1681 | mustmix = 1; | 1681 | mustmix = 1; |
| 1682 | } | 1682 | } |
| 1683 | 1683 | ||
| 1684 | /* transmission required */ | 1684 | /* transmission required */ |
| @@ -1699,263 +1699,262 @@ dsp_cmx_send(void *arg) | |||
| 1699 | #ifdef CMX_CONF_DEBUG | 1699 | #ifdef CMX_CONF_DEBUG |
| 1700 | if (conf->software && members > 1) { | 1700 | if (conf->software && members > 1) { |
| 1701 | #else | 1701 | #else |
| 1702 | if (conf->software && members > 2) { | 1702 | if (conf->software && members > 2) { |
| 1703 | #endif | 1703 | #endif |
| 1704 | /* check for hdlc conf */ | 1704 | /* check for hdlc conf */ |
| 1705 | member = list_entry(conf->mlist.next, | 1705 | member = list_entry(conf->mlist.next, |
| 1706 | struct dsp_conf_member, list); | 1706 | struct dsp_conf_member, list); |
| 1707 | if (member->dsp->hdlc) | 1707 | if (member->dsp->hdlc) |
| 1708 | continue; | 1708 | continue; |
| 1709 | /* mix all data */ | 1709 | /* mix all data */ |
| 1710 | memset(mixbuffer, 0, length * sizeof(s32)); | 1710 | memset(mixbuffer, 0, length * sizeof(s32)); |
| 1711 | list_for_each_entry(member, &conf->mlist, list) { | 1711 | list_for_each_entry(member, &conf->mlist, list) { |
| 1712 | dsp = member->dsp; | 1712 | dsp = member->dsp; |
| 1713 | /* get range of data to mix */ | 1713 | /* get range of data to mix */ |
| 1714 | c = mixbuffer; | 1714 | c = mixbuffer; |
| 1715 | q = dsp->rx_buff; | 1715 | q = dsp->rx_buff; |
| 1716 | r = dsp->rx_R; | 1716 | r = dsp->rx_R; |
| 1717 | rr = (r + length) & CMX_BUFF_MASK; | 1717 | rr = (r + length) & CMX_BUFF_MASK; |
| 1718 | /* add member's data */ | 1718 | /* add member's data */ |
| 1719 | while (r != rr) { | 1719 | while (r != rr) { |
| 1720 | *c++ += dsp_audio_law_to_s32[q[r]]; | 1720 | *c++ += dsp_audio_law_to_s32[q[r]]; |
| 1721 | r = (r + 1) & CMX_BUFF_MASK; | 1721 | r = (r + 1) & CMX_BUFF_MASK; |
| 1722 | } | ||
| 1723 | } | 1722 | } |
| 1723 | } | ||
| 1724 | 1724 | ||
| 1725 | /* process each member */ | 1725 | /* process each member */ |
| 1726 | list_for_each_entry(member, &conf->mlist, list) { | 1726 | list_for_each_entry(member, &conf->mlist, list) { |
| 1727 | /* transmission */ | 1727 | /* transmission */ |
| 1728 | dsp_cmx_send_member(member->dsp, length, | 1728 | dsp_cmx_send_member(member->dsp, length, |
| 1729 | mixbuffer, members); | 1729 | mixbuffer, members); |
| 1730 | } | 1730 | } |
| 1731 | } | ||
| 1732 | } | ||
| 1733 | |||
| 1734 | /* delete rx-data, increment buffers, change pointers */ | ||
| 1735 | list_for_each_entry(dsp, &dsp_ilist, list) { | ||
| 1736 | if (dsp->hdlc) | ||
| 1737 | continue; | ||
| 1738 | p = dsp->rx_buff; | ||
| 1739 | q = dsp->tx_buff; | ||
| 1740 | r = dsp->rx_R; | ||
| 1741 | /* move receive pointer when receiving */ | ||
| 1742 | if (!dsp->rx_is_off) { | ||
| 1743 | rr = (r + length) & CMX_BUFF_MASK; | ||
| 1744 | /* delete rx-data */ | ||
| 1745 | while (r != rr) { | ||
| 1746 | p[r] = dsp_silence; | ||
| 1747 | r = (r + 1) & CMX_BUFF_MASK; | ||
| 1731 | } | 1748 | } |
| 1749 | /* increment rx-buffer pointer */ | ||
| 1750 | dsp->rx_R = r; /* write incremented read pointer */ | ||
| 1732 | } | 1751 | } |
| 1733 | 1752 | ||
| 1734 | /* delete rx-data, increment buffers, change pointers */ | 1753 | /* check current rx_delay */ |
| 1735 | list_for_each_entry(dsp, &dsp_ilist, list) { | 1754 | delay = (dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK; |
| 1736 | if (dsp->hdlc) | 1755 | if (delay >= CMX_BUFF_HALF) |
| 1737 | continue; | 1756 | delay = 0; /* will be the delay before next write */ |
| 1738 | p = dsp->rx_buff; | 1757 | /* check for lower delay */ |
| 1739 | q = dsp->tx_buff; | 1758 | if (delay < dsp->rx_delay[0]) |
| 1740 | r = dsp->rx_R; | 1759 | dsp->rx_delay[0] = delay; |
| 1741 | /* move receive pointer when receiving */ | 1760 | /* check current tx_delay */ |
| 1742 | if (!dsp->rx_is_off) { | 1761 | delay = (dsp->tx_W-dsp->tx_R) & CMX_BUFF_MASK; |
| 1743 | rr = (r + length) & CMX_BUFF_MASK; | 1762 | if (delay >= CMX_BUFF_HALF) |
| 1763 | delay = 0; /* will be the delay before next write */ | ||
| 1764 | /* check for lower delay */ | ||
| 1765 | if (delay < dsp->tx_delay[0]) | ||
| 1766 | dsp->tx_delay[0] = delay; | ||
| 1767 | if (jittercheck) { | ||
| 1768 | /* find the lowest of all rx_delays */ | ||
| 1769 | delay = dsp->rx_delay[0]; | ||
| 1770 | i = 1; | ||
| 1771 | while (i < MAX_SECONDS_JITTER_CHECK) { | ||
| 1772 | if (delay > dsp->rx_delay[i]) | ||
| 1773 | delay = dsp->rx_delay[i]; | ||
| 1774 | i++; | ||
| 1775 | } | ||
| 1776 | /* | ||
| 1777 | * remove rx_delay only if we have delay AND we | ||
| 1778 | * have not preset cmx_delay AND | ||
| 1779 | * the delay is greater dsp_poll | ||
| 1780 | */ | ||
| 1781 | if (delay > dsp_poll && !dsp->cmx_delay) { | ||
| 1782 | if (dsp_debug & DEBUG_DSP_CLOCK) | ||
| 1783 | printk(KERN_DEBUG | ||
| 1784 | "%s lowest rx_delay of %d bytes for" | ||
| 1785 | " dsp %s are now removed.\n", | ||
| 1786 | __func__, delay, | ||
| 1787 | dsp->name); | ||
| 1788 | r = dsp->rx_R; | ||
| 1789 | rr = (r + delay - (dsp_poll >> 1)) | ||
| 1790 | & CMX_BUFF_MASK; | ||
| 1744 | /* delete rx-data */ | 1791 | /* delete rx-data */ |
| 1745 | while (r != rr) { | 1792 | while (r != rr) { |
| 1746 | p[r] = dsp_silence; | 1793 | p[r] = dsp_silence; |
| 1747 | r = (r + 1) & CMX_BUFF_MASK; | 1794 | r = (r + 1) & CMX_BUFF_MASK; |
| 1748 | } | 1795 | } |
| 1749 | /* increment rx-buffer pointer */ | 1796 | /* increment rx-buffer pointer */ |
| 1750 | dsp->rx_R = r; /* write incremented read pointer */ | 1797 | dsp->rx_R = r; |
| 1798 | /* write incremented read pointer */ | ||
| 1751 | } | 1799 | } |
| 1752 | 1800 | /* find the lowest of all tx_delays */ | |
| 1753 | /* check current rx_delay */ | 1801 | delay = dsp->tx_delay[0]; |
| 1754 | delay = (dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK; | 1802 | i = 1; |
| 1755 | if (delay >= CMX_BUFF_HALF) | 1803 | while (i < MAX_SECONDS_JITTER_CHECK) { |
| 1756 | delay = 0; /* will be the delay before next write */ | 1804 | if (delay > dsp->tx_delay[i]) |
| 1757 | /* check for lower delay */ | 1805 | delay = dsp->tx_delay[i]; |
| 1758 | if (delay < dsp->rx_delay[0]) | 1806 | i++; |
| 1759 | dsp->rx_delay[0] = delay; | 1807 | } |
| 1760 | /* check current tx_delay */ | 1808 | /* |
| 1761 | delay = (dsp->tx_W-dsp->tx_R) & CMX_BUFF_MASK; | 1809 | * remove delay only if we have delay AND we |
| 1762 | if (delay >= CMX_BUFF_HALF) | 1810 | * have enabled tx_dejitter |
| 1763 | delay = 0; /* will be the delay before next write */ | 1811 | */ |
| 1764 | /* check for lower delay */ | 1812 | if (delay > dsp_poll && dsp->tx_dejitter) { |
| 1765 | if (delay < dsp->tx_delay[0]) | 1813 | if (dsp_debug & DEBUG_DSP_CLOCK) |
| 1766 | dsp->tx_delay[0] = delay; | 1814 | printk(KERN_DEBUG |
| 1767 | if (jittercheck) { | 1815 | "%s lowest tx_delay of %d bytes for" |
| 1768 | /* find the lowest of all rx_delays */ | 1816 | " dsp %s are now removed.\n", |
| 1769 | delay = dsp->rx_delay[0]; | 1817 | __func__, delay, |
| 1770 | i = 1; | 1818 | dsp->name); |
| 1771 | while (i < MAX_SECONDS_JITTER_CHECK) { | 1819 | r = dsp->tx_R; |
| 1772 | if (delay > dsp->rx_delay[i]) | 1820 | rr = (r + delay - (dsp_poll >> 1)) |
| 1773 | delay = dsp->rx_delay[i]; | 1821 | & CMX_BUFF_MASK; |
| 1774 | i++; | 1822 | /* delete tx-data */ |
| 1775 | } | 1823 | while (r != rr) { |
| 1776 | /* | 1824 | q[r] = dsp_silence; |
| 1777 | * remove rx_delay only if we have delay AND we | 1825 | r = (r + 1) & CMX_BUFF_MASK; |
| 1778 | * have not preset cmx_delay AND | ||
| 1779 | * the delay is greater dsp_poll | ||
| 1780 | */ | ||
| 1781 | if (delay > dsp_poll && !dsp->cmx_delay) { | ||
| 1782 | if (dsp_debug & DEBUG_DSP_CLOCK) | ||
| 1783 | printk(KERN_DEBUG | ||
| 1784 | "%s lowest rx_delay of %d bytes for" | ||
| 1785 | " dsp %s are now removed.\n", | ||
| 1786 | __func__, delay, | ||
| 1787 | dsp->name); | ||
| 1788 | r = dsp->rx_R; | ||
| 1789 | rr = (r + delay - (dsp_poll >> 1)) | ||
| 1790 | & CMX_BUFF_MASK; | ||
| 1791 | /* delete rx-data */ | ||
| 1792 | while (r != rr) { | ||
| 1793 | p[r] = dsp_silence; | ||
| 1794 | r = (r + 1) & CMX_BUFF_MASK; | ||
| 1795 | } | ||
| 1796 | /* increment rx-buffer pointer */ | ||
| 1797 | dsp->rx_R = r; | ||
| 1798 | /* write incremented read pointer */ | ||
| 1799 | } | ||
| 1800 | /* find the lowest of all tx_delays */ | ||
| 1801 | delay = dsp->tx_delay[0]; | ||
| 1802 | i = 1; | ||
| 1803 | while (i < MAX_SECONDS_JITTER_CHECK) { | ||
| 1804 | if (delay > dsp->tx_delay[i]) | ||
| 1805 | delay = dsp->tx_delay[i]; | ||
| 1806 | i++; | ||
| 1807 | } | ||
| 1808 | /* | ||
| 1809 | * remove delay only if we have delay AND we | ||
| 1810 | * have enabled tx_dejitter | ||
| 1811 | */ | ||
| 1812 | if (delay > dsp_poll && dsp->tx_dejitter) { | ||
| 1813 | if (dsp_debug & DEBUG_DSP_CLOCK) | ||
| 1814 | printk(KERN_DEBUG | ||
| 1815 | "%s lowest tx_delay of %d bytes for" | ||
| 1816 | " dsp %s are now removed.\n", | ||
| 1817 | __func__, delay, | ||
| 1818 | dsp->name); | ||
| 1819 | r = dsp->tx_R; | ||
| 1820 | rr = (r + delay - (dsp_poll >> 1)) | ||
| 1821 | & CMX_BUFF_MASK; | ||
| 1822 | /* delete tx-data */ | ||
| 1823 | while (r != rr) { | ||
| 1824 | q[r] = dsp_silence; | ||
| 1825 | r = (r + 1) & CMX_BUFF_MASK; | ||
| 1826 | } | ||
| 1827 | /* increment rx-buffer pointer */ | ||
| 1828 | dsp->tx_R = r; | ||
| 1829 | /* write incremented read pointer */ | ||
| 1830 | } | ||
| 1831 | /* scroll up delays */ | ||
| 1832 | i = MAX_SECONDS_JITTER_CHECK - 1; | ||
| 1833 | while (i) { | ||
| 1834 | dsp->rx_delay[i] = dsp->rx_delay[i - 1]; | ||
| 1835 | dsp->tx_delay[i] = dsp->tx_delay[i - 1]; | ||
| 1836 | i--; | ||
| 1837 | } | 1826 | } |
| 1838 | dsp->tx_delay[0] = CMX_BUFF_HALF; /* (infinite) delay */ | 1827 | /* increment rx-buffer pointer */ |
| 1839 | dsp->rx_delay[0] = CMX_BUFF_HALF; /* (infinite) delay */ | 1828 | dsp->tx_R = r; |
| 1829 | /* write incremented read pointer */ | ||
| 1840 | } | 1830 | } |
| 1831 | /* scroll up delays */ | ||
| 1832 | i = MAX_SECONDS_JITTER_CHECK - 1; | ||
| 1833 | while (i) { | ||
| 1834 | dsp->rx_delay[i] = dsp->rx_delay[i - 1]; | ||
| 1835 | dsp->tx_delay[i] = dsp->tx_delay[i - 1]; | ||
| 1836 | i--; | ||
| 1837 | } | ||
| 1838 | dsp->tx_delay[0] = CMX_BUFF_HALF; /* (infinite) delay */ | ||
| 1839 | dsp->rx_delay[0] = CMX_BUFF_HALF; /* (infinite) delay */ | ||
| 1841 | } | 1840 | } |
| 1841 | } | ||
| 1842 | 1842 | ||
| 1843 | /* if next event would be in the past ... */ | 1843 | /* if next event would be in the past ... */ |
| 1844 | if ((s32)(dsp_spl_jiffies + dsp_tics-jiffies) <= 0) | 1844 | if ((s32)(dsp_spl_jiffies + dsp_tics-jiffies) <= 0) |
| 1845 | dsp_spl_jiffies = jiffies + 1; | 1845 | dsp_spl_jiffies = jiffies + 1; |
| 1846 | else | 1846 | else |
| 1847 | dsp_spl_jiffies += dsp_tics; | 1847 | dsp_spl_jiffies += dsp_tics; |
| 1848 | 1848 | ||
| 1849 | dsp_spl_tl.expires = dsp_spl_jiffies; | 1849 | dsp_spl_tl.expires = dsp_spl_jiffies; |
| 1850 | add_timer(&dsp_spl_tl); | 1850 | add_timer(&dsp_spl_tl); |
| 1851 | 1851 | ||
| 1852 | /* unlock */ | 1852 | /* unlock */ |
| 1853 | spin_unlock_irqrestore(&dsp_lock, flags); | 1853 | spin_unlock_irqrestore(&dsp_lock, flags); |
| 1854 | } | 1854 | } |
| 1855 | 1855 | ||
| 1856 | /* | 1856 | /* |
| 1857 | * audio data is transmitted from upper layer to the dsp | 1857 | * audio data is transmitted from upper layer to the dsp |
| 1858 | */ | 1858 | */ |
| 1859 | void | 1859 | void |
| 1860 | dsp_cmx_transmit(struct dsp *dsp, struct sk_buff *skb) | 1860 | dsp_cmx_transmit(struct dsp *dsp, struct sk_buff *skb) |
| 1861 | { | 1861 | { |
| 1862 | u_int w, ww; | 1862 | u_int w, ww; |
| 1863 | u8 *d, *p; | 1863 | u8 *d, *p; |
| 1864 | int space; /* todo: , l = skb->len; */ | 1864 | int space; /* todo: , l = skb->len; */ |
| 1865 | #ifdef CMX_TX_DEBUG | 1865 | #ifdef CMX_TX_DEBUG |
| 1866 | char debugbuf[256] = ""; | 1866 | char debugbuf[256] = ""; |
| 1867 | #endif | 1867 | #endif |
| 1868 | 1868 | ||
| 1869 | /* check if there is enough space, and then copy */ | 1869 | /* check if there is enough space, and then copy */ |
| 1870 | w = dsp->tx_W; | 1870 | w = dsp->tx_W; |
| 1871 | ww = dsp->tx_R; | 1871 | ww = dsp->tx_R; |
| 1872 | p = dsp->tx_buff; | 1872 | p = dsp->tx_buff; |
| 1873 | d = skb->data; | 1873 | d = skb->data; |
| 1874 | space = (ww - w - 1) & CMX_BUFF_MASK; | 1874 | space = (ww - w - 1) & CMX_BUFF_MASK; |
| 1875 | /* write-pointer should not overrun nor reach read pointer */ | 1875 | /* write-pointer should not overrun nor reach read pointer */ |
| 1876 | if (space < skb->len) { | 1876 | if (space < skb->len) { |
| 1877 | /* write to the space we have left */ | 1877 | /* write to the space we have left */ |
| 1878 | ww = (ww - 1) & CMX_BUFF_MASK; /* end one byte prior tx_R */ | 1878 | ww = (ww - 1) & CMX_BUFF_MASK; /* end one byte prior tx_R */ |
| 1879 | if (dsp_debug & DEBUG_DSP_CLOCK) | 1879 | if (dsp_debug & DEBUG_DSP_CLOCK) |
| 1880 | printk(KERN_DEBUG "%s: TX overflow space=%d skb->len=" | 1880 | printk(KERN_DEBUG "%s: TX overflow space=%d skb->len=" |
| 1881 | "%d, w=0x%04x, ww=0x%04x\n", __func__, space, | 1881 | "%d, w=0x%04x, ww=0x%04x\n", __func__, space, |
| 1882 | skb->len, w, ww); | 1882 | skb->len, w, ww); |
| 1883 | } else | 1883 | } else |
| 1884 | /* write until all byte are copied */ | 1884 | /* write until all byte are copied */ |
| 1885 | ww = (w + skb->len) & CMX_BUFF_MASK; | 1885 | ww = (w + skb->len) & CMX_BUFF_MASK; |
| 1886 | dsp->tx_W = ww; | 1886 | dsp->tx_W = ww; |
| 1887 | |||
| 1888 | /* show current buffer */ | 1887 | /* show current buffer */ |
| 1889 | #ifdef CMX_DEBUG | 1888 | #ifdef CMX_DEBUG |
| 1890 | printk(KERN_DEBUG | 1889 | printk(KERN_DEBUG |
| 1891 | "cmx_transmit(dsp=%lx) %d bytes to 0x%x-0x%x. %s\n", | 1890 | "cmx_transmit(dsp=%lx) %d bytes to 0x%x-0x%x. %s\n", |
| 1892 | (u_long)dsp, (ww - w) & CMX_BUFF_MASK, w, ww, dsp->name); | 1891 | (u_long)dsp, (ww - w) & CMX_BUFF_MASK, w, ww, dsp->name); |
| 1893 | #endif | 1892 | #endif |
| 1894 | 1893 | ||
| 1895 | /* copy transmit data to tx-buffer */ | 1894 | /* copy transmit data to tx-buffer */ |
| 1896 | #ifdef CMX_TX_DEBUG | 1895 | #ifdef CMX_TX_DEBUG |
| 1897 | sprintf(debugbuf, "TX getting (%04x-%04x)%p: ", w, ww, p); | 1896 | sprintf(debugbuf, "TX getting (%04x-%04x)%p: ", w, ww, p); |
| 1898 | #endif | 1897 | #endif |
| 1899 | while (w != ww) { | 1898 | while (w != ww) { |
| 1900 | #ifdef CMX_TX_DEBUG | 1899 | #ifdef CMX_TX_DEBUG |
| 1901 | if (strlen(debugbuf) < 48) | 1900 | if (strlen(debugbuf) < 48) |
| 1902 | sprintf(debugbuf + strlen(debugbuf), " %02x", *d); | 1901 | sprintf(debugbuf + strlen(debugbuf), " %02x", *d); |
| 1903 | #endif | 1902 | #endif |
| 1904 | p[w] = *d++; | 1903 | p[w] = *d++; |
| 1905 | w = (w + 1) & CMX_BUFF_MASK; | 1904 | w = (w + 1) & CMX_BUFF_MASK; |
| 1906 | } | 1905 | } |
| 1907 | #ifdef CMX_TX_DEBUG | 1906 | #ifdef CMX_TX_DEBUG |
| 1908 | printk(KERN_DEBUG "%s\n", debugbuf); | 1907 | printk(KERN_DEBUG "%s\n", debugbuf); |
| 1909 | #endif | 1908 | #endif |
| 1910 | 1909 | ||
| 1911 | } | 1910 | } |
| 1912 | 1911 | ||
| 1913 | /* | 1912 | /* |
| 1914 | * hdlc data is received from card and sent to all members. | 1913 | * hdlc data is received from card and sent to all members. |
| 1915 | */ | 1914 | */ |
| 1916 | void | 1915 | void |
| 1917 | dsp_cmx_hdlc(struct dsp *dsp, struct sk_buff *skb) | 1916 | dsp_cmx_hdlc(struct dsp *dsp, struct sk_buff *skb) |
| 1918 | { | 1917 | { |
| 1919 | struct sk_buff *nskb = NULL; | 1918 | struct sk_buff *nskb = NULL; |
| 1920 | struct dsp_conf_member *member; | 1919 | struct dsp_conf_member *member; |
| 1921 | struct mISDNhead *hh; | 1920 | struct mISDNhead *hh; |
| 1922 | |||
| 1923 | /* not if not active */ | ||
| 1924 | if (!dsp->b_active) | ||
| 1925 | return; | ||
| 1926 | 1921 | ||
| 1927 | /* check if we have sompen */ | 1922 | /* not if not active */ |
| 1928 | if (skb->len < 1) | 1923 | if (!dsp->b_active) |
| 1929 | return; | 1924 | return; |
| 1930 | 1925 | ||
| 1931 | /* no conf */ | 1926 | /* check if we have sompen */ |
| 1932 | if (!dsp->conf) { | 1927 | if (skb->len < 1) |
| 1933 | /* in case of software echo */ | 1928 | return; |
| 1934 | if (dsp->echo.software) { | 1929 | |
| 1935 | nskb = skb_clone(skb, GFP_ATOMIC); | 1930 | /* no conf */ |
| 1936 | if (nskb) { | 1931 | if (!dsp->conf) { |
| 1937 | hh = mISDN_HEAD_P(nskb); | 1932 | /* in case of software echo */ |
| 1938 | hh->prim = PH_DATA_REQ; | 1933 | if (dsp->echo.software) { |
| 1939 | hh->id = 0; | 1934 | nskb = skb_clone(skb, GFP_ATOMIC); |
| 1940 | skb_queue_tail(&dsp->sendq, nskb); | 1935 | if (nskb) { |
| 1941 | schedule_work(&dsp->workq); | 1936 | hh = mISDN_HEAD_P(nskb); |
| 1942 | } | 1937 | hh->prim = PH_DATA_REQ; |
| 1938 | hh->id = 0; | ||
| 1939 | skb_queue_tail(&dsp->sendq, nskb); | ||
| 1940 | schedule_work(&dsp->workq); | ||
| 1943 | } | 1941 | } |
| 1944 | return; | ||
| 1945 | } | 1942 | } |
| 1946 | /* in case of hardware conference */ | 1943 | return; |
| 1947 | if (dsp->conf->hardware) | 1944 | } |
| 1948 | return; | 1945 | /* in case of hardware conference */ |
| 1949 | list_for_each_entry(member, &dsp->conf->mlist, list) { | 1946 | if (dsp->conf->hardware) |
| 1950 | if (dsp->echo.software || member->dsp != dsp) { | 1947 | return; |
| 1951 | nskb = skb_clone(skb, GFP_ATOMIC); | 1948 | list_for_each_entry(member, &dsp->conf->mlist, list) { |
| 1952 | if (nskb) { | 1949 | if (dsp->echo.software || member->dsp != dsp) { |
| 1953 | hh = mISDN_HEAD_P(nskb); | 1950 | nskb = skb_clone(skb, GFP_ATOMIC); |
| 1954 | hh->prim = PH_DATA_REQ; | 1951 | if (nskb) { |
| 1955 | hh->id = 0; | 1952 | hh = mISDN_HEAD_P(nskb); |
| 1956 | skb_queue_tail(&member->dsp->sendq, nskb); | 1953 | hh->prim = PH_DATA_REQ; |
| 1957 | schedule_work(&member->dsp->workq); | 1954 | hh->id = 0; |
| 1958 | } | 1955 | skb_queue_tail(&member->dsp->sendq, nskb); |
| 1956 | schedule_work(&member->dsp->workq); | ||
| 1959 | } | 1957 | } |
| 1960 | } | 1958 | } |
| 1961 | } | 1959 | } |
| 1960 | } | ||
diff --git a/drivers/isdn/mISDN/socket.c b/drivers/isdn/mISDN/socket.c index a14e35d40538..84e1d4c2db66 100644 --- a/drivers/isdn/mISDN/socket.c +++ b/drivers/isdn/mISDN/socket.c | |||
| @@ -393,7 +393,7 @@ data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) | |||
| 393 | memcpy(di.channelmap, dev->channelmap, | 393 | memcpy(di.channelmap, dev->channelmap, |
| 394 | sizeof(di.channelmap)); | 394 | sizeof(di.channelmap)); |
| 395 | di.nrbchan = dev->nrbchan; | 395 | di.nrbchan = dev->nrbchan; |
| 396 | strcpy(di.name, dev_name(&dev->dev)); | 396 | strscpy(di.name, dev_name(&dev->dev), sizeof(di.name)); |
| 397 | if (copy_to_user((void __user *)arg, &di, sizeof(di))) | 397 | if (copy_to_user((void __user *)arg, &di, sizeof(di))) |
| 398 | err = -EFAULT; | 398 | err = -EFAULT; |
| 399 | } else | 399 | } else |
| @@ -676,7 +676,7 @@ base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) | |||
| 676 | memcpy(di.channelmap, dev->channelmap, | 676 | memcpy(di.channelmap, dev->channelmap, |
| 677 | sizeof(di.channelmap)); | 677 | sizeof(di.channelmap)); |
| 678 | di.nrbchan = dev->nrbchan; | 678 | di.nrbchan = dev->nrbchan; |
| 679 | strcpy(di.name, dev_name(&dev->dev)); | 679 | strscpy(di.name, dev_name(&dev->dev), sizeof(di.name)); |
| 680 | if (copy_to_user((void __user *)arg, &di, sizeof(di))) | 680 | if (copy_to_user((void __user *)arg, &di, sizeof(di))) |
| 681 | err = -EFAULT; | 681 | err = -EFAULT; |
| 682 | } else | 682 | } else |
| @@ -690,6 +690,7 @@ base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) | |||
| 690 | err = -EFAULT; | 690 | err = -EFAULT; |
| 691 | break; | 691 | break; |
| 692 | } | 692 | } |
| 693 | dn.name[sizeof(dn.name) - 1] = '\0'; | ||
| 693 | dev = get_mdevice(dn.id); | 694 | dev = get_mdevice(dn.id); |
| 694 | if (dev) | 695 | if (dev) |
| 695 | err = device_rename(&dev->dev, dn.name); | 696 | err = device_rename(&dev->dev, dn.name); |
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c index 062fa7e3af4c..407f4095a37a 100644 --- a/drivers/net/bonding/bond_main.c +++ b/drivers/net/bonding/bond_main.c | |||
| @@ -3122,13 +3122,18 @@ static int bond_slave_netdev_event(unsigned long event, | |||
| 3122 | case NETDEV_CHANGE: | 3122 | case NETDEV_CHANGE: |
| 3123 | /* For 802.3ad mode only: | 3123 | /* For 802.3ad mode only: |
| 3124 | * Getting invalid Speed/Duplex values here will put slave | 3124 | * Getting invalid Speed/Duplex values here will put slave |
| 3125 | * in weird state. So mark it as link-fail for the time | 3125 | * in weird state. Mark it as link-fail if the link was |
| 3126 | * being and let link-monitoring (miimon) set it right when | 3126 | * previously up or link-down if it hasn't yet come up, and |
| 3127 | * correct speeds/duplex are available. | 3127 | * let link-monitoring (miimon) set it right when correct |
| 3128 | * speeds/duplex are available. | ||
| 3128 | */ | 3129 | */ |
| 3129 | if (bond_update_speed_duplex(slave) && | 3130 | if (bond_update_speed_duplex(slave) && |
| 3130 | BOND_MODE(bond) == BOND_MODE_8023AD) | 3131 | BOND_MODE(bond) == BOND_MODE_8023AD) { |
| 3131 | slave->link = BOND_LINK_FAIL; | 3132 | if (slave->last_link_up) |
| 3133 | slave->link = BOND_LINK_FAIL; | ||
| 3134 | else | ||
| 3135 | slave->link = BOND_LINK_DOWN; | ||
| 3136 | } | ||
| 3132 | 3137 | ||
| 3133 | if (BOND_MODE(bond) == BOND_MODE_8023AD) | 3138 | if (BOND_MODE(bond) == BOND_MODE_8023AD) |
| 3134 | bond_3ad_adapter_speed_duplex_changed(slave); | 3139 | bond_3ad_adapter_speed_duplex_changed(slave); |
diff --git a/drivers/net/dsa/mv88e6xxx/chip.c b/drivers/net/dsa/mv88e6xxx/chip.c index 28414db979b0..12f165a71a6c 100644 --- a/drivers/net/dsa/mv88e6xxx/chip.c +++ b/drivers/net/dsa/mv88e6xxx/chip.c | |||
| @@ -785,7 +785,7 @@ static uint64_t _mv88e6xxx_get_ethtool_stat(struct mv88e6xxx_chip *chip, | |||
| 785 | err = mv88e6xxx_port_read(chip, port, s->reg + 1, ®); | 785 | err = mv88e6xxx_port_read(chip, port, s->reg + 1, ®); |
| 786 | if (err) | 786 | if (err) |
| 787 | return U64_MAX; | 787 | return U64_MAX; |
| 788 | high = reg; | 788 | low |= ((u32)reg) << 16; |
| 789 | } | 789 | } |
| 790 | break; | 790 | break; |
| 791 | case STATS_TYPE_BANK1: | 791 | case STATS_TYPE_BANK1: |
diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_ring.c b/drivers/net/ethernet/aquantia/atlantic/aq_ring.c index 350e385528fd..941b0beb87ef 100644 --- a/drivers/net/ethernet/aquantia/atlantic/aq_ring.c +++ b/drivers/net/ethernet/aquantia/atlantic/aq_ring.c | |||
| @@ -223,10 +223,10 @@ void aq_ring_queue_stop(struct aq_ring_s *ring) | |||
| 223 | bool aq_ring_tx_clean(struct aq_ring_s *self) | 223 | bool aq_ring_tx_clean(struct aq_ring_s *self) |
| 224 | { | 224 | { |
| 225 | struct device *dev = aq_nic_get_dev(self->aq_nic); | 225 | struct device *dev = aq_nic_get_dev(self->aq_nic); |
| 226 | unsigned int budget = AQ_CFG_TX_CLEAN_BUDGET; | 226 | unsigned int budget; |
| 227 | 227 | ||
| 228 | for (; self->sw_head != self->hw_head && budget--; | 228 | for (budget = AQ_CFG_TX_CLEAN_BUDGET; |
| 229 | self->sw_head = aq_ring_next_dx(self, self->sw_head)) { | 229 | budget && self->sw_head != self->hw_head; budget--) { |
| 230 | struct aq_ring_buff_s *buff = &self->buff_ring[self->sw_head]; | 230 | struct aq_ring_buff_s *buff = &self->buff_ring[self->sw_head]; |
| 231 | 231 | ||
| 232 | if (likely(buff->is_mapped)) { | 232 | if (likely(buff->is_mapped)) { |
| @@ -251,6 +251,7 @@ bool aq_ring_tx_clean(struct aq_ring_s *self) | |||
| 251 | 251 | ||
| 252 | buff->pa = 0U; | 252 | buff->pa = 0U; |
| 253 | buff->eop_index = 0xffffU; | 253 | buff->eop_index = 0xffffU; |
| 254 | self->sw_head = aq_ring_next_dx(self, self->sw_head); | ||
| 254 | } | 255 | } |
| 255 | 256 | ||
| 256 | return !!budget; | 257 | return !!budget; |
| @@ -298,35 +299,47 @@ int aq_ring_rx_clean(struct aq_ring_s *self, | |||
| 298 | unsigned int i = 0U; | 299 | unsigned int i = 0U; |
| 299 | u16 hdr_len; | 300 | u16 hdr_len; |
| 300 | 301 | ||
| 301 | if (buff->is_error) | ||
| 302 | continue; | ||
| 303 | |||
| 304 | if (buff->is_cleaned) | 302 | if (buff->is_cleaned) |
| 305 | continue; | 303 | continue; |
| 306 | 304 | ||
| 307 | if (!buff->is_eop) { | 305 | if (!buff->is_eop) { |
| 308 | for (next_ = buff->next, | 306 | buff_ = buff; |
| 309 | buff_ = &self->buff_ring[next_]; true; | 307 | do { |
| 310 | next_ = buff_->next, | 308 | next_ = buff_->next, |
| 311 | buff_ = &self->buff_ring[next_]) { | 309 | buff_ = &self->buff_ring[next_]; |
| 312 | is_rsc_completed = | 310 | is_rsc_completed = |
| 313 | aq_ring_dx_in_range(self->sw_head, | 311 | aq_ring_dx_in_range(self->sw_head, |
| 314 | next_, | 312 | next_, |
| 315 | self->hw_head); | 313 | self->hw_head); |
| 316 | 314 | ||
| 317 | if (unlikely(!is_rsc_completed)) { | 315 | if (unlikely(!is_rsc_completed)) |
| 318 | is_rsc_completed = false; | ||
| 319 | break; | 316 | break; |
| 320 | } | ||
| 321 | 317 | ||
| 322 | if (buff_->is_eop) | 318 | buff->is_error |= buff_->is_error; |
| 323 | break; | 319 | |
| 324 | } | 320 | } while (!buff_->is_eop); |
| 325 | 321 | ||
| 326 | if (!is_rsc_completed) { | 322 | if (!is_rsc_completed) { |
| 327 | err = 0; | 323 | err = 0; |
| 328 | goto err_exit; | 324 | goto err_exit; |
| 329 | } | 325 | } |
| 326 | if (buff->is_error) { | ||
| 327 | buff_ = buff; | ||
| 328 | do { | ||
| 329 | next_ = buff_->next, | ||
| 330 | buff_ = &self->buff_ring[next_]; | ||
| 331 | |||
| 332 | buff_->is_cleaned = true; | ||
| 333 | } while (!buff_->is_eop); | ||
| 334 | |||
| 335 | ++self->stats.rx.errors; | ||
| 336 | continue; | ||
| 337 | } | ||
| 338 | } | ||
| 339 | |||
| 340 | if (buff->is_error) { | ||
| 341 | ++self->stats.rx.errors; | ||
| 342 | continue; | ||
| 330 | } | 343 | } |
| 331 | 344 | ||
| 332 | dma_sync_single_range_for_cpu(aq_nic_get_dev(self->aq_nic), | 345 | dma_sync_single_range_for_cpu(aq_nic_get_dev(self->aq_nic), |
| @@ -389,6 +402,12 @@ int aq_ring_rx_clean(struct aq_ring_s *self, | |||
| 389 | AQ_CFG_RX_FRAME_MAX); | 402 | AQ_CFG_RX_FRAME_MAX); |
| 390 | page_ref_inc(buff_->rxdata.page); | 403 | page_ref_inc(buff_->rxdata.page); |
| 391 | buff_->is_cleaned = 1; | 404 | buff_->is_cleaned = 1; |
| 405 | |||
| 406 | buff->is_ip_cso &= buff_->is_ip_cso; | ||
| 407 | buff->is_udp_cso &= buff_->is_udp_cso; | ||
| 408 | buff->is_tcp_cso &= buff_->is_tcp_cso; | ||
| 409 | buff->is_cso_err |= buff_->is_cso_err; | ||
| 410 | |||
| 392 | } while (!buff_->is_eop); | 411 | } while (!buff_->is_eop); |
| 393 | } | 412 | } |
| 394 | } | 413 | } |
diff --git a/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c b/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c index bfcda12d73de..5c3065bdfddf 100644 --- a/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c +++ b/drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c | |||
| @@ -266,12 +266,11 @@ static int hw_atl_b0_hw_offload_set(struct aq_hw_s *self, | |||
| 266 | */ | 266 | */ |
| 267 | hw_atl_rpo_lro_max_coalescing_interval_set(self, 50); | 267 | hw_atl_rpo_lro_max_coalescing_interval_set(self, 50); |
| 268 | 268 | ||
| 269 | |||
| 270 | hw_atl_rpo_lro_qsessions_lim_set(self, 1U); | 269 | hw_atl_rpo_lro_qsessions_lim_set(self, 1U); |
| 271 | 270 | ||
| 272 | hw_atl_rpo_lro_total_desc_lim_set(self, 2U); | 271 | hw_atl_rpo_lro_total_desc_lim_set(self, 2U); |
| 273 | 272 | ||
| 274 | hw_atl_rpo_lro_patch_optimization_en_set(self, 0U); | 273 | hw_atl_rpo_lro_patch_optimization_en_set(self, 1U); |
| 275 | 274 | ||
| 276 | hw_atl_rpo_lro_min_pay_of_first_pkt_set(self, 10U); | 275 | hw_atl_rpo_lro_min_pay_of_first_pkt_set(self, 10U); |
| 277 | 276 | ||
| @@ -713,38 +712,41 @@ static int hw_atl_b0_hw_ring_rx_receive(struct aq_hw_s *self, | |||
| 713 | if ((rx_stat & BIT(0)) || rxd_wb->type & 0x1000U) { | 712 | if ((rx_stat & BIT(0)) || rxd_wb->type & 0x1000U) { |
| 714 | /* MAC error or DMA error */ | 713 | /* MAC error or DMA error */ |
| 715 | buff->is_error = 1U; | 714 | buff->is_error = 1U; |
| 716 | } else { | 715 | } |
| 717 | if (self->aq_nic_cfg->is_rss) { | 716 | if (self->aq_nic_cfg->is_rss) { |
| 718 | /* last 4 byte */ | 717 | /* last 4 byte */ |
| 719 | u16 rss_type = rxd_wb->type & 0xFU; | 718 | u16 rss_type = rxd_wb->type & 0xFU; |
| 720 | 719 | ||
| 721 | if (rss_type && rss_type < 0x8U) { | 720 | if (rss_type && rss_type < 0x8U) { |
| 722 | buff->is_hash_l4 = (rss_type == 0x4 || | 721 | buff->is_hash_l4 = (rss_type == 0x4 || |
| 723 | rss_type == 0x5); | 722 | rss_type == 0x5); |
| 724 | buff->rss_hash = rxd_wb->rss_hash; | 723 | buff->rss_hash = rxd_wb->rss_hash; |
| 725 | } | ||
| 726 | } | 724 | } |
| 725 | } | ||
| 727 | 726 | ||
| 728 | if (HW_ATL_B0_RXD_WB_STAT2_EOP & rxd_wb->status) { | 727 | if (HW_ATL_B0_RXD_WB_STAT2_EOP & rxd_wb->status) { |
| 729 | buff->len = rxd_wb->pkt_len % | 728 | buff->len = rxd_wb->pkt_len % |
| 730 | AQ_CFG_RX_FRAME_MAX; | 729 | AQ_CFG_RX_FRAME_MAX; |
| 731 | buff->len = buff->len ? | 730 | buff->len = buff->len ? |
| 732 | buff->len : AQ_CFG_RX_FRAME_MAX; | 731 | buff->len : AQ_CFG_RX_FRAME_MAX; |
| 733 | buff->next = 0U; | 732 | buff->next = 0U; |
| 734 | buff->is_eop = 1U; | 733 | buff->is_eop = 1U; |
| 734 | } else { | ||
| 735 | buff->len = | ||
| 736 | rxd_wb->pkt_len > AQ_CFG_RX_FRAME_MAX ? | ||
| 737 | AQ_CFG_RX_FRAME_MAX : rxd_wb->pkt_len; | ||
| 738 | |||
| 739 | if (HW_ATL_B0_RXD_WB_STAT2_RSCCNT & | ||
| 740 | rxd_wb->status) { | ||
| 741 | /* LRO */ | ||
| 742 | buff->next = rxd_wb->next_desc_ptr; | ||
| 743 | ++ring->stats.rx.lro_packets; | ||
| 735 | } else { | 744 | } else { |
| 736 | if (HW_ATL_B0_RXD_WB_STAT2_RSCCNT & | 745 | /* jumbo */ |
| 737 | rxd_wb->status) { | 746 | buff->next = |
| 738 | /* LRO */ | 747 | aq_ring_next_dx(ring, |
| 739 | buff->next = rxd_wb->next_desc_ptr; | 748 | ring->hw_head); |
| 740 | ++ring->stats.rx.lro_packets; | 749 | ++ring->stats.rx.jumbo_packets; |
| 741 | } else { | ||
| 742 | /* jumbo */ | ||
| 743 | buff->next = | ||
| 744 | aq_ring_next_dx(ring, | ||
| 745 | ring->hw_head); | ||
| 746 | ++ring->stats.rx.jumbo_packets; | ||
| 747 | } | ||
| 748 | } | 750 | } |
| 749 | } | 751 | } |
| 750 | } | 752 | } |
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c index 8314c00d7537..f758b2e0591f 100644 --- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c +++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c | |||
| @@ -1642,6 +1642,8 @@ static int bnxt_rx_pkt(struct bnxt *bp, struct bnxt_cp_ring_info *cpr, | |||
| 1642 | skb = bnxt_copy_skb(bnapi, data_ptr, len, dma_addr); | 1642 | skb = bnxt_copy_skb(bnapi, data_ptr, len, dma_addr); |
| 1643 | bnxt_reuse_rx_data(rxr, cons, data); | 1643 | bnxt_reuse_rx_data(rxr, cons, data); |
| 1644 | if (!skb) { | 1644 | if (!skb) { |
| 1645 | if (agg_bufs) | ||
| 1646 | bnxt_reuse_rx_agg_bufs(cpr, cp_cons, agg_bufs); | ||
| 1645 | rc = -ENOMEM; | 1647 | rc = -ENOMEM; |
| 1646 | goto next_rx; | 1648 | goto next_rx; |
| 1647 | } | 1649 | } |
| @@ -6377,7 +6379,7 @@ static int bnxt_alloc_ctx_mem(struct bnxt *bp) | |||
| 6377 | if (!ctx || (ctx->flags & BNXT_CTX_FLAG_INITED)) | 6379 | if (!ctx || (ctx->flags & BNXT_CTX_FLAG_INITED)) |
| 6378 | return 0; | 6380 | return 0; |
| 6379 | 6381 | ||
| 6380 | if (bp->flags & BNXT_FLAG_ROCE_CAP) { | 6382 | if ((bp->flags & BNXT_FLAG_ROCE_CAP) && !is_kdump_kernel()) { |
| 6381 | pg_lvl = 2; | 6383 | pg_lvl = 2; |
| 6382 | extra_qps = 65536; | 6384 | extra_qps = 65536; |
| 6383 | extra_srqs = 8192; | 6385 | extra_srqs = 8192; |
| @@ -7616,22 +7618,23 @@ static void bnxt_clear_int_mode(struct bnxt *bp) | |||
| 7616 | bp->flags &= ~BNXT_FLAG_USING_MSIX; | 7618 | bp->flags &= ~BNXT_FLAG_USING_MSIX; |
| 7617 | } | 7619 | } |
| 7618 | 7620 | ||
| 7619 | int bnxt_reserve_rings(struct bnxt *bp) | 7621 | int bnxt_reserve_rings(struct bnxt *bp, bool irq_re_init) |
| 7620 | { | 7622 | { |
| 7621 | int tcs = netdev_get_num_tc(bp->dev); | 7623 | int tcs = netdev_get_num_tc(bp->dev); |
| 7622 | bool reinit_irq = false; | 7624 | bool irq_cleared = false; |
| 7623 | int rc; | 7625 | int rc; |
| 7624 | 7626 | ||
| 7625 | if (!bnxt_need_reserve_rings(bp)) | 7627 | if (!bnxt_need_reserve_rings(bp)) |
| 7626 | return 0; | 7628 | return 0; |
| 7627 | 7629 | ||
| 7628 | if (BNXT_NEW_RM(bp) && (bnxt_get_num_msix(bp) != bp->total_irqs)) { | 7630 | if (irq_re_init && BNXT_NEW_RM(bp) && |
| 7631 | bnxt_get_num_msix(bp) != bp->total_irqs) { | ||
| 7629 | bnxt_ulp_irq_stop(bp); | 7632 | bnxt_ulp_irq_stop(bp); |
| 7630 | bnxt_clear_int_mode(bp); | 7633 | bnxt_clear_int_mode(bp); |
| 7631 | reinit_irq = true; | 7634 | irq_cleared = true; |
| 7632 | } | 7635 | } |
| 7633 | rc = __bnxt_reserve_rings(bp); | 7636 | rc = __bnxt_reserve_rings(bp); |
| 7634 | if (reinit_irq) { | 7637 | if (irq_cleared) { |
| 7635 | if (!rc) | 7638 | if (!rc) |
| 7636 | rc = bnxt_init_int_mode(bp); | 7639 | rc = bnxt_init_int_mode(bp); |
| 7637 | bnxt_ulp_irq_restart(bp, rc); | 7640 | bnxt_ulp_irq_restart(bp, rc); |
| @@ -8530,7 +8533,7 @@ static int __bnxt_open_nic(struct bnxt *bp, bool irq_re_init, bool link_re_init) | |||
| 8530 | return rc; | 8533 | return rc; |
| 8531 | } | 8534 | } |
| 8532 | } | 8535 | } |
| 8533 | rc = bnxt_reserve_rings(bp); | 8536 | rc = bnxt_reserve_rings(bp, irq_re_init); |
| 8534 | if (rc) | 8537 | if (rc) |
| 8535 | return rc; | 8538 | return rc; |
| 8536 | if ((bp->flags & BNXT_FLAG_RFS) && | 8539 | if ((bp->flags & BNXT_FLAG_RFS) && |
| @@ -10434,7 +10437,7 @@ static int bnxt_set_dflt_rings(struct bnxt *bp, bool sh) | |||
| 10434 | 10437 | ||
| 10435 | if (sh) | 10438 | if (sh) |
| 10436 | bp->flags |= BNXT_FLAG_SHARED_RINGS; | 10439 | bp->flags |= BNXT_FLAG_SHARED_RINGS; |
| 10437 | dflt_rings = netif_get_num_default_rss_queues(); | 10440 | dflt_rings = is_kdump_kernel() ? 1 : netif_get_num_default_rss_queues(); |
| 10438 | /* Reduce default rings on multi-port cards so that total default | 10441 | /* Reduce default rings on multi-port cards so that total default |
| 10439 | * rings do not exceed CPU count. | 10442 | * rings do not exceed CPU count. |
| 10440 | */ | 10443 | */ |
| @@ -10722,11 +10725,12 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) | |||
| 10722 | goto init_err_pci_clean; | 10725 | goto init_err_pci_clean; |
| 10723 | } | 10726 | } |
| 10724 | 10727 | ||
| 10725 | /* Read the adapter's DSN to use as the eswitch switch_id */ | 10728 | if (BNXT_PF(bp)) { |
| 10726 | rc = bnxt_pcie_dsn_get(bp, bp->switch_id); | 10729 | /* Read the adapter's DSN to use as the eswitch switch_id */ |
| 10727 | if (rc) | 10730 | rc = bnxt_pcie_dsn_get(bp, bp->switch_id); |
| 10728 | goto init_err_pci_clean; | 10731 | if (rc) |
| 10729 | 10732 | goto init_err_pci_clean; | |
| 10733 | } | ||
| 10730 | bnxt_hwrm_func_qcfg(bp); | 10734 | bnxt_hwrm_func_qcfg(bp); |
| 10731 | bnxt_hwrm_vnic_qcaps(bp); | 10735 | bnxt_hwrm_vnic_qcaps(bp); |
| 10732 | bnxt_hwrm_port_led_qcaps(bp); | 10736 | bnxt_hwrm_port_led_qcaps(bp); |
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.h b/drivers/net/ethernet/broadcom/bnxt/bnxt.h index eca36dd6b751..be438d82f939 100644 --- a/drivers/net/ethernet/broadcom/bnxt/bnxt.h +++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.h | |||
| @@ -20,6 +20,7 @@ | |||
| 20 | 20 | ||
| 21 | #include <linux/interrupt.h> | 21 | #include <linux/interrupt.h> |
| 22 | #include <linux/rhashtable.h> | 22 | #include <linux/rhashtable.h> |
| 23 | #include <linux/crash_dump.h> | ||
| 23 | #include <net/devlink.h> | 24 | #include <net/devlink.h> |
| 24 | #include <net/dst_metadata.h> | 25 | #include <net/dst_metadata.h> |
| 25 | #include <net/xdp.h> | 26 | #include <net/xdp.h> |
| @@ -1369,7 +1370,8 @@ struct bnxt { | |||
| 1369 | #define BNXT_CHIP_TYPE_NITRO_A0(bp) ((bp)->flags & BNXT_FLAG_CHIP_NITRO_A0) | 1370 | #define BNXT_CHIP_TYPE_NITRO_A0(bp) ((bp)->flags & BNXT_FLAG_CHIP_NITRO_A0) |
| 1370 | #define BNXT_RX_PAGE_MODE(bp) ((bp)->flags & BNXT_FLAG_RX_PAGE_MODE) | 1371 | #define BNXT_RX_PAGE_MODE(bp) ((bp)->flags & BNXT_FLAG_RX_PAGE_MODE) |
| 1371 | #define BNXT_SUPPORTS_TPA(bp) (!BNXT_CHIP_TYPE_NITRO_A0(bp) && \ | 1372 | #define BNXT_SUPPORTS_TPA(bp) (!BNXT_CHIP_TYPE_NITRO_A0(bp) && \ |
| 1372 | !(bp->flags & BNXT_FLAG_CHIP_P5)) | 1373 | !(bp->flags & BNXT_FLAG_CHIP_P5) && \ |
| 1374 | !is_kdump_kernel()) | ||
| 1373 | 1375 | ||
| 1374 | /* Chip class phase 5 */ | 1376 | /* Chip class phase 5 */ |
| 1375 | #define BNXT_CHIP_P5(bp) \ | 1377 | #define BNXT_CHIP_P5(bp) \ |
| @@ -1790,7 +1792,7 @@ unsigned int bnxt_get_avail_stat_ctxs_for_en(struct bnxt *bp); | |||
| 1790 | unsigned int bnxt_get_max_func_cp_rings(struct bnxt *bp); | 1792 | unsigned int bnxt_get_max_func_cp_rings(struct bnxt *bp); |
| 1791 | unsigned int bnxt_get_avail_cp_rings_for_en(struct bnxt *bp); | 1793 | unsigned int bnxt_get_avail_cp_rings_for_en(struct bnxt *bp); |
| 1792 | int bnxt_get_avail_msix(struct bnxt *bp, int num); | 1794 | int bnxt_get_avail_msix(struct bnxt *bp, int num); |
| 1793 | int bnxt_reserve_rings(struct bnxt *bp); | 1795 | int bnxt_reserve_rings(struct bnxt *bp, bool irq_re_init); |
| 1794 | void bnxt_tx_disable(struct bnxt *bp); | 1796 | void bnxt_tx_disable(struct bnxt *bp); |
| 1795 | void bnxt_tx_enable(struct bnxt *bp); | 1797 | void bnxt_tx_enable(struct bnxt *bp); |
| 1796 | int bnxt_hwrm_set_pause(struct bnxt *); | 1798 | int bnxt_hwrm_set_pause(struct bnxt *); |
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c index b1263821a6e9..a6c7baf38036 100644 --- a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c +++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c | |||
| @@ -831,7 +831,7 @@ static int bnxt_set_channels(struct net_device *dev, | |||
| 831 | */ | 831 | */ |
| 832 | } | 832 | } |
| 833 | } else { | 833 | } else { |
| 834 | rc = bnxt_reserve_rings(bp); | 834 | rc = bnxt_reserve_rings(bp, true); |
| 835 | } | 835 | } |
| 836 | 836 | ||
| 837 | return rc; | 837 | return rc; |
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_ulp.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_ulp.c index cf475873ce81..bfa342a98d08 100644 --- a/drivers/net/ethernet/broadcom/bnxt/bnxt_ulp.c +++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_ulp.c | |||
| @@ -147,7 +147,7 @@ static int bnxt_req_msix_vecs(struct bnxt_en_dev *edev, int ulp_id, | |||
| 147 | bnxt_close_nic(bp, true, false); | 147 | bnxt_close_nic(bp, true, false); |
| 148 | rc = bnxt_open_nic(bp, true, false); | 148 | rc = bnxt_open_nic(bp, true, false); |
| 149 | } else { | 149 | } else { |
| 150 | rc = bnxt_reserve_rings(bp); | 150 | rc = bnxt_reserve_rings(bp, true); |
| 151 | } | 151 | } |
| 152 | } | 152 | } |
| 153 | if (rc) { | 153 | if (rc) { |
diff --git a/drivers/net/ethernet/cadence/macb.h b/drivers/net/ethernet/cadence/macb.h index acc66a7e7b95..00ee5e8e0ff0 100644 --- a/drivers/net/ethernet/cadence/macb.h +++ b/drivers/net/ethernet/cadence/macb.h | |||
| @@ -1080,6 +1080,11 @@ struct macb_ptp_info { | |||
| 1080 | struct ifreq *ifr, int cmd); | 1080 | struct ifreq *ifr, int cmd); |
| 1081 | }; | 1081 | }; |
| 1082 | 1082 | ||
| 1083 | struct macb_pm_data { | ||
| 1084 | u32 scrt2; | ||
| 1085 | u32 usrio; | ||
| 1086 | }; | ||
| 1087 | |||
| 1083 | struct macb_config { | 1088 | struct macb_config { |
| 1084 | u32 caps; | 1089 | u32 caps; |
| 1085 | unsigned int dma_burst_length; | 1090 | unsigned int dma_burst_length; |
| @@ -1220,6 +1225,8 @@ struct macb { | |||
| 1220 | int tx_bd_rd_prefetch; | 1225 | int tx_bd_rd_prefetch; |
| 1221 | 1226 | ||
| 1222 | u32 rx_intr_mask; | 1227 | u32 rx_intr_mask; |
| 1228 | |||
| 1229 | struct macb_pm_data pm_data; | ||
| 1223 | }; | 1230 | }; |
| 1224 | 1231 | ||
| 1225 | #ifdef CONFIG_MACB_USE_HWSTAMP | 1232 | #ifdef CONFIG_MACB_USE_HWSTAMP |
diff --git a/drivers/net/ethernet/cadence/macb_main.c b/drivers/net/ethernet/cadence/macb_main.c index bebd9b1aeb64..f825e3960540 100644 --- a/drivers/net/ethernet/cadence/macb_main.c +++ b/drivers/net/ethernet/cadence/macb_main.c | |||
| @@ -2849,10 +2849,14 @@ static int macb_get_ts_info(struct net_device *netdev, | |||
| 2849 | 2849 | ||
| 2850 | static void gem_enable_flow_filters(struct macb *bp, bool enable) | 2850 | static void gem_enable_flow_filters(struct macb *bp, bool enable) |
| 2851 | { | 2851 | { |
| 2852 | struct net_device *netdev = bp->dev; | ||
| 2852 | struct ethtool_rx_fs_item *item; | 2853 | struct ethtool_rx_fs_item *item; |
| 2853 | u32 t2_scr; | 2854 | u32 t2_scr; |
| 2854 | int num_t2_scr; | 2855 | int num_t2_scr; |
| 2855 | 2856 | ||
| 2857 | if (!(netdev->features & NETIF_F_NTUPLE)) | ||
| 2858 | return; | ||
| 2859 | |||
| 2856 | num_t2_scr = GEM_BFEXT(T2SCR, gem_readl(bp, DCFG8)); | 2860 | num_t2_scr = GEM_BFEXT(T2SCR, gem_readl(bp, DCFG8)); |
| 2857 | 2861 | ||
| 2858 | list_for_each_entry(item, &bp->rx_fs_list.list, list) { | 2862 | list_for_each_entry(item, &bp->rx_fs_list.list, list) { |
| @@ -3012,8 +3016,7 @@ static int gem_add_flow_filter(struct net_device *netdev, | |||
| 3012 | gem_prog_cmp_regs(bp, fs); | 3016 | gem_prog_cmp_regs(bp, fs); |
| 3013 | bp->rx_fs_list.count++; | 3017 | bp->rx_fs_list.count++; |
| 3014 | /* enable filtering if NTUPLE on */ | 3018 | /* enable filtering if NTUPLE on */ |
| 3015 | if (netdev->features & NETIF_F_NTUPLE) | 3019 | gem_enable_flow_filters(bp, 1); |
| 3016 | gem_enable_flow_filters(bp, 1); | ||
| 3017 | 3020 | ||
| 3018 | spin_unlock_irqrestore(&bp->rx_fs_lock, flags); | 3021 | spin_unlock_irqrestore(&bp->rx_fs_lock, flags); |
| 3019 | return 0; | 3022 | return 0; |
| @@ -3201,6 +3204,50 @@ static int macb_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) | |||
| 3201 | } | 3204 | } |
| 3202 | } | 3205 | } |
| 3203 | 3206 | ||
| 3207 | static inline void macb_set_txcsum_feature(struct macb *bp, | ||
| 3208 | netdev_features_t features) | ||
| 3209 | { | ||
| 3210 | u32 val; | ||
| 3211 | |||
| 3212 | if (!macb_is_gem(bp)) | ||
| 3213 | return; | ||
| 3214 | |||
| 3215 | val = gem_readl(bp, DMACFG); | ||
| 3216 | if (features & NETIF_F_HW_CSUM) | ||
| 3217 | val |= GEM_BIT(TXCOEN); | ||
| 3218 | else | ||
| 3219 | val &= ~GEM_BIT(TXCOEN); | ||
| 3220 | |||
| 3221 | gem_writel(bp, DMACFG, val); | ||
| 3222 | } | ||
| 3223 | |||
| 3224 | static inline void macb_set_rxcsum_feature(struct macb *bp, | ||
| 3225 | netdev_features_t features) | ||
| 3226 | { | ||
| 3227 | struct net_device *netdev = bp->dev; | ||
| 3228 | u32 val; | ||
| 3229 | |||
| 3230 | if (!macb_is_gem(bp)) | ||
| 3231 | return; | ||
| 3232 | |||
| 3233 | val = gem_readl(bp, NCFGR); | ||
| 3234 | if ((features & NETIF_F_RXCSUM) && !(netdev->flags & IFF_PROMISC)) | ||
| 3235 | val |= GEM_BIT(RXCOEN); | ||
| 3236 | else | ||
| 3237 | val &= ~GEM_BIT(RXCOEN); | ||
| 3238 | |||
| 3239 | gem_writel(bp, NCFGR, val); | ||
| 3240 | } | ||
| 3241 | |||
| 3242 | static inline void macb_set_rxflow_feature(struct macb *bp, | ||
| 3243 | netdev_features_t features) | ||
| 3244 | { | ||
| 3245 | if (!macb_is_gem(bp)) | ||
| 3246 | return; | ||
| 3247 | |||
| 3248 | gem_enable_flow_filters(bp, !!(features & NETIF_F_NTUPLE)); | ||
| 3249 | } | ||
| 3250 | |||
| 3204 | static int macb_set_features(struct net_device *netdev, | 3251 | static int macb_set_features(struct net_device *netdev, |
| 3205 | netdev_features_t features) | 3252 | netdev_features_t features) |
| 3206 | { | 3253 | { |
| @@ -3208,39 +3255,35 @@ static int macb_set_features(struct net_device *netdev, | |||
| 3208 | netdev_features_t changed = features ^ netdev->features; | 3255 | netdev_features_t changed = features ^ netdev->features; |
| 3209 | 3256 | ||
| 3210 | /* TX checksum offload */ | 3257 | /* TX checksum offload */ |
| 3211 | if ((changed & NETIF_F_HW_CSUM) && macb_is_gem(bp)) { | 3258 | if (changed & NETIF_F_HW_CSUM) |
| 3212 | u32 dmacfg; | 3259 | macb_set_txcsum_feature(bp, features); |
| 3213 | |||
| 3214 | dmacfg = gem_readl(bp, DMACFG); | ||
| 3215 | if (features & NETIF_F_HW_CSUM) | ||
| 3216 | dmacfg |= GEM_BIT(TXCOEN); | ||
| 3217 | else | ||
| 3218 | dmacfg &= ~GEM_BIT(TXCOEN); | ||
| 3219 | gem_writel(bp, DMACFG, dmacfg); | ||
| 3220 | } | ||
| 3221 | 3260 | ||
| 3222 | /* RX checksum offload */ | 3261 | /* RX checksum offload */ |
| 3223 | if ((changed & NETIF_F_RXCSUM) && macb_is_gem(bp)) { | 3262 | if (changed & NETIF_F_RXCSUM) |
| 3224 | u32 netcfg; | 3263 | macb_set_rxcsum_feature(bp, features); |
| 3225 | |||
| 3226 | netcfg = gem_readl(bp, NCFGR); | ||
| 3227 | if (features & NETIF_F_RXCSUM && | ||
| 3228 | !(netdev->flags & IFF_PROMISC)) | ||
| 3229 | netcfg |= GEM_BIT(RXCOEN); | ||
| 3230 | else | ||
| 3231 | netcfg &= ~GEM_BIT(RXCOEN); | ||
| 3232 | gem_writel(bp, NCFGR, netcfg); | ||
| 3233 | } | ||
| 3234 | 3264 | ||
| 3235 | /* RX Flow Filters */ | 3265 | /* RX Flow Filters */ |
| 3236 | if ((changed & NETIF_F_NTUPLE) && macb_is_gem(bp)) { | 3266 | if (changed & NETIF_F_NTUPLE) |
| 3237 | bool turn_on = features & NETIF_F_NTUPLE; | 3267 | macb_set_rxflow_feature(bp, features); |
| 3238 | 3268 | ||
| 3239 | gem_enable_flow_filters(bp, turn_on); | ||
| 3240 | } | ||
| 3241 | return 0; | 3269 | return 0; |
| 3242 | } | 3270 | } |
| 3243 | 3271 | ||
| 3272 | static void macb_restore_features(struct macb *bp) | ||
| 3273 | { | ||
| 3274 | struct net_device *netdev = bp->dev; | ||
| 3275 | netdev_features_t features = netdev->features; | ||
| 3276 | |||
| 3277 | /* TX checksum offload */ | ||
| 3278 | macb_set_txcsum_feature(bp, features); | ||
| 3279 | |||
| 3280 | /* RX checksum offload */ | ||
| 3281 | macb_set_rxcsum_feature(bp, features); | ||
| 3282 | |||
| 3283 | /* RX Flow Filters */ | ||
| 3284 | macb_set_rxflow_feature(bp, features); | ||
| 3285 | } | ||
| 3286 | |||
| 3244 | static const struct net_device_ops macb_netdev_ops = { | 3287 | static const struct net_device_ops macb_netdev_ops = { |
| 3245 | .ndo_open = macb_open, | 3288 | .ndo_open = macb_open, |
| 3246 | .ndo_stop = macb_close, | 3289 | .ndo_stop = macb_close, |
| @@ -4273,6 +4316,12 @@ static int __maybe_unused macb_suspend(struct device *dev) | |||
| 4273 | spin_lock_irqsave(&bp->lock, flags); | 4316 | spin_lock_irqsave(&bp->lock, flags); |
| 4274 | macb_reset_hw(bp); | 4317 | macb_reset_hw(bp); |
| 4275 | spin_unlock_irqrestore(&bp->lock, flags); | 4318 | spin_unlock_irqrestore(&bp->lock, flags); |
| 4319 | |||
| 4320 | if (!(bp->caps & MACB_CAPS_USRIO_DISABLED)) | ||
| 4321 | bp->pm_data.usrio = macb_or_gem_readl(bp, USRIO); | ||
| 4322 | |||
| 4323 | if (netdev->hw_features & NETIF_F_NTUPLE) | ||
| 4324 | bp->pm_data.scrt2 = gem_readl_n(bp, ETHT, SCRT2_ETHT); | ||
| 4276 | } | 4325 | } |
| 4277 | 4326 | ||
| 4278 | netif_carrier_off(netdev); | 4327 | netif_carrier_off(netdev); |
| @@ -4301,6 +4350,13 @@ static int __maybe_unused macb_resume(struct device *dev) | |||
| 4301 | disable_irq_wake(bp->queues[0].irq); | 4350 | disable_irq_wake(bp->queues[0].irq); |
| 4302 | } else { | 4351 | } else { |
| 4303 | macb_writel(bp, NCR, MACB_BIT(MPE)); | 4352 | macb_writel(bp, NCR, MACB_BIT(MPE)); |
| 4353 | |||
| 4354 | if (netdev->hw_features & NETIF_F_NTUPLE) | ||
| 4355 | gem_writel_n(bp, ETHT, SCRT2_ETHT, bp->pm_data.scrt2); | ||
| 4356 | |||
| 4357 | if (!(bp->caps & MACB_CAPS_USRIO_DISABLED)) | ||
| 4358 | macb_or_gem_writel(bp, USRIO, bp->pm_data.usrio); | ||
| 4359 | |||
| 4304 | for (q = 0, queue = bp->queues; q < bp->num_queues; | 4360 | for (q = 0, queue = bp->queues; q < bp->num_queues; |
| 4305 | ++q, ++queue) | 4361 | ++q, ++queue) |
| 4306 | napi_enable(&queue->napi); | 4362 | napi_enable(&queue->napi); |
| @@ -4312,6 +4368,7 @@ static int __maybe_unused macb_resume(struct device *dev) | |||
| 4312 | bp->macbgem_ops.mog_init_rings(bp); | 4368 | bp->macbgem_ops.mog_init_rings(bp); |
| 4313 | macb_init_hw(bp); | 4369 | macb_init_hw(bp); |
| 4314 | macb_set_rx_mode(netdev); | 4370 | macb_set_rx_mode(netdev); |
| 4371 | macb_restore_features(bp); | ||
| 4315 | netif_device_attach(netdev); | 4372 | netif_device_attach(netdev); |
| 4316 | if (bp->ptp_info) | 4373 | if (bp->ptp_info) |
| 4317 | bp->ptp_info->ptp_init(netdev); | 4374 | bp->ptp_info->ptp_init(netdev); |
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c index 6e2d80008a79..cfaf8f618d1f 100644 --- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c +++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c | |||
| @@ -197,6 +197,9 @@ static void cxgb4_process_flow_match(struct net_device *dev, | |||
| 197 | fs->val.ivlan = vlan_tci; | 197 | fs->val.ivlan = vlan_tci; |
| 198 | fs->mask.ivlan = vlan_tci_mask; | 198 | fs->mask.ivlan = vlan_tci_mask; |
| 199 | 199 | ||
| 200 | fs->val.ivlan_vld = 1; | ||
| 201 | fs->mask.ivlan_vld = 1; | ||
| 202 | |||
| 200 | /* Chelsio adapters use ivlan_vld bit to match vlan packets | 203 | /* Chelsio adapters use ivlan_vld bit to match vlan packets |
| 201 | * as 802.1Q. Also, when vlan tag is present in packets, | 204 | * as 802.1Q. Also, when vlan tag is present in packets, |
| 202 | * ethtype match is used then to match on ethtype of inner | 205 | * ethtype match is used then to match on ethtype of inner |
| @@ -207,8 +210,6 @@ static void cxgb4_process_flow_match(struct net_device *dev, | |||
| 207 | * ethtype value with ethtype of inner header. | 210 | * ethtype value with ethtype of inner header. |
| 208 | */ | 211 | */ |
| 209 | if (fs->val.ethtype == ETH_P_8021Q) { | 212 | if (fs->val.ethtype == ETH_P_8021Q) { |
| 210 | fs->val.ivlan_vld = 1; | ||
| 211 | fs->mask.ivlan_vld = 1; | ||
| 212 | fs->val.ethtype = 0; | 213 | fs->val.ethtype = 0; |
| 213 | fs->mask.ethtype = 0; | 214 | fs->mask.ethtype = 0; |
| 214 | } | 215 | } |
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c index f9b70be59792..93feb258067b 100644 --- a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c +++ b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c | |||
| @@ -7253,10 +7253,21 @@ int t4_fixup_host_params(struct adapter *adap, unsigned int page_size, | |||
| 7253 | unsigned int cache_line_size) | 7253 | unsigned int cache_line_size) |
| 7254 | { | 7254 | { |
| 7255 | unsigned int page_shift = fls(page_size) - 1; | 7255 | unsigned int page_shift = fls(page_size) - 1; |
| 7256 | unsigned int sge_hps = page_shift - 10; | ||
| 7256 | unsigned int stat_len = cache_line_size > 64 ? 128 : 64; | 7257 | unsigned int stat_len = cache_line_size > 64 ? 128 : 64; |
| 7257 | unsigned int fl_align = cache_line_size < 32 ? 32 : cache_line_size; | 7258 | unsigned int fl_align = cache_line_size < 32 ? 32 : cache_line_size; |
| 7258 | unsigned int fl_align_log = fls(fl_align) - 1; | 7259 | unsigned int fl_align_log = fls(fl_align) - 1; |
| 7259 | 7260 | ||
| 7261 | t4_write_reg(adap, SGE_HOST_PAGE_SIZE_A, | ||
| 7262 | HOSTPAGESIZEPF0_V(sge_hps) | | ||
| 7263 | HOSTPAGESIZEPF1_V(sge_hps) | | ||
| 7264 | HOSTPAGESIZEPF2_V(sge_hps) | | ||
| 7265 | HOSTPAGESIZEPF3_V(sge_hps) | | ||
| 7266 | HOSTPAGESIZEPF4_V(sge_hps) | | ||
| 7267 | HOSTPAGESIZEPF5_V(sge_hps) | | ||
| 7268 | HOSTPAGESIZEPF6_V(sge_hps) | | ||
| 7269 | HOSTPAGESIZEPF7_V(sge_hps)); | ||
| 7270 | |||
| 7260 | if (is_t4(adap->params.chip)) { | 7271 | if (is_t4(adap->params.chip)) { |
| 7261 | t4_set_reg_field(adap, SGE_CONTROL_A, | 7272 | t4_set_reg_field(adap, SGE_CONTROL_A, |
| 7262 | INGPADBOUNDARY_V(INGPADBOUNDARY_M) | | 7273 | INGPADBOUNDARY_V(INGPADBOUNDARY_M) | |
diff --git a/drivers/net/ethernet/dec/tulip/de4x5.c b/drivers/net/ethernet/dec/tulip/de4x5.c index 66535d1653f6..f16853c3c851 100644 --- a/drivers/net/ethernet/dec/tulip/de4x5.c +++ b/drivers/net/ethernet/dec/tulip/de4x5.c | |||
| @@ -2107,7 +2107,6 @@ static struct eisa_driver de4x5_eisa_driver = { | |||
| 2107 | .remove = de4x5_eisa_remove, | 2107 | .remove = de4x5_eisa_remove, |
| 2108 | } | 2108 | } |
| 2109 | }; | 2109 | }; |
| 2110 | MODULE_DEVICE_TABLE(eisa, de4x5_eisa_ids); | ||
| 2111 | #endif | 2110 | #endif |
| 2112 | 2111 | ||
| 2113 | #ifdef CONFIG_PCI | 2112 | #ifdef CONFIG_PCI |
diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c index d3f2408dc9e8..f38c3fa7d705 100644 --- a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c +++ b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c | |||
| @@ -780,7 +780,7 @@ static void dpaa_eth_add_channel(u16 channel) | |||
| 780 | struct qman_portal *portal; | 780 | struct qman_portal *portal; |
| 781 | int cpu; | 781 | int cpu; |
| 782 | 782 | ||
| 783 | for_each_cpu(cpu, cpus) { | 783 | for_each_cpu_and(cpu, cpus, cpu_online_mask) { |
| 784 | portal = qman_get_affine_portal(cpu); | 784 | portal = qman_get_affine_portal(cpu); |
| 785 | qman_p_static_dequeue_add(portal, pool); | 785 | qman_p_static_dequeue_add(portal, pool); |
| 786 | } | 786 | } |
| @@ -896,7 +896,7 @@ static void dpaa_fq_setup(struct dpaa_priv *priv, | |||
| 896 | u16 channels[NR_CPUS]; | 896 | u16 channels[NR_CPUS]; |
| 897 | struct dpaa_fq *fq; | 897 | struct dpaa_fq *fq; |
| 898 | 898 | ||
| 899 | for_each_cpu(cpu, affine_cpus) | 899 | for_each_cpu_and(cpu, affine_cpus, cpu_online_mask) |
| 900 | channels[num_portals++] = qman_affine_channel(cpu); | 900 | channels[num_portals++] = qman_affine_channel(cpu); |
| 901 | 901 | ||
| 902 | if (num_portals == 0) | 902 | if (num_portals == 0) |
| @@ -2174,7 +2174,6 @@ static int dpaa_eth_poll(struct napi_struct *napi, int budget) | |||
| 2174 | if (cleaned < budget) { | 2174 | if (cleaned < budget) { |
| 2175 | napi_complete_done(napi, cleaned); | 2175 | napi_complete_done(napi, cleaned); |
| 2176 | qman_p_irqsource_add(np->p, QM_PIRQ_DQRI); | 2176 | qman_p_irqsource_add(np->p, QM_PIRQ_DQRI); |
| 2177 | |||
| 2178 | } else if (np->down) { | 2177 | } else if (np->down) { |
| 2179 | qman_p_irqsource_add(np->p, QM_PIRQ_DQRI); | 2178 | qman_p_irqsource_add(np->p, QM_PIRQ_DQRI); |
| 2180 | } | 2179 | } |
| @@ -2448,7 +2447,7 @@ static void dpaa_eth_napi_enable(struct dpaa_priv *priv) | |||
| 2448 | struct dpaa_percpu_priv *percpu_priv; | 2447 | struct dpaa_percpu_priv *percpu_priv; |
| 2449 | int i; | 2448 | int i; |
| 2450 | 2449 | ||
| 2451 | for_each_possible_cpu(i) { | 2450 | for_each_online_cpu(i) { |
| 2452 | percpu_priv = per_cpu_ptr(priv->percpu_priv, i); | 2451 | percpu_priv = per_cpu_ptr(priv->percpu_priv, i); |
| 2453 | 2452 | ||
| 2454 | percpu_priv->np.down = 0; | 2453 | percpu_priv->np.down = 0; |
| @@ -2461,7 +2460,7 @@ static void dpaa_eth_napi_disable(struct dpaa_priv *priv) | |||
| 2461 | struct dpaa_percpu_priv *percpu_priv; | 2460 | struct dpaa_percpu_priv *percpu_priv; |
| 2462 | int i; | 2461 | int i; |
| 2463 | 2462 | ||
| 2464 | for_each_possible_cpu(i) { | 2463 | for_each_online_cpu(i) { |
| 2465 | percpu_priv = per_cpu_ptr(priv->percpu_priv, i); | 2464 | percpu_priv = per_cpu_ptr(priv->percpu_priv, i); |
| 2466 | 2465 | ||
| 2467 | percpu_priv->np.down = 1; | 2466 | percpu_priv->np.down = 1; |
diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c b/drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c index bdee441bc3b7..7ce2e99b594d 100644 --- a/drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c +++ b/drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c | |||
| @@ -569,7 +569,7 @@ static int dpaa_set_coalesce(struct net_device *dev, | |||
| 569 | qman_dqrr_get_ithresh(portal, &prev_thresh); | 569 | qman_dqrr_get_ithresh(portal, &prev_thresh); |
| 570 | 570 | ||
| 571 | /* set new values */ | 571 | /* set new values */ |
| 572 | for_each_cpu(cpu, cpus) { | 572 | for_each_cpu_and(cpu, cpus, cpu_online_mask) { |
| 573 | portal = qman_get_affine_portal(cpu); | 573 | portal = qman_get_affine_portal(cpu); |
| 574 | res = qman_portal_set_iperiod(portal, period); | 574 | res = qman_portal_set_iperiod(portal, period); |
| 575 | if (res) | 575 | if (res) |
| @@ -586,7 +586,7 @@ static int dpaa_set_coalesce(struct net_device *dev, | |||
| 586 | 586 | ||
| 587 | revert_values: | 587 | revert_values: |
| 588 | /* restore previous values */ | 588 | /* restore previous values */ |
| 589 | for_each_cpu(cpu, cpus) { | 589 | for_each_cpu_and(cpu, cpus, cpu_online_mask) { |
| 590 | if (!needs_revert[cpu]) | 590 | if (!needs_revert[cpu]) |
| 591 | continue; | 591 | continue; |
| 592 | portal = qman_get_affine_portal(cpu); | 592 | portal = qman_get_affine_portal(cpu); |
diff --git a/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c b/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c index 63b1ecc18c26..7d2390e3df77 100644 --- a/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c +++ b/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c | |||
| @@ -1972,7 +1972,7 @@ alloc_channel(struct dpaa2_eth_priv *priv) | |||
| 1972 | 1972 | ||
| 1973 | channel->dpcon = setup_dpcon(priv); | 1973 | channel->dpcon = setup_dpcon(priv); |
| 1974 | if (IS_ERR_OR_NULL(channel->dpcon)) { | 1974 | if (IS_ERR_OR_NULL(channel->dpcon)) { |
| 1975 | err = PTR_ERR(channel->dpcon); | 1975 | err = PTR_ERR_OR_ZERO(channel->dpcon); |
| 1976 | goto err_setup; | 1976 | goto err_setup; |
| 1977 | } | 1977 | } |
| 1978 | 1978 | ||
| @@ -2028,7 +2028,7 @@ static int setup_dpio(struct dpaa2_eth_priv *priv) | |||
| 2028 | /* Try to allocate a channel */ | 2028 | /* Try to allocate a channel */ |
| 2029 | channel = alloc_channel(priv); | 2029 | channel = alloc_channel(priv); |
| 2030 | if (IS_ERR_OR_NULL(channel)) { | 2030 | if (IS_ERR_OR_NULL(channel)) { |
| 2031 | err = PTR_ERR(channel); | 2031 | err = PTR_ERR_OR_ZERO(channel); |
| 2032 | if (err != -EPROBE_DEFER) | 2032 | if (err != -EPROBE_DEFER) |
| 2033 | dev_info(dev, | 2033 | dev_info(dev, |
| 2034 | "No affine channel for cpu %d and above\n", i); | 2034 | "No affine channel for cpu %d and above\n", i); |
diff --git a/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.h b/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.h index 5fb8f5c0dc9f..e180d5a68c98 100644 --- a/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.h +++ b/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.h | |||
| @@ -467,7 +467,7 @@ enum dpaa2_eth_rx_dist { | |||
| 467 | #define DPAA2_ETH_DIST_IPPROTO BIT(6) | 467 | #define DPAA2_ETH_DIST_IPPROTO BIT(6) |
| 468 | #define DPAA2_ETH_DIST_L4SRC BIT(7) | 468 | #define DPAA2_ETH_DIST_L4SRC BIT(7) |
| 469 | #define DPAA2_ETH_DIST_L4DST BIT(8) | 469 | #define DPAA2_ETH_DIST_L4DST BIT(8) |
| 470 | #define DPAA2_ETH_DIST_ALL (~0U) | 470 | #define DPAA2_ETH_DIST_ALL (~0ULL) |
| 471 | 471 | ||
| 472 | static inline | 472 | static inline |
| 473 | unsigned int dpaa2_eth_needed_headroom(struct dpaa2_eth_priv *priv, | 473 | unsigned int dpaa2_eth_needed_headroom(struct dpaa2_eth_priv *priv, |
diff --git a/drivers/net/ethernet/freescale/dpaa2/dpaa2-ethtool.c b/drivers/net/ethernet/freescale/dpaa2/dpaa2-ethtool.c index 76bd8d2872cc..7b182f4b263c 100644 --- a/drivers/net/ethernet/freescale/dpaa2/dpaa2-ethtool.c +++ b/drivers/net/ethernet/freescale/dpaa2/dpaa2-ethtool.c | |||
| @@ -4,6 +4,7 @@ | |||
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| 6 | #include <linux/net_tstamp.h> | 6 | #include <linux/net_tstamp.h> |
| 7 | #include <linux/nospec.h> | ||
| 7 | 8 | ||
| 8 | #include "dpni.h" /* DPNI_LINK_OPT_* */ | 9 | #include "dpni.h" /* DPNI_LINK_OPT_* */ |
| 9 | #include "dpaa2-eth.h" | 10 | #include "dpaa2-eth.h" |
| @@ -648,6 +649,8 @@ static int dpaa2_eth_get_rxnfc(struct net_device *net_dev, | |||
| 648 | case ETHTOOL_GRXCLSRULE: | 649 | case ETHTOOL_GRXCLSRULE: |
| 649 | if (rxnfc->fs.location >= max_rules) | 650 | if (rxnfc->fs.location >= max_rules) |
| 650 | return -EINVAL; | 651 | return -EINVAL; |
| 652 | rxnfc->fs.location = array_index_nospec(rxnfc->fs.location, | ||
| 653 | max_rules); | ||
| 651 | if (!priv->cls_rules[rxnfc->fs.location].in_use) | 654 | if (!priv->cls_rules[rxnfc->fs.location].in_use) |
| 652 | return -EINVAL; | 655 | return -EINVAL; |
| 653 | rxnfc->fs = priv->cls_rules[rxnfc->fs.location].fs; | 656 | rxnfc->fs = priv->cls_rules[rxnfc->fs.location].fs; |
diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c index aa7d4e27c5d1..38f10f7dcbc3 100644 --- a/drivers/net/ethernet/freescale/fec_main.c +++ b/drivers/net/ethernet/freescale/fec_main.c | |||
| @@ -3556,7 +3556,7 @@ failed_init: | |||
| 3556 | if (fep->reg_phy) | 3556 | if (fep->reg_phy) |
| 3557 | regulator_disable(fep->reg_phy); | 3557 | regulator_disable(fep->reg_phy); |
| 3558 | failed_reset: | 3558 | failed_reset: |
| 3559 | pm_runtime_put(&pdev->dev); | 3559 | pm_runtime_put_noidle(&pdev->dev); |
| 3560 | pm_runtime_disable(&pdev->dev); | 3560 | pm_runtime_disable(&pdev->dev); |
| 3561 | failed_regulator: | 3561 | failed_regulator: |
| 3562 | clk_disable_unprepare(fep->clk_ahb); | 3562 | clk_disable_unprepare(fep->clk_ahb); |
diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c index e758650b2c26..269bd73be1a0 100644 --- a/drivers/net/ethernet/marvell/mvneta.c +++ b/drivers/net/ethernet/marvell/mvneta.c | |||
| @@ -4674,7 +4674,7 @@ static int mvneta_probe(struct platform_device *pdev) | |||
| 4674 | err = register_netdev(dev); | 4674 | err = register_netdev(dev); |
| 4675 | if (err < 0) { | 4675 | if (err < 0) { |
| 4676 | dev_err(&pdev->dev, "failed to register\n"); | 4676 | dev_err(&pdev->dev, "failed to register\n"); |
| 4677 | goto err_free_stats; | 4677 | goto err_netdev; |
| 4678 | } | 4678 | } |
| 4679 | 4679 | ||
| 4680 | netdev_info(dev, "Using %s mac address %pM\n", mac_from, | 4680 | netdev_info(dev, "Using %s mac address %pM\n", mac_from, |
| @@ -4685,14 +4685,12 @@ static int mvneta_probe(struct platform_device *pdev) | |||
| 4685 | return 0; | 4685 | return 0; |
| 4686 | 4686 | ||
| 4687 | err_netdev: | 4687 | err_netdev: |
| 4688 | unregister_netdev(dev); | ||
| 4689 | if (pp->bm_priv) { | 4688 | if (pp->bm_priv) { |
| 4690 | mvneta_bm_pool_destroy(pp->bm_priv, pp->pool_long, 1 << pp->id); | 4689 | mvneta_bm_pool_destroy(pp->bm_priv, pp->pool_long, 1 << pp->id); |
| 4691 | mvneta_bm_pool_destroy(pp->bm_priv, pp->pool_short, | 4690 | mvneta_bm_pool_destroy(pp->bm_priv, pp->pool_short, |
| 4692 | 1 << pp->id); | 4691 | 1 << pp->id); |
| 4693 | mvneta_bm_put(pp->bm_priv); | 4692 | mvneta_bm_put(pp->bm_priv); |
| 4694 | } | 4693 | } |
| 4695 | err_free_stats: | ||
| 4696 | free_percpu(pp->stats); | 4694 | free_percpu(pp->stats); |
| 4697 | err_free_ports: | 4695 | err_free_ports: |
| 4698 | free_percpu(pp->ports); | 4696 | free_percpu(pp->ports); |
diff --git a/drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c b/drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c index d046f7a1dcf5..a57d17ab91f0 100644 --- a/drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c +++ b/drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c | |||
| @@ -1271,6 +1271,9 @@ int mvpp2_ethtool_cls_rule_ins(struct mvpp2_port *port, | |||
| 1271 | if (ret) | 1271 | if (ret) |
| 1272 | goto clean_eth_rule; | 1272 | goto clean_eth_rule; |
| 1273 | 1273 | ||
| 1274 | ethtool_rx_flow_rule_destroy(ethtool_rule); | ||
| 1275 | efs->rule.flow = NULL; | ||
| 1276 | |||
| 1274 | memcpy(&efs->rxnfc, info, sizeof(*info)); | 1277 | memcpy(&efs->rxnfc, info, sizeof(*info)); |
| 1275 | port->rfs_rules[efs->rule.loc] = efs; | 1278 | port->rfs_rules[efs->rule.loc] = efs; |
| 1276 | port->n_rfs_rules++; | 1279 | port->n_rfs_rules++; |
diff --git a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c index d38952eb7aa9..7a67e23a2c2b 100644 --- a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c +++ b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c | |||
| @@ -1455,7 +1455,7 @@ static inline void mvpp2_xlg_max_rx_size_set(struct mvpp2_port *port) | |||
| 1455 | /* Set defaults to the MVPP2 port */ | 1455 | /* Set defaults to the MVPP2 port */ |
| 1456 | static void mvpp2_defaults_set(struct mvpp2_port *port) | 1456 | static void mvpp2_defaults_set(struct mvpp2_port *port) |
| 1457 | { | 1457 | { |
| 1458 | int tx_port_num, val, queue, ptxq, lrxq; | 1458 | int tx_port_num, val, queue, lrxq; |
| 1459 | 1459 | ||
| 1460 | if (port->priv->hw_version == MVPP21) { | 1460 | if (port->priv->hw_version == MVPP21) { |
| 1461 | /* Update TX FIFO MIN Threshold */ | 1461 | /* Update TX FIFO MIN Threshold */ |
| @@ -1476,11 +1476,9 @@ static void mvpp2_defaults_set(struct mvpp2_port *port) | |||
| 1476 | mvpp2_write(port->priv, MVPP2_TXP_SCHED_FIXED_PRIO_REG, 0); | 1476 | mvpp2_write(port->priv, MVPP2_TXP_SCHED_FIXED_PRIO_REG, 0); |
| 1477 | 1477 | ||
| 1478 | /* Close bandwidth for all queues */ | 1478 | /* Close bandwidth for all queues */ |
| 1479 | for (queue = 0; queue < MVPP2_MAX_TXQ; queue++) { | 1479 | for (queue = 0; queue < MVPP2_MAX_TXQ; queue++) |
| 1480 | ptxq = mvpp2_txq_phys(port->id, queue); | ||
| 1481 | mvpp2_write(port->priv, | 1480 | mvpp2_write(port->priv, |
| 1482 | MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(ptxq), 0); | 1481 | MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(queue), 0); |
| 1483 | } | ||
| 1484 | 1482 | ||
| 1485 | /* Set refill period to 1 usec, refill tokens | 1483 | /* Set refill period to 1 usec, refill tokens |
| 1486 | * and bucket size to maximum | 1484 | * and bucket size to maximum |
| @@ -2336,7 +2334,7 @@ static void mvpp2_txq_deinit(struct mvpp2_port *port, | |||
| 2336 | txq->descs_dma = 0; | 2334 | txq->descs_dma = 0; |
| 2337 | 2335 | ||
| 2338 | /* Set minimum bandwidth for disabled TXQs */ | 2336 | /* Set minimum bandwidth for disabled TXQs */ |
| 2339 | mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(txq->id), 0); | 2337 | mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(txq->log_id), 0); |
| 2340 | 2338 | ||
| 2341 | /* Set Tx descriptors queue starting address and size */ | 2339 | /* Set Tx descriptors queue starting address and size */ |
| 2342 | thread = mvpp2_cpu_to_thread(port->priv, get_cpu()); | 2340 | thread = mvpp2_cpu_to_thread(port->priv, get_cpu()); |
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c index 457cc39423f2..c65cefd84eda 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c | |||
| @@ -3687,6 +3687,12 @@ static netdev_features_t mlx5e_fix_features(struct net_device *netdev, | |||
| 3687 | netdev_warn(netdev, "Disabling LRO, not supported in legacy RQ\n"); | 3687 | netdev_warn(netdev, "Disabling LRO, not supported in legacy RQ\n"); |
| 3688 | } | 3688 | } |
| 3689 | 3689 | ||
| 3690 | if (MLX5E_GET_PFLAG(params, MLX5E_PFLAG_RX_CQE_COMPRESS)) { | ||
| 3691 | features &= ~NETIF_F_RXHASH; | ||
| 3692 | if (netdev->features & NETIF_F_RXHASH) | ||
| 3693 | netdev_warn(netdev, "Disabling rxhash, not supported when CQE compress is active\n"); | ||
| 3694 | } | ||
| 3695 | |||
| 3690 | mutex_unlock(&priv->state_lock); | 3696 | mutex_unlock(&priv->state_lock); |
| 3691 | 3697 | ||
| 3692 | return features; | 3698 | return features; |
| @@ -3812,6 +3818,9 @@ int mlx5e_hwstamp_set(struct mlx5e_priv *priv, struct ifreq *ifr) | |||
| 3812 | memcpy(&priv->tstamp, &config, sizeof(config)); | 3818 | memcpy(&priv->tstamp, &config, sizeof(config)); |
| 3813 | mutex_unlock(&priv->state_lock); | 3819 | mutex_unlock(&priv->state_lock); |
| 3814 | 3820 | ||
| 3821 | /* might need to fix some features */ | ||
| 3822 | netdev_update_features(priv->netdev); | ||
| 3823 | |||
| 3815 | return copy_to_user(ifr->ifr_data, &config, | 3824 | return copy_to_user(ifr->ifr_data, &config, |
| 3816 | sizeof(config)) ? -EFAULT : 0; | 3825 | sizeof(config)) ? -EFAULT : 0; |
| 3817 | } | 3826 | } |
| @@ -4680,6 +4689,10 @@ static void mlx5e_build_nic_netdev(struct net_device *netdev) | |||
| 4680 | if (!priv->channels.params.scatter_fcs_en) | 4689 | if (!priv->channels.params.scatter_fcs_en) |
| 4681 | netdev->features &= ~NETIF_F_RXFCS; | 4690 | netdev->features &= ~NETIF_F_RXFCS; |
| 4682 | 4691 | ||
| 4692 | /* prefere CQE compression over rxhash */ | ||
| 4693 | if (MLX5E_GET_PFLAG(&priv->channels.params, MLX5E_PFLAG_RX_CQE_COMPRESS)) | ||
| 4694 | netdev->features &= ~NETIF_F_RXHASH; | ||
| 4695 | |||
| 4683 | #define FT_CAP(f) MLX5_CAP_FLOWTABLE(mdev, flow_table_properties_nic_receive.f) | 4696 | #define FT_CAP(f) MLX5_CAP_FLOWTABLE(mdev, flow_table_properties_nic_receive.f) |
| 4684 | if (FT_CAP(flow_modify_en) && | 4697 | if (FT_CAP(flow_modify_en) && |
| 4685 | FT_CAP(modify_root) && | 4698 | FT_CAP(modify_root) && |
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c index 5283e16c69e4..9aea9c5b2ce8 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c | |||
| @@ -813,7 +813,7 @@ static int mlx5e_nic_rep_netdevice_event(struct notifier_block *nb, | |||
| 813 | struct net_device *netdev = netdev_notifier_info_to_dev(ptr); | 813 | struct net_device *netdev = netdev_notifier_info_to_dev(ptr); |
| 814 | 814 | ||
| 815 | if (!mlx5e_tc_tun_device_to_offload(priv, netdev) && | 815 | if (!mlx5e_tc_tun_device_to_offload(priv, netdev) && |
| 816 | !is_vlan_dev(netdev)) | 816 | !(is_vlan_dev(netdev) && vlan_dev_real_dev(netdev) == rpriv->netdev)) |
| 817 | return NOTIFY_OK; | 817 | return NOTIFY_OK; |
| 818 | 818 | ||
| 819 | switch (event) { | 819 | switch (event) { |
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c b/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c index d7ca7e82a832..fe76c6fd6d80 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c | |||
| @@ -2284,7 +2284,7 @@ static struct mlx5_flow_root_namespace | |||
| 2284 | cmds = mlx5_fs_cmd_get_default_ipsec_fpga_cmds(table_type); | 2284 | cmds = mlx5_fs_cmd_get_default_ipsec_fpga_cmds(table_type); |
| 2285 | 2285 | ||
| 2286 | /* Create the root namespace */ | 2286 | /* Create the root namespace */ |
| 2287 | root_ns = kvzalloc(sizeof(*root_ns), GFP_KERNEL); | 2287 | root_ns = kzalloc(sizeof(*root_ns), GFP_KERNEL); |
| 2288 | if (!root_ns) | 2288 | if (!root_ns) |
| 2289 | return NULL; | 2289 | return NULL; |
| 2290 | 2290 | ||
| @@ -2427,6 +2427,7 @@ static void cleanup_egress_acls_root_ns(struct mlx5_core_dev *dev) | |||
| 2427 | cleanup_root_ns(steering->esw_egress_root_ns[i]); | 2427 | cleanup_root_ns(steering->esw_egress_root_ns[i]); |
| 2428 | 2428 | ||
| 2429 | kfree(steering->esw_egress_root_ns); | 2429 | kfree(steering->esw_egress_root_ns); |
| 2430 | steering->esw_egress_root_ns = NULL; | ||
| 2430 | } | 2431 | } |
| 2431 | 2432 | ||
| 2432 | static void cleanup_ingress_acls_root_ns(struct mlx5_core_dev *dev) | 2433 | static void cleanup_ingress_acls_root_ns(struct mlx5_core_dev *dev) |
| @@ -2441,6 +2442,7 @@ static void cleanup_ingress_acls_root_ns(struct mlx5_core_dev *dev) | |||
| 2441 | cleanup_root_ns(steering->esw_ingress_root_ns[i]); | 2442 | cleanup_root_ns(steering->esw_ingress_root_ns[i]); |
| 2442 | 2443 | ||
| 2443 | kfree(steering->esw_ingress_root_ns); | 2444 | kfree(steering->esw_ingress_root_ns); |
| 2445 | steering->esw_ingress_root_ns = NULL; | ||
| 2444 | } | 2446 | } |
| 2445 | 2447 | ||
| 2446 | void mlx5_cleanup_fs(struct mlx5_core_dev *dev) | 2448 | void mlx5_cleanup_fs(struct mlx5_core_dev *dev) |
| @@ -2474,11 +2476,7 @@ static int init_sniffer_tx_root_ns(struct mlx5_flow_steering *steering) | |||
| 2474 | 2476 | ||
| 2475 | /* Create single prio */ | 2477 | /* Create single prio */ |
| 2476 | prio = fs_create_prio(&steering->sniffer_tx_root_ns->ns, 0, 1); | 2478 | prio = fs_create_prio(&steering->sniffer_tx_root_ns->ns, 0, 1); |
| 2477 | if (IS_ERR(prio)) { | 2479 | return PTR_ERR_OR_ZERO(prio); |
| 2478 | cleanup_root_ns(steering->sniffer_tx_root_ns); | ||
| 2479 | return PTR_ERR(prio); | ||
| 2480 | } | ||
| 2481 | return 0; | ||
| 2482 | } | 2480 | } |
| 2483 | 2481 | ||
| 2484 | static int init_sniffer_rx_root_ns(struct mlx5_flow_steering *steering) | 2482 | static int init_sniffer_rx_root_ns(struct mlx5_flow_steering *steering) |
| @@ -2491,11 +2489,7 @@ static int init_sniffer_rx_root_ns(struct mlx5_flow_steering *steering) | |||
| 2491 | 2489 | ||
| 2492 | /* Create single prio */ | 2490 | /* Create single prio */ |
| 2493 | prio = fs_create_prio(&steering->sniffer_rx_root_ns->ns, 0, 1); | 2491 | prio = fs_create_prio(&steering->sniffer_rx_root_ns->ns, 0, 1); |
| 2494 | if (IS_ERR(prio)) { | 2492 | return PTR_ERR_OR_ZERO(prio); |
| 2495 | cleanup_root_ns(steering->sniffer_rx_root_ns); | ||
| 2496 | return PTR_ERR(prio); | ||
| 2497 | } | ||
| 2498 | return 0; | ||
| 2499 | } | 2493 | } |
| 2500 | 2494 | ||
| 2501 | static int init_rdma_rx_root_ns(struct mlx5_flow_steering *steering) | 2495 | static int init_rdma_rx_root_ns(struct mlx5_flow_steering *steering) |
| @@ -2511,11 +2505,7 @@ static int init_rdma_rx_root_ns(struct mlx5_flow_steering *steering) | |||
| 2511 | 2505 | ||
| 2512 | /* Create single prio */ | 2506 | /* Create single prio */ |
| 2513 | prio = fs_create_prio(&steering->rdma_rx_root_ns->ns, 0, 1); | 2507 | prio = fs_create_prio(&steering->rdma_rx_root_ns->ns, 0, 1); |
| 2514 | if (IS_ERR(prio)) { | 2508 | return PTR_ERR_OR_ZERO(prio); |
| 2515 | cleanup_root_ns(steering->rdma_rx_root_ns); | ||
| 2516 | return PTR_ERR(prio); | ||
| 2517 | } | ||
| 2518 | return 0; | ||
| 2519 | } | 2509 | } |
| 2520 | static int init_fdb_root_ns(struct mlx5_flow_steering *steering) | 2510 | static int init_fdb_root_ns(struct mlx5_flow_steering *steering) |
| 2521 | { | 2511 | { |
| @@ -2637,6 +2627,7 @@ cleanup_root_ns: | |||
| 2637 | for (i--; i >= 0; i--) | 2627 | for (i--; i >= 0; i--) |
| 2638 | cleanup_root_ns(steering->esw_egress_root_ns[i]); | 2628 | cleanup_root_ns(steering->esw_egress_root_ns[i]); |
| 2639 | kfree(steering->esw_egress_root_ns); | 2629 | kfree(steering->esw_egress_root_ns); |
| 2630 | steering->esw_egress_root_ns = NULL; | ||
| 2640 | return err; | 2631 | return err; |
| 2641 | } | 2632 | } |
| 2642 | 2633 | ||
| @@ -2664,6 +2655,7 @@ cleanup_root_ns: | |||
| 2664 | for (i--; i >= 0; i--) | 2655 | for (i--; i >= 0; i--) |
| 2665 | cleanup_root_ns(steering->esw_ingress_root_ns[i]); | 2656 | cleanup_root_ns(steering->esw_ingress_root_ns[i]); |
| 2666 | kfree(steering->esw_ingress_root_ns); | 2657 | kfree(steering->esw_ingress_root_ns); |
| 2658 | steering->esw_ingress_root_ns = NULL; | ||
| 2667 | return err; | 2659 | return err; |
| 2668 | } | 2660 | } |
| 2669 | 2661 | ||
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c index 61fa1d162d28..23d53163ce15 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c | |||
| @@ -1067,7 +1067,7 @@ static int mlx5_load(struct mlx5_core_dev *dev) | |||
| 1067 | err = mlx5_core_set_hca_defaults(dev); | 1067 | err = mlx5_core_set_hca_defaults(dev); |
| 1068 | if (err) { | 1068 | if (err) { |
| 1069 | mlx5_core_err(dev, "Failed to set hca defaults\n"); | 1069 | mlx5_core_err(dev, "Failed to set hca defaults\n"); |
| 1070 | goto err_fs; | 1070 | goto err_sriov; |
| 1071 | } | 1071 | } |
| 1072 | 1072 | ||
| 1073 | err = mlx5_sriov_attach(dev); | 1073 | err = mlx5_sriov_attach(dev); |
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c index dbb425717f5e..dfe6b44baf63 100644 --- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c +++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c | |||
| @@ -3128,6 +3128,10 @@ mlxsw_sp_port_set_link_ksettings(struct net_device *dev, | |||
| 3128 | ops->reg_ptys_eth_unpack(mlxsw_sp, ptys_pl, ð_proto_cap, NULL, NULL); | 3128 | ops->reg_ptys_eth_unpack(mlxsw_sp, ptys_pl, ð_proto_cap, NULL, NULL); |
| 3129 | 3129 | ||
| 3130 | autoneg = cmd->base.autoneg == AUTONEG_ENABLE; | 3130 | autoneg = cmd->base.autoneg == AUTONEG_ENABLE; |
| 3131 | if (!autoneg && cmd->base.speed == SPEED_56000) { | ||
| 3132 | netdev_err(dev, "56G not supported with autoneg off\n"); | ||
| 3133 | return -EINVAL; | ||
| 3134 | } | ||
| 3131 | eth_proto_new = autoneg ? | 3135 | eth_proto_new = autoneg ? |
| 3132 | ops->to_ptys_advert_link(mlxsw_sp, cmd) : | 3136 | ops->to_ptys_advert_link(mlxsw_sp, cmd) : |
| 3133 | ops->to_ptys_speed(mlxsw_sp, cmd->base.speed); | 3137 | ops->to_ptys_speed(mlxsw_sp, cmd->base.speed); |
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c index c1a9cc9a3292..4c98950380d5 100644 --- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c +++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c | |||
| @@ -1171,13 +1171,12 @@ mlxsw_sp_acl_erp_delta_fill(const struct mlxsw_sp_acl_erp_key *parent_key, | |||
| 1171 | return -EINVAL; | 1171 | return -EINVAL; |
| 1172 | } | 1172 | } |
| 1173 | if (si == -1) { | 1173 | if (si == -1) { |
| 1174 | /* The masks are the same, this cannot happen. | 1174 | /* The masks are the same, this can happen in case eRPs with |
| 1175 | * That means the caller is broken. | 1175 | * the same mask were created in both A-TCAM and C-TCAM. |
| 1176 | * The only possible condition under which this can happen | ||
| 1177 | * is identical rule insertion. Delta is not possible here. | ||
| 1176 | */ | 1178 | */ |
| 1177 | WARN_ON(1); | 1179 | return -EINVAL; |
| 1178 | *delta_start = 0; | ||
| 1179 | *delta_mask = 0; | ||
| 1180 | return 0; | ||
| 1181 | } | 1180 | } |
| 1182 | pmask = (unsigned char) parent_key->mask[__MASK_IDX(si)]; | 1181 | pmask = (unsigned char) parent_key->mask[__MASK_IDX(si)]; |
| 1183 | mask = (unsigned char) key->mask[__MASK_IDX(si)]; | 1182 | mask = (unsigned char) key->mask[__MASK_IDX(si)]; |
diff --git a/drivers/net/ethernet/mscc/ocelot.c b/drivers/net/ethernet/mscc/ocelot.c index d715ef4fc92f..02ad11e0b0d8 100644 --- a/drivers/net/ethernet/mscc/ocelot.c +++ b/drivers/net/ethernet/mscc/ocelot.c | |||
| @@ -593,45 +593,25 @@ static int ocelot_port_xmit(struct sk_buff *skb, struct net_device *dev) | |||
| 593 | return NETDEV_TX_OK; | 593 | return NETDEV_TX_OK; |
| 594 | } | 594 | } |
| 595 | 595 | ||
| 596 | static void ocelot_mact_mc_reset(struct ocelot_port *port) | 596 | static int ocelot_mc_unsync(struct net_device *dev, const unsigned char *addr) |
| 597 | { | 597 | { |
| 598 | struct ocelot *ocelot = port->ocelot; | 598 | struct ocelot_port *port = netdev_priv(dev); |
| 599 | struct netdev_hw_addr *ha, *n; | ||
| 600 | 599 | ||
| 601 | /* Free and forget all the MAC addresses stored in the port private mc | 600 | return ocelot_mact_forget(port->ocelot, addr, port->pvid); |
| 602 | * list. These are mc addresses that were previously added by calling | ||
| 603 | * ocelot_mact_mc_add(). | ||
| 604 | */ | ||
| 605 | list_for_each_entry_safe(ha, n, &port->mc, list) { | ||
| 606 | ocelot_mact_forget(ocelot, ha->addr, port->pvid); | ||
| 607 | list_del(&ha->list); | ||
| 608 | kfree(ha); | ||
| 609 | } | ||
| 610 | } | 601 | } |
| 611 | 602 | ||
| 612 | static int ocelot_mact_mc_add(struct ocelot_port *port, | 603 | static int ocelot_mc_sync(struct net_device *dev, const unsigned char *addr) |
| 613 | struct netdev_hw_addr *hw_addr) | ||
| 614 | { | 604 | { |
| 615 | struct ocelot *ocelot = port->ocelot; | 605 | struct ocelot_port *port = netdev_priv(dev); |
| 616 | struct netdev_hw_addr *ha = kzalloc(sizeof(*ha), GFP_ATOMIC); | ||
| 617 | |||
| 618 | if (!ha) | ||
| 619 | return -ENOMEM; | ||
| 620 | |||
| 621 | memcpy(ha, hw_addr, sizeof(*ha)); | ||
| 622 | list_add_tail(&ha->list, &port->mc); | ||
| 623 | |||
| 624 | ocelot_mact_learn(ocelot, PGID_CPU, ha->addr, port->pvid, | ||
| 625 | ENTRYTYPE_LOCKED); | ||
| 626 | 606 | ||
| 627 | return 0; | 607 | return ocelot_mact_learn(port->ocelot, PGID_CPU, addr, port->pvid, |
| 608 | ENTRYTYPE_LOCKED); | ||
| 628 | } | 609 | } |
| 629 | 610 | ||
| 630 | static void ocelot_set_rx_mode(struct net_device *dev) | 611 | static void ocelot_set_rx_mode(struct net_device *dev) |
| 631 | { | 612 | { |
| 632 | struct ocelot_port *port = netdev_priv(dev); | 613 | struct ocelot_port *port = netdev_priv(dev); |
| 633 | struct ocelot *ocelot = port->ocelot; | 614 | struct ocelot *ocelot = port->ocelot; |
| 634 | struct netdev_hw_addr *ha; | ||
| 635 | int i; | 615 | int i; |
| 636 | u32 val; | 616 | u32 val; |
| 637 | 617 | ||
| @@ -643,13 +623,7 @@ static void ocelot_set_rx_mode(struct net_device *dev) | |||
| 643 | for (i = ocelot->num_phys_ports + 1; i < PGID_CPU; i++) | 623 | for (i = ocelot->num_phys_ports + 1; i < PGID_CPU; i++) |
| 644 | ocelot_write_rix(ocelot, val, ANA_PGID_PGID, i); | 624 | ocelot_write_rix(ocelot, val, ANA_PGID_PGID, i); |
| 645 | 625 | ||
| 646 | /* Handle the device multicast addresses. First remove all the | 626 | __dev_mc_sync(dev, ocelot_mc_sync, ocelot_mc_unsync); |
| 647 | * previously installed addresses and then add the latest ones to the | ||
| 648 | * mac table. | ||
| 649 | */ | ||
| 650 | ocelot_mact_mc_reset(port); | ||
| 651 | netdev_for_each_mc_addr(ha, dev) | ||
| 652 | ocelot_mact_mc_add(port, ha); | ||
| 653 | } | 627 | } |
| 654 | 628 | ||
| 655 | static int ocelot_port_get_phys_port_name(struct net_device *dev, | 629 | static int ocelot_port_get_phys_port_name(struct net_device *dev, |
| @@ -1657,7 +1631,6 @@ int ocelot_probe_port(struct ocelot *ocelot, u8 port, | |||
| 1657 | ocelot_port->regs = regs; | 1631 | ocelot_port->regs = regs; |
| 1658 | ocelot_port->chip_port = port; | 1632 | ocelot_port->chip_port = port; |
| 1659 | ocelot_port->phy = phy; | 1633 | ocelot_port->phy = phy; |
| 1660 | INIT_LIST_HEAD(&ocelot_port->mc); | ||
| 1661 | ocelot->ports[port] = ocelot_port; | 1634 | ocelot->ports[port] = ocelot_port; |
| 1662 | 1635 | ||
| 1663 | dev->netdev_ops = &ocelot_port_netdev_ops; | 1636 | dev->netdev_ops = &ocelot_port_netdev_ops; |
diff --git a/drivers/net/ethernet/mscc/ocelot.h b/drivers/net/ethernet/mscc/ocelot.h index ba3b3380b4d0..541fe41e60b0 100644 --- a/drivers/net/ethernet/mscc/ocelot.h +++ b/drivers/net/ethernet/mscc/ocelot.h | |||
| @@ -441,10 +441,6 @@ struct ocelot_port { | |||
| 441 | struct phy_device *phy; | 441 | struct phy_device *phy; |
| 442 | void __iomem *regs; | 442 | void __iomem *regs; |
| 443 | u8 chip_port; | 443 | u8 chip_port; |
| 444 | /* Keep a track of the mc addresses added to the mac table, so that they | ||
| 445 | * can be removed when needed. | ||
| 446 | */ | ||
| 447 | struct list_head mc; | ||
| 448 | 444 | ||
| 449 | /* Ingress default VLAN (pvid) */ | 445 | /* Ingress default VLAN (pvid) */ |
| 450 | u16 pvid; | 446 | u16 pvid; |
diff --git a/drivers/net/ethernet/realtek/r8169.c b/drivers/net/ethernet/realtek/r8169.c index 8e404186ef87..d06a61f00e78 100644 --- a/drivers/net/ethernet/realtek/r8169.c +++ b/drivers/net/ethernet/realtek/r8169.c | |||
| @@ -6722,6 +6722,8 @@ static int rtl8169_resume(struct device *device) | |||
| 6722 | struct net_device *dev = dev_get_drvdata(device); | 6722 | struct net_device *dev = dev_get_drvdata(device); |
| 6723 | struct rtl8169_private *tp = netdev_priv(dev); | 6723 | struct rtl8169_private *tp = netdev_priv(dev); |
| 6724 | 6724 | ||
| 6725 | rtl_rar_set(tp, dev->dev_addr); | ||
| 6726 | |||
| 6725 | clk_prepare_enable(tp->clk); | 6727 | clk_prepare_enable(tp->clk); |
| 6726 | 6728 | ||
| 6727 | if (netif_running(dev)) | 6729 | if (netif_running(dev)) |
| @@ -6755,6 +6757,7 @@ static int rtl8169_runtime_resume(struct device *device) | |||
| 6755 | { | 6757 | { |
| 6756 | struct net_device *dev = dev_get_drvdata(device); | 6758 | struct net_device *dev = dev_get_drvdata(device); |
| 6757 | struct rtl8169_private *tp = netdev_priv(dev); | 6759 | struct rtl8169_private *tp = netdev_priv(dev); |
| 6760 | |||
| 6758 | rtl_rar_set(tp, dev->dev_addr); | 6761 | rtl_rar_set(tp, dev->dev_addr); |
| 6759 | 6762 | ||
| 6760 | if (!tp->TxDescArray) | 6763 | if (!tp->TxDescArray) |
diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c index 6354f19a31eb..7ba35a0bdb29 100644 --- a/drivers/net/ethernet/renesas/sh_eth.c +++ b/drivers/net/ethernet/renesas/sh_eth.c | |||
| @@ -1594,6 +1594,10 @@ static void sh_eth_dev_exit(struct net_device *ndev) | |||
| 1594 | sh_eth_get_stats(ndev); | 1594 | sh_eth_get_stats(ndev); |
| 1595 | mdp->cd->soft_reset(ndev); | 1595 | mdp->cd->soft_reset(ndev); |
| 1596 | 1596 | ||
| 1597 | /* Set the RMII mode again if required */ | ||
| 1598 | if (mdp->cd->rmiimode) | ||
| 1599 | sh_eth_write(ndev, 0x1, RMIIMODE); | ||
| 1600 | |||
| 1597 | /* Set MAC address again */ | 1601 | /* Set MAC address again */ |
| 1598 | update_mac_address(ndev); | 1602 | update_mac_address(ndev); |
| 1599 | } | 1603 | } |
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-dwc-qos-eth.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-dwc-qos-eth.c index 3256e5cbad27..5bc224834c77 100644 --- a/drivers/net/ethernet/stmicro/stmmac/dwmac-dwc-qos-eth.c +++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-dwc-qos-eth.c | |||
| @@ -455,7 +455,11 @@ static int dwc_eth_dwmac_probe(struct platform_device *pdev) | |||
| 455 | priv = data->probe(pdev, plat_dat, &stmmac_res); | 455 | priv = data->probe(pdev, plat_dat, &stmmac_res); |
| 456 | if (IS_ERR(priv)) { | 456 | if (IS_ERR(priv)) { |
| 457 | ret = PTR_ERR(priv); | 457 | ret = PTR_ERR(priv); |
| 458 | dev_err(&pdev->dev, "failed to probe subdriver: %d\n", ret); | 458 | |
| 459 | if (ret != -EPROBE_DEFER) | ||
| 460 | dev_err(&pdev->dev, "failed to probe subdriver: %d\n", | ||
| 461 | ret); | ||
| 462 | |||
| 459 | goto remove_config; | 463 | goto remove_config; |
| 460 | } | 464 | } |
| 461 | 465 | ||
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-mediatek.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-mediatek.c index bf2562995fc8..126b66bb73a6 100644 --- a/drivers/net/ethernet/stmicro/stmmac/dwmac-mediatek.c +++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-mediatek.c | |||
| @@ -346,8 +346,6 @@ static int mediatek_dwmac_probe(struct platform_device *pdev) | |||
| 346 | return PTR_ERR(plat_dat); | 346 | return PTR_ERR(plat_dat); |
| 347 | 347 | ||
| 348 | plat_dat->interface = priv_plat->phy_mode; | 348 | plat_dat->interface = priv_plat->phy_mode; |
| 349 | /* clk_csr_i = 250-300MHz & MDC = clk_csr_i/124 */ | ||
| 350 | plat_dat->clk_csr = 5; | ||
| 351 | plat_dat->has_gmac4 = 1; | 349 | plat_dat->has_gmac4 = 1; |
| 352 | plat_dat->has_gmac = 0; | 350 | plat_dat->has_gmac = 0; |
| 353 | plat_dat->pmt = 0; | 351 | plat_dat->pmt = 0; |
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c index 2a1052704885..65e57b9f6887 100644 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c | |||
| @@ -3338,6 +3338,7 @@ static inline void stmmac_rx_refill(struct stmmac_priv *priv, u32 queue) | |||
| 3338 | entry = STMMAC_GET_ENTRY(entry, DMA_RX_SIZE); | 3338 | entry = STMMAC_GET_ENTRY(entry, DMA_RX_SIZE); |
| 3339 | } | 3339 | } |
| 3340 | rx_q->dirty_rx = entry; | 3340 | rx_q->dirty_rx = entry; |
| 3341 | stmmac_set_rx_tail_ptr(priv, priv->ioaddr, rx_q->rx_tail_addr, queue); | ||
| 3341 | } | 3342 | } |
| 3342 | 3343 | ||
| 3343 | /** | 3344 | /** |
| @@ -4379,10 +4380,10 @@ int stmmac_dvr_probe(struct device *device, | |||
| 4379 | * set the MDC clock dynamically according to the csr actual | 4380 | * set the MDC clock dynamically according to the csr actual |
| 4380 | * clock input. | 4381 | * clock input. |
| 4381 | */ | 4382 | */ |
| 4382 | if (!priv->plat->clk_csr) | 4383 | if (priv->plat->clk_csr >= 0) |
| 4383 | stmmac_clk_csr_set(priv); | ||
| 4384 | else | ||
| 4385 | priv->clk_csr = priv->plat->clk_csr; | 4384 | priv->clk_csr = priv->plat->clk_csr; |
| 4385 | else | ||
| 4386 | stmmac_clk_csr_set(priv); | ||
| 4386 | 4387 | ||
| 4387 | stmmac_check_pcs_mode(priv); | 4388 | stmmac_check_pcs_mode(priv); |
| 4388 | 4389 | ||
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c index bdd351597b55..093a223fe408 100644 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c | |||
| @@ -267,7 +267,8 @@ int stmmac_mdio_reset(struct mii_bus *bus) | |||
| 267 | of_property_read_u32_array(np, | 267 | of_property_read_u32_array(np, |
| 268 | "snps,reset-delays-us", data->delays, 3); | 268 | "snps,reset-delays-us", data->delays, 3); |
| 269 | 269 | ||
| 270 | if (gpio_request(data->reset_gpio, "mdio-reset")) | 270 | if (devm_gpio_request(priv->device, data->reset_gpio, |
| 271 | "mdio-reset")) | ||
| 271 | return 0; | 272 | return 0; |
| 272 | } | 273 | } |
| 273 | 274 | ||
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c index 3031f2bf15d6..f45bfbef97d0 100644 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c | |||
| @@ -408,7 +408,10 @@ stmmac_probe_config_dt(struct platform_device *pdev, const char **mac) | |||
| 408 | /* Default to phy auto-detection */ | 408 | /* Default to phy auto-detection */ |
| 409 | plat->phy_addr = -1; | 409 | plat->phy_addr = -1; |
| 410 | 410 | ||
| 411 | /* Get clk_csr from device tree */ | 411 | /* Default to get clk_csr from stmmac_clk_crs_set(), |
| 412 | * or get clk_csr from device tree. | ||
| 413 | */ | ||
| 414 | plat->clk_csr = -1; | ||
| 412 | of_property_read_u32(np, "clk_csr", &plat->clk_csr); | 415 | of_property_read_u32(np, "clk_csr", &plat->clk_csr); |
| 413 | 416 | ||
| 414 | /* "snps,phy-addr" is not a standard property. Mark it as deprecated | 417 | /* "snps,phy-addr" is not a standard property. Mark it as deprecated |
diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c index 06393b215102..9873b8679f81 100644 --- a/drivers/net/hyperv/netvsc_drv.c +++ b/drivers/net/hyperv/netvsc_drv.c | |||
| @@ -2000,6 +2000,12 @@ static rx_handler_result_t netvsc_vf_handle_frame(struct sk_buff **pskb) | |||
| 2000 | struct netvsc_vf_pcpu_stats *pcpu_stats | 2000 | struct netvsc_vf_pcpu_stats *pcpu_stats |
| 2001 | = this_cpu_ptr(ndev_ctx->vf_stats); | 2001 | = this_cpu_ptr(ndev_ctx->vf_stats); |
| 2002 | 2002 | ||
| 2003 | skb = skb_share_check(skb, GFP_ATOMIC); | ||
| 2004 | if (unlikely(!skb)) | ||
| 2005 | return RX_HANDLER_CONSUMED; | ||
| 2006 | |||
| 2007 | *pskb = skb; | ||
| 2008 | |||
| 2003 | skb->dev = ndev; | 2009 | skb->dev = ndev; |
| 2004 | 2010 | ||
| 2005 | u64_stats_update_begin(&pcpu_stats->syncp); | 2011 | u64_stats_update_begin(&pcpu_stats->syncp); |
diff --git a/drivers/net/phy/dp83867.c b/drivers/net/phy/dp83867.c index fd35131a0c39..c71c7d0f53f0 100644 --- a/drivers/net/phy/dp83867.c +++ b/drivers/net/phy/dp83867.c | |||
| @@ -26,10 +26,18 @@ | |||
| 26 | 26 | ||
| 27 | /* Extended Registers */ | 27 | /* Extended Registers */ |
| 28 | #define DP83867_CFG4 0x0031 | 28 | #define DP83867_CFG4 0x0031 |
| 29 | #define DP83867_CFG4_SGMII_ANEG_MASK (BIT(5) | BIT(6)) | ||
| 30 | #define DP83867_CFG4_SGMII_ANEG_TIMER_11MS (3 << 5) | ||
| 31 | #define DP83867_CFG4_SGMII_ANEG_TIMER_800US (2 << 5) | ||
| 32 | #define DP83867_CFG4_SGMII_ANEG_TIMER_2US (1 << 5) | ||
| 33 | #define DP83867_CFG4_SGMII_ANEG_TIMER_16MS (0 << 5) | ||
| 34 | |||
| 29 | #define DP83867_RGMIICTL 0x0032 | 35 | #define DP83867_RGMIICTL 0x0032 |
| 30 | #define DP83867_STRAP_STS1 0x006E | 36 | #define DP83867_STRAP_STS1 0x006E |
| 31 | #define DP83867_RGMIIDCTL 0x0086 | 37 | #define DP83867_RGMIIDCTL 0x0086 |
| 32 | #define DP83867_IO_MUX_CFG 0x0170 | 38 | #define DP83867_IO_MUX_CFG 0x0170 |
| 39 | #define DP83867_10M_SGMII_CFG 0x016F | ||
| 40 | #define DP83867_10M_SGMII_RATE_ADAPT_MASK BIT(7) | ||
| 33 | 41 | ||
| 34 | #define DP83867_SW_RESET BIT(15) | 42 | #define DP83867_SW_RESET BIT(15) |
| 35 | #define DP83867_SW_RESTART BIT(14) | 43 | #define DP83867_SW_RESTART BIT(14) |
| @@ -247,10 +255,8 @@ static int dp83867_config_init(struct phy_device *phydev) | |||
| 247 | ret = phy_write(phydev, MII_DP83867_PHYCTRL, val); | 255 | ret = phy_write(phydev, MII_DP83867_PHYCTRL, val); |
| 248 | if (ret) | 256 | if (ret) |
| 249 | return ret; | 257 | return ret; |
| 250 | } | ||
| 251 | 258 | ||
| 252 | if ((phydev->interface >= PHY_INTERFACE_MODE_RGMII_ID) && | 259 | /* Set up RGMII delays */ |
| 253 | (phydev->interface <= PHY_INTERFACE_MODE_RGMII_RXID)) { | ||
| 254 | val = phy_read_mmd(phydev, DP83867_DEVADDR, DP83867_RGMIICTL); | 260 | val = phy_read_mmd(phydev, DP83867_DEVADDR, DP83867_RGMIICTL); |
| 255 | 261 | ||
| 256 | if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID) | 262 | if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID) |
| @@ -277,6 +283,33 @@ static int dp83867_config_init(struct phy_device *phydev) | |||
| 277 | DP83867_IO_MUX_CFG_IO_IMPEDANCE_CTRL); | 283 | DP83867_IO_MUX_CFG_IO_IMPEDANCE_CTRL); |
| 278 | } | 284 | } |
| 279 | 285 | ||
| 286 | if (phydev->interface == PHY_INTERFACE_MODE_SGMII) { | ||
| 287 | /* For support SPEED_10 in SGMII mode | ||
| 288 | * DP83867_10M_SGMII_RATE_ADAPT bit | ||
| 289 | * has to be cleared by software. That | ||
| 290 | * does not affect SPEED_100 and | ||
| 291 | * SPEED_1000. | ||
| 292 | */ | ||
| 293 | ret = phy_modify_mmd(phydev, DP83867_DEVADDR, | ||
| 294 | DP83867_10M_SGMII_CFG, | ||
| 295 | DP83867_10M_SGMII_RATE_ADAPT_MASK, | ||
| 296 | 0); | ||
| 297 | if (ret) | ||
| 298 | return ret; | ||
| 299 | |||
| 300 | /* After reset SGMII Autoneg timer is set to 2us (bits 6 and 5 | ||
| 301 | * are 01). That is not enough to finalize autoneg on some | ||
| 302 | * devices. Increase this timer duration to maximum 16ms. | ||
| 303 | */ | ||
| 304 | ret = phy_modify_mmd(phydev, DP83867_DEVADDR, | ||
| 305 | DP83867_CFG4, | ||
| 306 | DP83867_CFG4_SGMII_ANEG_MASK, | ||
| 307 | DP83867_CFG4_SGMII_ANEG_TIMER_16MS); | ||
| 308 | |||
| 309 | if (ret) | ||
| 310 | return ret; | ||
| 311 | } | ||
| 312 | |||
| 280 | /* Enable Interrupt output INT_OE in CFG3 register */ | 313 | /* Enable Interrupt output INT_OE in CFG3 register */ |
| 281 | if (phy_interrupt_is_valid(phydev)) { | 314 | if (phy_interrupt_is_valid(phydev)) { |
| 282 | val = phy_read(phydev, DP83867_CFG3); | 315 | val = phy_read(phydev, DP83867_CFG3); |
| @@ -307,7 +340,7 @@ static int dp83867_phy_reset(struct phy_device *phydev) | |||
| 307 | 340 | ||
| 308 | usleep_range(10, 20); | 341 | usleep_range(10, 20); |
| 309 | 342 | ||
| 310 | return dp83867_config_init(phydev); | 343 | return 0; |
| 311 | } | 344 | } |
| 312 | 345 | ||
| 313 | static struct phy_driver dp83867_driver[] = { | 346 | static struct phy_driver dp83867_driver[] = { |
diff --git a/drivers/net/phy/marvell10g.c b/drivers/net/phy/marvell10g.c index 238a20e13d6a..3b99882692e3 100644 --- a/drivers/net/phy/marvell10g.c +++ b/drivers/net/phy/marvell10g.c | |||
| @@ -31,6 +31,9 @@ | |||
| 31 | #define MV_PHY_ALASKA_NBT_QUIRK_REV (MARVELL_PHY_ID_88X3310 | 0xa) | 31 | #define MV_PHY_ALASKA_NBT_QUIRK_REV (MARVELL_PHY_ID_88X3310 | 0xa) |
| 32 | 32 | ||
| 33 | enum { | 33 | enum { |
| 34 | MV_PMA_BOOT = 0xc050, | ||
| 35 | MV_PMA_BOOT_FATAL = BIT(0), | ||
| 36 | |||
| 34 | MV_PCS_BASE_T = 0x0000, | 37 | MV_PCS_BASE_T = 0x0000, |
| 35 | MV_PCS_BASE_R = 0x1000, | 38 | MV_PCS_BASE_R = 0x1000, |
| 36 | MV_PCS_1000BASEX = 0x2000, | 39 | MV_PCS_1000BASEX = 0x2000, |
| @@ -213,6 +216,16 @@ static int mv3310_probe(struct phy_device *phydev) | |||
| 213 | (phydev->c45_ids.devices_in_package & mmd_mask) != mmd_mask) | 216 | (phydev->c45_ids.devices_in_package & mmd_mask) != mmd_mask) |
| 214 | return -ENODEV; | 217 | return -ENODEV; |
| 215 | 218 | ||
| 219 | ret = phy_read_mmd(phydev, MDIO_MMD_PMAPMD, MV_PMA_BOOT); | ||
| 220 | if (ret < 0) | ||
| 221 | return ret; | ||
| 222 | |||
| 223 | if (ret & MV_PMA_BOOT_FATAL) { | ||
| 224 | dev_warn(&phydev->mdio.dev, | ||
| 225 | "PHY failed to boot firmware, status=%04x\n", ret); | ||
| 226 | return -ENODEV; | ||
| 227 | } | ||
| 228 | |||
| 216 | priv = devm_kzalloc(&phydev->mdio.dev, sizeof(*priv), GFP_KERNEL); | 229 | priv = devm_kzalloc(&phydev->mdio.dev, sizeof(*priv), GFP_KERNEL); |
| 217 | if (!priv) | 230 | if (!priv) |
| 218 | return -ENOMEM; | 231 | return -ENOMEM; |
diff --git a/drivers/net/phy/phylink.c b/drivers/net/phy/phylink.c index 74983593834b..9044b95d2afe 100644 --- a/drivers/net/phy/phylink.c +++ b/drivers/net/phy/phylink.c | |||
| @@ -51,6 +51,10 @@ struct phylink { | |||
| 51 | 51 | ||
| 52 | /* The link configuration settings */ | 52 | /* The link configuration settings */ |
| 53 | struct phylink_link_state link_config; | 53 | struct phylink_link_state link_config; |
| 54 | |||
| 55 | /* The current settings */ | ||
| 56 | phy_interface_t cur_interface; | ||
| 57 | |||
| 54 | struct gpio_desc *link_gpio; | 58 | struct gpio_desc *link_gpio; |
| 55 | struct timer_list link_poll; | 59 | struct timer_list link_poll; |
| 56 | void (*get_fixed_state)(struct net_device *dev, | 60 | void (*get_fixed_state)(struct net_device *dev, |
| @@ -446,12 +450,12 @@ static void phylink_resolve(struct work_struct *w) | |||
| 446 | if (!link_state.link) { | 450 | if (!link_state.link) { |
| 447 | netif_carrier_off(ndev); | 451 | netif_carrier_off(ndev); |
| 448 | pl->ops->mac_link_down(ndev, pl->link_an_mode, | 452 | pl->ops->mac_link_down(ndev, pl->link_an_mode, |
| 449 | pl->phy_state.interface); | 453 | pl->cur_interface); |
| 450 | netdev_info(ndev, "Link is Down\n"); | 454 | netdev_info(ndev, "Link is Down\n"); |
| 451 | } else { | 455 | } else { |
| 456 | pl->cur_interface = link_state.interface; | ||
| 452 | pl->ops->mac_link_up(ndev, pl->link_an_mode, | 457 | pl->ops->mac_link_up(ndev, pl->link_an_mode, |
| 453 | pl->phy_state.interface, | 458 | pl->cur_interface, pl->phydev); |
| 454 | pl->phydev); | ||
| 455 | 459 | ||
| 456 | netif_carrier_on(ndev); | 460 | netif_carrier_on(ndev); |
| 457 | 461 | ||
