/drivers/net/niu.c

https://gitlab.com/TeamCarbonXtreme/android_kernel_samsung_bcm21553-common · C · 10280 lines · 8345 code · 1773 blank · 162 comment · 1374 complexity · d9a6bc9cffd37c042abc656e8c81341e MD5 · raw file

Large files are truncated click here to view the full file

  1. /* niu.c: Neptune ethernet driver.
  2. *
  3. * Copyright (C) 2007, 2008 David S. Miller (davem@davemloft.net)
  4. */
  5. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  6. #include <linux/module.h>
  7. #include <linux/init.h>
  8. #include <linux/pci.h>
  9. #include <linux/dma-mapping.h>
  10. #include <linux/netdevice.h>
  11. #include <linux/ethtool.h>
  12. #include <linux/etherdevice.h>
  13. #include <linux/platform_device.h>
  14. #include <linux/delay.h>
  15. #include <linux/bitops.h>
  16. #include <linux/mii.h>
  17. #include <linux/if_ether.h>
  18. #include <linux/if_vlan.h>
  19. #include <linux/ip.h>
  20. #include <linux/in.h>
  21. #include <linux/ipv6.h>
  22. #include <linux/log2.h>
  23. #include <linux/jiffies.h>
  24. #include <linux/crc32.h>
  25. #include <linux/list.h>
  26. #include <linux/slab.h>
  27. #include <linux/io.h>
  28. #ifdef CONFIG_SPARC64
  29. #include <linux/of_device.h>
  30. #endif
  31. #include "niu.h"
  32. #define DRV_MODULE_NAME "niu"
  33. #define DRV_MODULE_VERSION "1.1"
  34. #define DRV_MODULE_RELDATE "Apr 22, 2010"
  35. static char version[] __devinitdata =
  36. DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
  37. MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
  38. MODULE_DESCRIPTION("NIU ethernet driver");
  39. MODULE_LICENSE("GPL");
  40. MODULE_VERSION(DRV_MODULE_VERSION);
  41. #ifndef readq
  42. static u64 readq(void __iomem *reg)
  43. {
  44. return ((u64) readl(reg)) | (((u64) readl(reg + 4UL)) << 32);
  45. }
  46. static void writeq(u64 val, void __iomem *reg)
  47. {
  48. writel(val & 0xffffffff, reg);
  49. writel(val >> 32, reg + 0x4UL);
  50. }
  51. #endif
  52. static DEFINE_PCI_DEVICE_TABLE(niu_pci_tbl) = {
  53. {PCI_DEVICE(PCI_VENDOR_ID_SUN, 0xabcd)},
  54. {}
  55. };
  56. MODULE_DEVICE_TABLE(pci, niu_pci_tbl);
  57. #define NIU_TX_TIMEOUT (5 * HZ)
  58. #define nr64(reg) readq(np->regs + (reg))
  59. #define nw64(reg, val) writeq((val), np->regs + (reg))
  60. #define nr64_mac(reg) readq(np->mac_regs + (reg))
  61. #define nw64_mac(reg, val) writeq((val), np->mac_regs + (reg))
  62. #define nr64_ipp(reg) readq(np->regs + np->ipp_off + (reg))
  63. #define nw64_ipp(reg, val) writeq((val), np->regs + np->ipp_off + (reg))
  64. #define nr64_pcs(reg) readq(np->regs + np->pcs_off + (reg))
  65. #define nw64_pcs(reg, val) writeq((val), np->regs + np->pcs_off + (reg))
  66. #define nr64_xpcs(reg) readq(np->regs + np->xpcs_off + (reg))
  67. #define nw64_xpcs(reg, val) writeq((val), np->regs + np->xpcs_off + (reg))
  68. #define NIU_MSG_DEFAULT (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK)
  69. static int niu_debug;
  70. static int debug = -1;
  71. module_param(debug, int, 0);
  72. MODULE_PARM_DESC(debug, "NIU debug level");
  73. #define niu_lock_parent(np, flags) \
  74. spin_lock_irqsave(&np->parent->lock, flags)
  75. #define niu_unlock_parent(np, flags) \
  76. spin_unlock_irqrestore(&np->parent->lock, flags)
  77. static int serdes_init_10g_serdes(struct niu *np);
  78. static int __niu_wait_bits_clear_mac(struct niu *np, unsigned long reg,
  79. u64 bits, int limit, int delay)
  80. {
  81. while (--limit >= 0) {
  82. u64 val = nr64_mac(reg);
  83. if (!(val & bits))
  84. break;
  85. udelay(delay);
  86. }
  87. if (limit < 0)
  88. return -ENODEV;
  89. return 0;
  90. }
  91. static int __niu_set_and_wait_clear_mac(struct niu *np, unsigned long reg,
  92. u64 bits, int limit, int delay,
  93. const char *reg_name)
  94. {
  95. int err;
  96. nw64_mac(reg, bits);
  97. err = __niu_wait_bits_clear_mac(np, reg, bits, limit, delay);
  98. if (err)
  99. netdev_err(np->dev, "bits (%llx) of register %s would not clear, val[%llx]\n",
  100. (unsigned long long)bits, reg_name,
  101. (unsigned long long)nr64_mac(reg));
  102. return err;
  103. }
  104. #define niu_set_and_wait_clear_mac(NP, REG, BITS, LIMIT, DELAY, REG_NAME) \
  105. ({ BUILD_BUG_ON(LIMIT <= 0 || DELAY < 0); \
  106. __niu_set_and_wait_clear_mac(NP, REG, BITS, LIMIT, DELAY, REG_NAME); \
  107. })
  108. static int __niu_wait_bits_clear_ipp(struct niu *np, unsigned long reg,
  109. u64 bits, int limit, int delay)
  110. {
  111. while (--limit >= 0) {
  112. u64 val = nr64_ipp(reg);
  113. if (!(val & bits))
  114. break;
  115. udelay(delay);
  116. }
  117. if (limit < 0)
  118. return -ENODEV;
  119. return 0;
  120. }
  121. static int __niu_set_and_wait_clear_ipp(struct niu *np, unsigned long reg,
  122. u64 bits, int limit, int delay,
  123. const char *reg_name)
  124. {
  125. int err;
  126. u64 val;
  127. val = nr64_ipp(reg);
  128. val |= bits;
  129. nw64_ipp(reg, val);
  130. err = __niu_wait_bits_clear_ipp(np, reg, bits, limit, delay);
  131. if (err)
  132. netdev_err(np->dev, "bits (%llx) of register %s would not clear, val[%llx]\n",
  133. (unsigned long long)bits, reg_name,
  134. (unsigned long long)nr64_ipp(reg));
  135. return err;
  136. }
  137. #define niu_set_and_wait_clear_ipp(NP, REG, BITS, LIMIT, DELAY, REG_NAME) \
  138. ({ BUILD_BUG_ON(LIMIT <= 0 || DELAY < 0); \
  139. __niu_set_and_wait_clear_ipp(NP, REG, BITS, LIMIT, DELAY, REG_NAME); \
  140. })
  141. static int __niu_wait_bits_clear(struct niu *np, unsigned long reg,
  142. u64 bits, int limit, int delay)
  143. {
  144. while (--limit >= 0) {
  145. u64 val = nr64(reg);
  146. if (!(val & bits))
  147. break;
  148. udelay(delay);
  149. }
  150. if (limit < 0)
  151. return -ENODEV;
  152. return 0;
  153. }
  154. #define niu_wait_bits_clear(NP, REG, BITS, LIMIT, DELAY) \
  155. ({ BUILD_BUG_ON(LIMIT <= 0 || DELAY < 0); \
  156. __niu_wait_bits_clear(NP, REG, BITS, LIMIT, DELAY); \
  157. })
  158. static int __niu_set_and_wait_clear(struct niu *np, unsigned long reg,
  159. u64 bits, int limit, int delay,
  160. const char *reg_name)
  161. {
  162. int err;
  163. nw64(reg, bits);
  164. err = __niu_wait_bits_clear(np, reg, bits, limit, delay);
  165. if (err)
  166. netdev_err(np->dev, "bits (%llx) of register %s would not clear, val[%llx]\n",
  167. (unsigned long long)bits, reg_name,
  168. (unsigned long long)nr64(reg));
  169. return err;
  170. }
  171. #define niu_set_and_wait_clear(NP, REG, BITS, LIMIT, DELAY, REG_NAME) \
  172. ({ BUILD_BUG_ON(LIMIT <= 0 || DELAY < 0); \
  173. __niu_set_and_wait_clear(NP, REG, BITS, LIMIT, DELAY, REG_NAME); \
  174. })
  175. static void niu_ldg_rearm(struct niu *np, struct niu_ldg *lp, int on)
  176. {
  177. u64 val = (u64) lp->timer;
  178. if (on)
  179. val |= LDG_IMGMT_ARM;
  180. nw64(LDG_IMGMT(lp->ldg_num), val);
  181. }
  182. static int niu_ldn_irq_enable(struct niu *np, int ldn, int on)
  183. {
  184. unsigned long mask_reg, bits;
  185. u64 val;
  186. if (ldn < 0 || ldn > LDN_MAX)
  187. return -EINVAL;
  188. if (ldn < 64) {
  189. mask_reg = LD_IM0(ldn);
  190. bits = LD_IM0_MASK;
  191. } else {
  192. mask_reg = LD_IM1(ldn - 64);
  193. bits = LD_IM1_MASK;
  194. }
  195. val = nr64(mask_reg);
  196. if (on)
  197. val &= ~bits;
  198. else
  199. val |= bits;
  200. nw64(mask_reg, val);
  201. return 0;
  202. }
  203. static int niu_enable_ldn_in_ldg(struct niu *np, struct niu_ldg *lp, int on)
  204. {
  205. struct niu_parent *parent = np->parent;
  206. int i;
  207. for (i = 0; i <= LDN_MAX; i++) {
  208. int err;
  209. if (parent->ldg_map[i] != lp->ldg_num)
  210. continue;
  211. err = niu_ldn_irq_enable(np, i, on);
  212. if (err)
  213. return err;
  214. }
  215. return 0;
  216. }
  217. static int niu_enable_interrupts(struct niu *np, int on)
  218. {
  219. int i;
  220. for (i = 0; i < np->num_ldg; i++) {
  221. struct niu_ldg *lp = &np->ldg[i];
  222. int err;
  223. err = niu_enable_ldn_in_ldg(np, lp, on);
  224. if (err)
  225. return err;
  226. }
  227. for (i = 0; i < np->num_ldg; i++)
  228. niu_ldg_rearm(np, &np->ldg[i], on);
  229. return 0;
  230. }
  231. static u32 phy_encode(u32 type, int port)
  232. {
  233. return (type << (port * 2));
  234. }
  235. static u32 phy_decode(u32 val, int port)
  236. {
  237. return (val >> (port * 2)) & PORT_TYPE_MASK;
  238. }
  239. static int mdio_wait(struct niu *np)
  240. {
  241. int limit = 1000;
  242. u64 val;
  243. while (--limit > 0) {
  244. val = nr64(MIF_FRAME_OUTPUT);
  245. if ((val >> MIF_FRAME_OUTPUT_TA_SHIFT) & 0x1)
  246. return val & MIF_FRAME_OUTPUT_DATA;
  247. udelay(10);
  248. }
  249. return -ENODEV;
  250. }
  251. static int mdio_read(struct niu *np, int port, int dev, int reg)
  252. {
  253. int err;
  254. nw64(MIF_FRAME_OUTPUT, MDIO_ADDR_OP(port, dev, reg));
  255. err = mdio_wait(np);
  256. if (err < 0)
  257. return err;
  258. nw64(MIF_FRAME_OUTPUT, MDIO_READ_OP(port, dev));
  259. return mdio_wait(np);
  260. }
  261. static int mdio_write(struct niu *np, int port, int dev, int reg, int data)
  262. {
  263. int err;
  264. nw64(MIF_FRAME_OUTPUT, MDIO_ADDR_OP(port, dev, reg));
  265. err = mdio_wait(np);
  266. if (err < 0)
  267. return err;
  268. nw64(MIF_FRAME_OUTPUT, MDIO_WRITE_OP(port, dev, data));
  269. err = mdio_wait(np);
  270. if (err < 0)
  271. return err;
  272. return 0;
  273. }
  274. static int mii_read(struct niu *np, int port, int reg)
  275. {
  276. nw64(MIF_FRAME_OUTPUT, MII_READ_OP(port, reg));
  277. return mdio_wait(np);
  278. }
  279. static int mii_write(struct niu *np, int port, int reg, int data)
  280. {
  281. int err;
  282. nw64(MIF_FRAME_OUTPUT, MII_WRITE_OP(port, reg, data));
  283. err = mdio_wait(np);
  284. if (err < 0)
  285. return err;
  286. return 0;
  287. }
  288. static int esr2_set_tx_cfg(struct niu *np, unsigned long channel, u32 val)
  289. {
  290. int err;
  291. err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  292. ESR2_TI_PLL_TX_CFG_L(channel),
  293. val & 0xffff);
  294. if (!err)
  295. err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  296. ESR2_TI_PLL_TX_CFG_H(channel),
  297. val >> 16);
  298. return err;
  299. }
  300. static int esr2_set_rx_cfg(struct niu *np, unsigned long channel, u32 val)
  301. {
  302. int err;
  303. err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  304. ESR2_TI_PLL_RX_CFG_L(channel),
  305. val & 0xffff);
  306. if (!err)
  307. err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  308. ESR2_TI_PLL_RX_CFG_H(channel),
  309. val >> 16);
  310. return err;
  311. }
  312. /* Mode is always 10G fiber. */
  313. static int serdes_init_niu_10g_fiber(struct niu *np)
  314. {
  315. struct niu_link_config *lp = &np->link_config;
  316. u32 tx_cfg, rx_cfg;
  317. unsigned long i;
  318. tx_cfg = (PLL_TX_CFG_ENTX | PLL_TX_CFG_SWING_1375MV);
  319. rx_cfg = (PLL_RX_CFG_ENRX | PLL_RX_CFG_TERM_0P8VDDT |
  320. PLL_RX_CFG_ALIGN_ENA | PLL_RX_CFG_LOS_LTHRESH |
  321. PLL_RX_CFG_EQ_LP_ADAPTIVE);
  322. if (lp->loopback_mode == LOOPBACK_PHY) {
  323. u16 test_cfg = PLL_TEST_CFG_LOOPBACK_CML_DIS;
  324. mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  325. ESR2_TI_PLL_TEST_CFG_L, test_cfg);
  326. tx_cfg |= PLL_TX_CFG_ENTEST;
  327. rx_cfg |= PLL_RX_CFG_ENTEST;
  328. }
  329. /* Initialize all 4 lanes of the SERDES. */
  330. for (i = 0; i < 4; i++) {
  331. int err = esr2_set_tx_cfg(np, i, tx_cfg);
  332. if (err)
  333. return err;
  334. }
  335. for (i = 0; i < 4; i++) {
  336. int err = esr2_set_rx_cfg(np, i, rx_cfg);
  337. if (err)
  338. return err;
  339. }
  340. return 0;
  341. }
  342. static int serdes_init_niu_1g_serdes(struct niu *np)
  343. {
  344. struct niu_link_config *lp = &np->link_config;
  345. u16 pll_cfg, pll_sts;
  346. int max_retry = 100;
  347. u64 uninitialized_var(sig), mask, val;
  348. u32 tx_cfg, rx_cfg;
  349. unsigned long i;
  350. int err;
  351. tx_cfg = (PLL_TX_CFG_ENTX | PLL_TX_CFG_SWING_1375MV |
  352. PLL_TX_CFG_RATE_HALF);
  353. rx_cfg = (PLL_RX_CFG_ENRX | PLL_RX_CFG_TERM_0P8VDDT |
  354. PLL_RX_CFG_ALIGN_ENA | PLL_RX_CFG_LOS_LTHRESH |
  355. PLL_RX_CFG_RATE_HALF);
  356. if (np->port == 0)
  357. rx_cfg |= PLL_RX_CFG_EQ_LP_ADAPTIVE;
  358. if (lp->loopback_mode == LOOPBACK_PHY) {
  359. u16 test_cfg = PLL_TEST_CFG_LOOPBACK_CML_DIS;
  360. mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  361. ESR2_TI_PLL_TEST_CFG_L, test_cfg);
  362. tx_cfg |= PLL_TX_CFG_ENTEST;
  363. rx_cfg |= PLL_RX_CFG_ENTEST;
  364. }
  365. /* Initialize PLL for 1G */
  366. pll_cfg = (PLL_CFG_ENPLL | PLL_CFG_MPY_8X);
  367. err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  368. ESR2_TI_PLL_CFG_L, pll_cfg);
  369. if (err) {
  370. netdev_err(np->dev, "NIU Port %d %s() mdio write to ESR2_TI_PLL_CFG_L failed\n",
  371. np->port, __func__);
  372. return err;
  373. }
  374. pll_sts = PLL_CFG_ENPLL;
  375. err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  376. ESR2_TI_PLL_STS_L, pll_sts);
  377. if (err) {
  378. netdev_err(np->dev, "NIU Port %d %s() mdio write to ESR2_TI_PLL_STS_L failed\n",
  379. np->port, __func__);
  380. return err;
  381. }
  382. udelay(200);
  383. /* Initialize all 4 lanes of the SERDES. */
  384. for (i = 0; i < 4; i++) {
  385. err = esr2_set_tx_cfg(np, i, tx_cfg);
  386. if (err)
  387. return err;
  388. }
  389. for (i = 0; i < 4; i++) {
  390. err = esr2_set_rx_cfg(np, i, rx_cfg);
  391. if (err)
  392. return err;
  393. }
  394. switch (np->port) {
  395. case 0:
  396. val = (ESR_INT_SRDY0_P0 | ESR_INT_DET0_P0);
  397. mask = val;
  398. break;
  399. case 1:
  400. val = (ESR_INT_SRDY0_P1 | ESR_INT_DET0_P1);
  401. mask = val;
  402. break;
  403. default:
  404. return -EINVAL;
  405. }
  406. while (max_retry--) {
  407. sig = nr64(ESR_INT_SIGNALS);
  408. if ((sig & mask) == val)
  409. break;
  410. mdelay(500);
  411. }
  412. if ((sig & mask) != val) {
  413. netdev_err(np->dev, "Port %u signal bits [%08x] are not [%08x]\n",
  414. np->port, (int)(sig & mask), (int)val);
  415. return -ENODEV;
  416. }
  417. return 0;
  418. }
  419. static int serdes_init_niu_10g_serdes(struct niu *np)
  420. {
  421. struct niu_link_config *lp = &np->link_config;
  422. u32 tx_cfg, rx_cfg, pll_cfg, pll_sts;
  423. int max_retry = 100;
  424. u64 uninitialized_var(sig), mask, val;
  425. unsigned long i;
  426. int err;
  427. tx_cfg = (PLL_TX_CFG_ENTX | PLL_TX_CFG_SWING_1375MV);
  428. rx_cfg = (PLL_RX_CFG_ENRX | PLL_RX_CFG_TERM_0P8VDDT |
  429. PLL_RX_CFG_ALIGN_ENA | PLL_RX_CFG_LOS_LTHRESH |
  430. PLL_RX_CFG_EQ_LP_ADAPTIVE);
  431. if (lp->loopback_mode == LOOPBACK_PHY) {
  432. u16 test_cfg = PLL_TEST_CFG_LOOPBACK_CML_DIS;
  433. mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  434. ESR2_TI_PLL_TEST_CFG_L, test_cfg);
  435. tx_cfg |= PLL_TX_CFG_ENTEST;
  436. rx_cfg |= PLL_RX_CFG_ENTEST;
  437. }
  438. /* Initialize PLL for 10G */
  439. pll_cfg = (PLL_CFG_ENPLL | PLL_CFG_MPY_10X);
  440. err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  441. ESR2_TI_PLL_CFG_L, pll_cfg & 0xffff);
  442. if (err) {
  443. netdev_err(np->dev, "NIU Port %d %s() mdio write to ESR2_TI_PLL_CFG_L failed\n",
  444. np->port, __func__);
  445. return err;
  446. }
  447. pll_sts = PLL_CFG_ENPLL;
  448. err = mdio_write(np, np->port, NIU_ESR2_DEV_ADDR,
  449. ESR2_TI_PLL_STS_L, pll_sts & 0xffff);
  450. if (err) {
  451. netdev_err(np->dev, "NIU Port %d %s() mdio write to ESR2_TI_PLL_STS_L failed\n",
  452. np->port, __func__);
  453. return err;
  454. }
  455. udelay(200);
  456. /* Initialize all 4 lanes of the SERDES. */
  457. for (i = 0; i < 4; i++) {
  458. err = esr2_set_tx_cfg(np, i, tx_cfg);
  459. if (err)
  460. return err;
  461. }
  462. for (i = 0; i < 4; i++) {
  463. err = esr2_set_rx_cfg(np, i, rx_cfg);
  464. if (err)
  465. return err;
  466. }
  467. /* check if serdes is ready */
  468. switch (np->port) {
  469. case 0:
  470. mask = ESR_INT_SIGNALS_P0_BITS;
  471. val = (ESR_INT_SRDY0_P0 |
  472. ESR_INT_DET0_P0 |
  473. ESR_INT_XSRDY_P0 |
  474. ESR_INT_XDP_P0_CH3 |
  475. ESR_INT_XDP_P0_CH2 |
  476. ESR_INT_XDP_P0_CH1 |
  477. ESR_INT_XDP_P0_CH0);
  478. break;
  479. case 1:
  480. mask = ESR_INT_SIGNALS_P1_BITS;
  481. val = (ESR_INT_SRDY0_P1 |
  482. ESR_INT_DET0_P1 |
  483. ESR_INT_XSRDY_P1 |
  484. ESR_INT_XDP_P1_CH3 |
  485. ESR_INT_XDP_P1_CH2 |
  486. ESR_INT_XDP_P1_CH1 |
  487. ESR_INT_XDP_P1_CH0);
  488. break;
  489. default:
  490. return -EINVAL;
  491. }
  492. while (max_retry--) {
  493. sig = nr64(ESR_INT_SIGNALS);
  494. if ((sig & mask) == val)
  495. break;
  496. mdelay(500);
  497. }
  498. if ((sig & mask) != val) {
  499. pr_info("NIU Port %u signal bits [%08x] are not [%08x] for 10G...trying 1G\n",
  500. np->port, (int)(sig & mask), (int)val);
  501. /* 10G failed, try initializing at 1G */
  502. err = serdes_init_niu_1g_serdes(np);
  503. if (!err) {
  504. np->flags &= ~NIU_FLAGS_10G;
  505. np->mac_xcvr = MAC_XCVR_PCS;
  506. } else {
  507. netdev_err(np->dev, "Port %u 10G/1G SERDES Link Failed\n",
  508. np->port);
  509. return -ENODEV;
  510. }
  511. }
  512. return 0;
  513. }
  514. static int esr_read_rxtx_ctrl(struct niu *np, unsigned long chan, u32 *val)
  515. {
  516. int err;
  517. err = mdio_read(np, np->port, NIU_ESR_DEV_ADDR, ESR_RXTX_CTRL_L(chan));
  518. if (err >= 0) {
  519. *val = (err & 0xffff);
  520. err = mdio_read(np, np->port, NIU_ESR_DEV_ADDR,
  521. ESR_RXTX_CTRL_H(chan));
  522. if (err >= 0)
  523. *val |= ((err & 0xffff) << 16);
  524. err = 0;
  525. }
  526. return err;
  527. }
  528. static int esr_read_glue0(struct niu *np, unsigned long chan, u32 *val)
  529. {
  530. int err;
  531. err = mdio_read(np, np->port, NIU_ESR_DEV_ADDR,
  532. ESR_GLUE_CTRL0_L(chan));
  533. if (err >= 0) {
  534. *val = (err & 0xffff);
  535. err = mdio_read(np, np->port, NIU_ESR_DEV_ADDR,
  536. ESR_GLUE_CTRL0_H(chan));
  537. if (err >= 0) {
  538. *val |= ((err & 0xffff) << 16);
  539. err = 0;
  540. }
  541. }
  542. return err;
  543. }
  544. static int esr_read_reset(struct niu *np, u32 *val)
  545. {
  546. int err;
  547. err = mdio_read(np, np->port, NIU_ESR_DEV_ADDR,
  548. ESR_RXTX_RESET_CTRL_L);
  549. if (err >= 0) {
  550. *val = (err & 0xffff);
  551. err = mdio_read(np, np->port, NIU_ESR_DEV_ADDR,
  552. ESR_RXTX_RESET_CTRL_H);
  553. if (err >= 0) {
  554. *val |= ((err & 0xffff) << 16);
  555. err = 0;
  556. }
  557. }
  558. return err;
  559. }
  560. static int esr_write_rxtx_ctrl(struct niu *np, unsigned long chan, u32 val)
  561. {
  562. int err;
  563. err = mdio_write(np, np->port, NIU_ESR_DEV_ADDR,
  564. ESR_RXTX_CTRL_L(chan), val & 0xffff);
  565. if (!err)
  566. err = mdio_write(np, np->port, NIU_ESR_DEV_ADDR,
  567. ESR_RXTX_CTRL_H(chan), (val >> 16));
  568. return err;
  569. }
  570. static int esr_write_glue0(struct niu *np, unsigned long chan, u32 val)
  571. {
  572. int err;
  573. err = mdio_write(np, np->port, NIU_ESR_DEV_ADDR,
  574. ESR_GLUE_CTRL0_L(chan), val & 0xffff);
  575. if (!err)
  576. err = mdio_write(np, np->port, NIU_ESR_DEV_ADDR,
  577. ESR_GLUE_CTRL0_H(chan), (val >> 16));
  578. return err;
  579. }
  580. static int esr_reset(struct niu *np)
  581. {
  582. u32 uninitialized_var(reset);
  583. int err;
  584. err = mdio_write(np, np->port, NIU_ESR_DEV_ADDR,
  585. ESR_RXTX_RESET_CTRL_L, 0x0000);
  586. if (err)
  587. return err;
  588. err = mdio_write(np, np->port, NIU_ESR_DEV_ADDR,
  589. ESR_RXTX_RESET_CTRL_H, 0xffff);
  590. if (err)
  591. return err;
  592. udelay(200);
  593. err = mdio_write(np, np->port, NIU_ESR_DEV_ADDR,
  594. ESR_RXTX_RESET_CTRL_L, 0xffff);
  595. if (err)
  596. return err;
  597. udelay(200);
  598. err = mdio_write(np, np->port, NIU_ESR_DEV_ADDR,
  599. ESR_RXTX_RESET_CTRL_H, 0x0000);
  600. if (err)
  601. return err;
  602. udelay(200);
  603. err = esr_read_reset(np, &reset);
  604. if (err)
  605. return err;
  606. if (reset != 0) {
  607. netdev_err(np->dev, "Port %u ESR_RESET did not clear [%08x]\n",
  608. np->port, reset);
  609. return -ENODEV;
  610. }
  611. return 0;
  612. }
  613. static int serdes_init_10g(struct niu *np)
  614. {
  615. struct niu_link_config *lp = &np->link_config;
  616. unsigned long ctrl_reg, test_cfg_reg, i;
  617. u64 ctrl_val, test_cfg_val, sig, mask, val;
  618. int err;
  619. switch (np->port) {
  620. case 0:
  621. ctrl_reg = ENET_SERDES_0_CTRL_CFG;
  622. test_cfg_reg = ENET_SERDES_0_TEST_CFG;
  623. break;
  624. case 1:
  625. ctrl_reg = ENET_SERDES_1_CTRL_CFG;
  626. test_cfg_reg = ENET_SERDES_1_TEST_CFG;
  627. break;
  628. default:
  629. return -EINVAL;
  630. }
  631. ctrl_val = (ENET_SERDES_CTRL_SDET_0 |
  632. ENET_SERDES_CTRL_SDET_1 |
  633. ENET_SERDES_CTRL_SDET_2 |
  634. ENET_SERDES_CTRL_SDET_3 |
  635. (0x5 << ENET_SERDES_CTRL_EMPH_0_SHIFT) |
  636. (0x5 << ENET_SERDES_CTRL_EMPH_1_SHIFT) |
  637. (0x5 << ENET_SERDES_CTRL_EMPH_2_SHIFT) |
  638. (0x5 << ENET_SERDES_CTRL_EMPH_3_SHIFT) |
  639. (0x1 << ENET_SERDES_CTRL_LADJ_0_SHIFT) |
  640. (0x1 << ENET_SERDES_CTRL_LADJ_1_SHIFT) |
  641. (0x1 << ENET_SERDES_CTRL_LADJ_2_SHIFT) |
  642. (0x1 << ENET_SERDES_CTRL_LADJ_3_SHIFT));
  643. test_cfg_val = 0;
  644. if (lp->loopback_mode == LOOPBACK_PHY) {
  645. test_cfg_val |= ((ENET_TEST_MD_PAD_LOOPBACK <<
  646. ENET_SERDES_TEST_MD_0_SHIFT) |
  647. (ENET_TEST_MD_PAD_LOOPBACK <<
  648. ENET_SERDES_TEST_MD_1_SHIFT) |
  649. (ENET_TEST_MD_PAD_LOOPBACK <<
  650. ENET_SERDES_TEST_MD_2_SHIFT) |
  651. (ENET_TEST_MD_PAD_LOOPBACK <<
  652. ENET_SERDES_TEST_MD_3_SHIFT));
  653. }
  654. nw64(ctrl_reg, ctrl_val);
  655. nw64(test_cfg_reg, test_cfg_val);
  656. /* Initialize all 4 lanes of the SERDES. */
  657. for (i = 0; i < 4; i++) {
  658. u32 rxtx_ctrl, glue0;
  659. err = esr_read_rxtx_ctrl(np, i, &rxtx_ctrl);
  660. if (err)
  661. return err;
  662. err = esr_read_glue0(np, i, &glue0);
  663. if (err)
  664. return err;
  665. rxtx_ctrl &= ~(ESR_RXTX_CTRL_VMUXLO);
  666. rxtx_ctrl |= (ESR_RXTX_CTRL_ENSTRETCH |
  667. (2 << ESR_RXTX_CTRL_VMUXLO_SHIFT));
  668. glue0 &= ~(ESR_GLUE_CTRL0_SRATE |
  669. ESR_GLUE_CTRL0_THCNT |
  670. ESR_GLUE_CTRL0_BLTIME);
  671. glue0 |= (ESR_GLUE_CTRL0_RXLOSENAB |
  672. (0xf << ESR_GLUE_CTRL0_SRATE_SHIFT) |
  673. (0xff << ESR_GLUE_CTRL0_THCNT_SHIFT) |
  674. (BLTIME_300_CYCLES <<
  675. ESR_GLUE_CTRL0_BLTIME_SHIFT));
  676. err = esr_write_rxtx_ctrl(np, i, rxtx_ctrl);
  677. if (err)
  678. return err;
  679. err = esr_write_glue0(np, i, glue0);
  680. if (err)
  681. return err;
  682. }
  683. err = esr_reset(np);
  684. if (err)
  685. return err;
  686. sig = nr64(ESR_INT_SIGNALS);
  687. switch (np->port) {
  688. case 0:
  689. mask = ESR_INT_SIGNALS_P0_BITS;
  690. val = (ESR_INT_SRDY0_P0 |
  691. ESR_INT_DET0_P0 |
  692. ESR_INT_XSRDY_P0 |
  693. ESR_INT_XDP_P0_CH3 |
  694. ESR_INT_XDP_P0_CH2 |
  695. ESR_INT_XDP_P0_CH1 |
  696. ESR_INT_XDP_P0_CH0);
  697. break;
  698. case 1:
  699. mask = ESR_INT_SIGNALS_P1_BITS;
  700. val = (ESR_INT_SRDY0_P1 |
  701. ESR_INT_DET0_P1 |
  702. ESR_INT_XSRDY_P1 |
  703. ESR_INT_XDP_P1_CH3 |
  704. ESR_INT_XDP_P1_CH2 |
  705. ESR_INT_XDP_P1_CH1 |
  706. ESR_INT_XDP_P1_CH0);
  707. break;
  708. default:
  709. return -EINVAL;
  710. }
  711. if ((sig & mask) != val) {
  712. if (np->flags & NIU_FLAGS_HOTPLUG_PHY) {
  713. np->flags &= ~NIU_FLAGS_HOTPLUG_PHY_PRESENT;
  714. return 0;
  715. }
  716. netdev_err(np->dev, "Port %u signal bits [%08x] are not [%08x]\n",
  717. np->port, (int)(sig & mask), (int)val);
  718. return -ENODEV;
  719. }
  720. if (np->flags & NIU_FLAGS_HOTPLUG_PHY)
  721. np->flags |= NIU_FLAGS_HOTPLUG_PHY_PRESENT;
  722. return 0;
  723. }
  724. static int serdes_init_1g(struct niu *np)
  725. {
  726. u64 val;
  727. val = nr64(ENET_SERDES_1_PLL_CFG);
  728. val &= ~ENET_SERDES_PLL_FBDIV2;
  729. switch (np->port) {
  730. case 0:
  731. val |= ENET_SERDES_PLL_HRATE0;
  732. break;
  733. case 1:
  734. val |= ENET_SERDES_PLL_HRATE1;
  735. break;
  736. case 2:
  737. val |= ENET_SERDES_PLL_HRATE2;
  738. break;
  739. case 3:
  740. val |= ENET_SERDES_PLL_HRATE3;
  741. break;
  742. default:
  743. return -EINVAL;
  744. }
  745. nw64(ENET_SERDES_1_PLL_CFG, val);
  746. return 0;
  747. }
  748. static int serdes_init_1g_serdes(struct niu *np)
  749. {
  750. struct niu_link_config *lp = &np->link_config;
  751. unsigned long ctrl_reg, test_cfg_reg, pll_cfg, i;
  752. u64 ctrl_val, test_cfg_val, sig, mask, val;
  753. int err;
  754. u64 reset_val, val_rd;
  755. val = ENET_SERDES_PLL_HRATE0 | ENET_SERDES_PLL_HRATE1 |
  756. ENET_SERDES_PLL_HRATE2 | ENET_SERDES_PLL_HRATE3 |
  757. ENET_SERDES_PLL_FBDIV0;
  758. switch (np->port) {
  759. case 0:
  760. reset_val = ENET_SERDES_RESET_0;
  761. ctrl_reg = ENET_SERDES_0_CTRL_CFG;
  762. test_cfg_reg = ENET_SERDES_0_TEST_CFG;
  763. pll_cfg = ENET_SERDES_0_PLL_CFG;
  764. break;
  765. case 1:
  766. reset_val = ENET_SERDES_RESET_1;
  767. ctrl_reg = ENET_SERDES_1_CTRL_CFG;
  768. test_cfg_reg = ENET_SERDES_1_TEST_CFG;
  769. pll_cfg = ENET_SERDES_1_PLL_CFG;
  770. break;
  771. default:
  772. return -EINVAL;
  773. }
  774. ctrl_val = (ENET_SERDES_CTRL_SDET_0 |
  775. ENET_SERDES_CTRL_SDET_1 |
  776. ENET_SERDES_CTRL_SDET_2 |
  777. ENET_SERDES_CTRL_SDET_3 |
  778. (0x5 << ENET_SERDES_CTRL_EMPH_0_SHIFT) |
  779. (0x5 << ENET_SERDES_CTRL_EMPH_1_SHIFT) |
  780. (0x5 << ENET_SERDES_CTRL_EMPH_2_SHIFT) |
  781. (0x5 << ENET_SERDES_CTRL_EMPH_3_SHIFT) |
  782. (0x1 << ENET_SERDES_CTRL_LADJ_0_SHIFT) |
  783. (0x1 << ENET_SERDES_CTRL_LADJ_1_SHIFT) |
  784. (0x1 << ENET_SERDES_CTRL_LADJ_2_SHIFT) |
  785. (0x1 << ENET_SERDES_CTRL_LADJ_3_SHIFT));
  786. test_cfg_val = 0;
  787. if (lp->loopback_mode == LOOPBACK_PHY) {
  788. test_cfg_val |= ((ENET_TEST_MD_PAD_LOOPBACK <<
  789. ENET_SERDES_TEST_MD_0_SHIFT) |
  790. (ENET_TEST_MD_PAD_LOOPBACK <<
  791. ENET_SERDES_TEST_MD_1_SHIFT) |
  792. (ENET_TEST_MD_PAD_LOOPBACK <<
  793. ENET_SERDES_TEST_MD_2_SHIFT) |
  794. (ENET_TEST_MD_PAD_LOOPBACK <<
  795. ENET_SERDES_TEST_MD_3_SHIFT));
  796. }
  797. nw64(ENET_SERDES_RESET, reset_val);
  798. mdelay(20);
  799. val_rd = nr64(ENET_SERDES_RESET);
  800. val_rd &= ~reset_val;
  801. nw64(pll_cfg, val);
  802. nw64(ctrl_reg, ctrl_val);
  803. nw64(test_cfg_reg, test_cfg_val);
  804. nw64(ENET_SERDES_RESET, val_rd);
  805. mdelay(2000);
  806. /* Initialize all 4 lanes of the SERDES. */
  807. for (i = 0; i < 4; i++) {
  808. u32 rxtx_ctrl, glue0;
  809. err = esr_read_rxtx_ctrl(np, i, &rxtx_ctrl);
  810. if (err)
  811. return err;
  812. err = esr_read_glue0(np, i, &glue0);
  813. if (err)
  814. return err;
  815. rxtx_ctrl &= ~(ESR_RXTX_CTRL_VMUXLO);
  816. rxtx_ctrl |= (ESR_RXTX_CTRL_ENSTRETCH |
  817. (2 << ESR_RXTX_CTRL_VMUXLO_SHIFT));
  818. glue0 &= ~(ESR_GLUE_CTRL0_SRATE |
  819. ESR_GLUE_CTRL0_THCNT |
  820. ESR_GLUE_CTRL0_BLTIME);
  821. glue0 |= (ESR_GLUE_CTRL0_RXLOSENAB |
  822. (0xf << ESR_GLUE_CTRL0_SRATE_SHIFT) |
  823. (0xff << ESR_GLUE_CTRL0_THCNT_SHIFT) |
  824. (BLTIME_300_CYCLES <<
  825. ESR_GLUE_CTRL0_BLTIME_SHIFT));
  826. err = esr_write_rxtx_ctrl(np, i, rxtx_ctrl);
  827. if (err)
  828. return err;
  829. err = esr_write_glue0(np, i, glue0);
  830. if (err)
  831. return err;
  832. }
  833. sig = nr64(ESR_INT_SIGNALS);
  834. switch (np->port) {
  835. case 0:
  836. val = (ESR_INT_SRDY0_P0 | ESR_INT_DET0_P0);
  837. mask = val;
  838. break;
  839. case 1:
  840. val = (ESR_INT_SRDY0_P1 | ESR_INT_DET0_P1);
  841. mask = val;
  842. break;
  843. default:
  844. return -EINVAL;
  845. }
  846. if ((sig & mask) != val) {
  847. netdev_err(np->dev, "Port %u signal bits [%08x] are not [%08x]\n",
  848. np->port, (int)(sig & mask), (int)val);
  849. return -ENODEV;
  850. }
  851. return 0;
  852. }
  853. static int link_status_1g_serdes(struct niu *np, int *link_up_p)
  854. {
  855. struct niu_link_config *lp = &np->link_config;
  856. int link_up;
  857. u64 val;
  858. u16 current_speed;
  859. unsigned long flags;
  860. u8 current_duplex;
  861. link_up = 0;
  862. current_speed = SPEED_INVALID;
  863. current_duplex = DUPLEX_INVALID;
  864. spin_lock_irqsave(&np->lock, flags);
  865. val = nr64_pcs(PCS_MII_STAT);
  866. if (val & PCS_MII_STAT_LINK_STATUS) {
  867. link_up = 1;
  868. current_speed = SPEED_1000;
  869. current_duplex = DUPLEX_FULL;
  870. }
  871. lp->active_speed = current_speed;
  872. lp->active_duplex = current_duplex;
  873. spin_unlock_irqrestore(&np->lock, flags);
  874. *link_up_p = link_up;
  875. return 0;
  876. }
  877. static int link_status_10g_serdes(struct niu *np, int *link_up_p)
  878. {
  879. unsigned long flags;
  880. struct niu_link_config *lp = &np->link_config;
  881. int link_up = 0;
  882. int link_ok = 1;
  883. u64 val, val2;
  884. u16 current_speed;
  885. u8 current_duplex;
  886. if (!(np->flags & NIU_FLAGS_10G))
  887. return link_status_1g_serdes(np, link_up_p);
  888. current_speed = SPEED_INVALID;
  889. current_duplex = DUPLEX_INVALID;
  890. spin_lock_irqsave(&np->lock, flags);
  891. val = nr64_xpcs(XPCS_STATUS(0));
  892. val2 = nr64_mac(XMAC_INTER2);
  893. if (val2 & 0x01000000)
  894. link_ok = 0;
  895. if ((val & 0x1000ULL) && link_ok) {
  896. link_up = 1;
  897. current_speed = SPEED_10000;
  898. current_duplex = DUPLEX_FULL;
  899. }
  900. lp->active_speed = current_speed;
  901. lp->active_duplex = current_duplex;
  902. spin_unlock_irqrestore(&np->lock, flags);
  903. *link_up_p = link_up;
  904. return 0;
  905. }
  906. static int link_status_mii(struct niu *np, int *link_up_p)
  907. {
  908. struct niu_link_config *lp = &np->link_config;
  909. int err;
  910. int bmsr, advert, ctrl1000, stat1000, lpa, bmcr, estatus;
  911. int supported, advertising, active_speed, active_duplex;
  912. err = mii_read(np, np->phy_addr, MII_BMCR);
  913. if (unlikely(err < 0))
  914. return err;
  915. bmcr = err;
  916. err = mii_read(np, np->phy_addr, MII_BMSR);
  917. if (unlikely(err < 0))
  918. return err;
  919. bmsr = err;
  920. err = mii_read(np, np->phy_addr, MII_ADVERTISE);
  921. if (unlikely(err < 0))
  922. return err;
  923. advert = err;
  924. err = mii_read(np, np->phy_addr, MII_LPA);
  925. if (unlikely(err < 0))
  926. return err;
  927. lpa = err;
  928. if (likely(bmsr & BMSR_ESTATEN)) {
  929. err = mii_read(np, np->phy_addr, MII_ESTATUS);
  930. if (unlikely(err < 0))
  931. return err;
  932. estatus = err;
  933. err = mii_read(np, np->phy_addr, MII_CTRL1000);
  934. if (unlikely(err < 0))
  935. return err;
  936. ctrl1000 = err;
  937. err = mii_read(np, np->phy_addr, MII_STAT1000);
  938. if (unlikely(err < 0))
  939. return err;
  940. stat1000 = err;
  941. } else
  942. estatus = ctrl1000 = stat1000 = 0;
  943. supported = 0;
  944. if (bmsr & BMSR_ANEGCAPABLE)
  945. supported |= SUPPORTED_Autoneg;
  946. if (bmsr & BMSR_10HALF)
  947. supported |= SUPPORTED_10baseT_Half;
  948. if (bmsr & BMSR_10FULL)
  949. supported |= SUPPORTED_10baseT_Full;
  950. if (bmsr & BMSR_100HALF)
  951. supported |= SUPPORTED_100baseT_Half;
  952. if (bmsr & BMSR_100FULL)
  953. supported |= SUPPORTED_100baseT_Full;
  954. if (estatus & ESTATUS_1000_THALF)
  955. supported |= SUPPORTED_1000baseT_Half;
  956. if (estatus & ESTATUS_1000_TFULL)
  957. supported |= SUPPORTED_1000baseT_Full;
  958. lp->supported = supported;
  959. advertising = 0;
  960. if (advert & ADVERTISE_10HALF)
  961. advertising |= ADVERTISED_10baseT_Half;
  962. if (advert & ADVERTISE_10FULL)
  963. advertising |= ADVERTISED_10baseT_Full;
  964. if (advert & ADVERTISE_100HALF)
  965. advertising |= ADVERTISED_100baseT_Half;
  966. if (advert & ADVERTISE_100FULL)
  967. advertising |= ADVERTISED_100baseT_Full;
  968. if (ctrl1000 & ADVERTISE_1000HALF)
  969. advertising |= ADVERTISED_1000baseT_Half;
  970. if (ctrl1000 & ADVERTISE_1000FULL)
  971. advertising |= ADVERTISED_1000baseT_Full;
  972. if (bmcr & BMCR_ANENABLE) {
  973. int neg, neg1000;
  974. lp->active_autoneg = 1;
  975. advertising |= ADVERTISED_Autoneg;
  976. neg = advert & lpa;
  977. neg1000 = (ctrl1000 << 2) & stat1000;
  978. if (neg1000 & (LPA_1000FULL | LPA_1000HALF))
  979. active_speed = SPEED_1000;
  980. else if (neg & LPA_100)
  981. active_speed = SPEED_100;
  982. else if (neg & (LPA_10HALF | LPA_10FULL))
  983. active_speed = SPEED_10;
  984. else
  985. active_speed = SPEED_INVALID;
  986. if ((neg1000 & LPA_1000FULL) || (neg & LPA_DUPLEX))
  987. active_duplex = DUPLEX_FULL;
  988. else if (active_speed != SPEED_INVALID)
  989. active_duplex = DUPLEX_HALF;
  990. else
  991. active_duplex = DUPLEX_INVALID;
  992. } else {
  993. lp->active_autoneg = 0;
  994. if ((bmcr & BMCR_SPEED1000) && !(bmcr & BMCR_SPEED100))
  995. active_speed = SPEED_1000;
  996. else if (bmcr & BMCR_SPEED100)
  997. active_speed = SPEED_100;
  998. else
  999. active_speed = SPEED_10;
  1000. if (bmcr & BMCR_FULLDPLX)
  1001. active_duplex = DUPLEX_FULL;
  1002. else
  1003. active_duplex = DUPLEX_HALF;
  1004. }
  1005. lp->active_advertising = advertising;
  1006. lp->active_speed = active_speed;
  1007. lp->active_duplex = active_duplex;
  1008. *link_up_p = !!(bmsr & BMSR_LSTATUS);
  1009. return 0;
  1010. }
  1011. static int link_status_1g_rgmii(struct niu *np, int *link_up_p)
  1012. {
  1013. struct niu_link_config *lp = &np->link_config;
  1014. u16 current_speed, bmsr;
  1015. unsigned long flags;
  1016. u8 current_duplex;
  1017. int err, link_up;
  1018. link_up = 0;
  1019. current_speed = SPEED_INVALID;
  1020. current_duplex = DUPLEX_INVALID;
  1021. spin_lock_irqsave(&np->lock, flags);
  1022. err = -EINVAL;
  1023. err = mii_read(np, np->phy_addr, MII_BMSR);
  1024. if (err < 0)
  1025. goto out;
  1026. bmsr = err;
  1027. if (bmsr & BMSR_LSTATUS) {
  1028. u16 adv, lpa, common, estat;
  1029. err = mii_read(np, np->phy_addr, MII_ADVERTISE);
  1030. if (err < 0)
  1031. goto out;
  1032. adv = err;
  1033. err = mii_read(np, np->phy_addr, MII_LPA);
  1034. if (err < 0)
  1035. goto out;
  1036. lpa = err;
  1037. common = adv & lpa;
  1038. err = mii_read(np, np->phy_addr, MII_ESTATUS);
  1039. if (err < 0)
  1040. goto out;
  1041. estat = err;
  1042. link_up = 1;
  1043. current_speed = SPEED_1000;
  1044. current_duplex = DUPLEX_FULL;
  1045. }
  1046. lp->active_speed = current_speed;
  1047. lp->active_duplex = current_duplex;
  1048. err = 0;
  1049. out:
  1050. spin_unlock_irqrestore(&np->lock, flags);
  1051. *link_up_p = link_up;
  1052. return err;
  1053. }
  1054. static int link_status_1g(struct niu *np, int *link_up_p)
  1055. {
  1056. struct niu_link_config *lp = &np->link_config;
  1057. unsigned long flags;
  1058. int err;
  1059. spin_lock_irqsave(&np->lock, flags);
  1060. err = link_status_mii(np, link_up_p);
  1061. lp->supported |= SUPPORTED_TP;
  1062. lp->active_advertising |= ADVERTISED_TP;
  1063. spin_unlock_irqrestore(&np->lock, flags);
  1064. return err;
  1065. }
  1066. static int bcm8704_reset(struct niu *np)
  1067. {
  1068. int err, limit;
  1069. err = mdio_read(np, np->phy_addr,
  1070. BCM8704_PHYXS_DEV_ADDR, MII_BMCR);
  1071. if (err < 0 || err == 0xffff)
  1072. return err;
  1073. err |= BMCR_RESET;
  1074. err = mdio_write(np, np->phy_addr, BCM8704_PHYXS_DEV_ADDR,
  1075. MII_BMCR, err);
  1076. if (err)
  1077. return err;
  1078. limit = 1000;
  1079. while (--limit >= 0) {
  1080. err = mdio_read(np, np->phy_addr,
  1081. BCM8704_PHYXS_DEV_ADDR, MII_BMCR);
  1082. if (err < 0)
  1083. return err;
  1084. if (!(err & BMCR_RESET))
  1085. break;
  1086. }
  1087. if (limit < 0) {
  1088. netdev_err(np->dev, "Port %u PHY will not reset (bmcr=%04x)\n",
  1089. np->port, (err & 0xffff));
  1090. return -ENODEV;
  1091. }
  1092. return 0;
  1093. }
  1094. /* When written, certain PHY registers need to be read back twice
  1095. * in order for the bits to settle properly.
  1096. */
  1097. static int bcm8704_user_dev3_readback(struct niu *np, int reg)
  1098. {
  1099. int err = mdio_read(np, np->phy_addr, BCM8704_USER_DEV3_ADDR, reg);
  1100. if (err < 0)
  1101. return err;
  1102. err = mdio_read(np, np->phy_addr, BCM8704_USER_DEV3_ADDR, reg);
  1103. if (err < 0)
  1104. return err;
  1105. return 0;
  1106. }
  1107. static int bcm8706_init_user_dev3(struct niu *np)
  1108. {
  1109. int err;
  1110. err = mdio_read(np, np->phy_addr, BCM8704_USER_DEV3_ADDR,
  1111. BCM8704_USER_OPT_DIGITAL_CTRL);
  1112. if (err < 0)
  1113. return err;
  1114. err &= ~USER_ODIG_CTRL_GPIOS;
  1115. err |= (0x3 << USER_ODIG_CTRL_GPIOS_SHIFT);
  1116. err |= USER_ODIG_CTRL_RESV2;
  1117. err = mdio_write(np, np->phy_addr, BCM8704_USER_DEV3_ADDR,
  1118. BCM8704_USER_OPT_DIGITAL_CTRL, err);
  1119. if (err)
  1120. return err;
  1121. mdelay(1000);
  1122. return 0;
  1123. }
  1124. static int bcm8704_init_user_dev3(struct niu *np)
  1125. {
  1126. int err;
  1127. err = mdio_write(np, np->phy_addr,
  1128. BCM8704_USER_DEV3_ADDR, BCM8704_USER_CONTROL,
  1129. (USER_CONTROL_OPTXRST_LVL |
  1130. USER_CONTROL_OPBIASFLT_LVL |
  1131. USER_CONTROL_OBTMPFLT_LVL |
  1132. USER_CONTROL_OPPRFLT_LVL |
  1133. USER_CONTROL_OPTXFLT_LVL |
  1134. USER_CONTROL_OPRXLOS_LVL |
  1135. USER_CONTROL_OPRXFLT_LVL |
  1136. USER_CONTROL_OPTXON_LVL |
  1137. (0x3f << USER_CONTROL_RES1_SHIFT)));
  1138. if (err)
  1139. return err;
  1140. err = mdio_write(np, np->phy_addr,
  1141. BCM8704_USER_DEV3_ADDR, BCM8704_USER_PMD_TX_CONTROL,
  1142. (USER_PMD_TX_CTL_XFP_CLKEN |
  1143. (1 << USER_PMD_TX_CTL_TX_DAC_TXD_SH) |
  1144. (2 << USER_PMD_TX_CTL_TX_DAC_TXCK_SH) |
  1145. USER_PMD_TX_CTL_TSCK_LPWREN));
  1146. if (err)
  1147. return err;
  1148. err = bcm8704_user_dev3_readback(np, BCM8704_USER_CONTROL);
  1149. if (err)
  1150. return err;
  1151. err = bcm8704_user_dev3_readback(np, BCM8704_USER_PMD_TX_CONTROL);
  1152. if (err)
  1153. return err;
  1154. err = mdio_read(np, np->phy_addr, BCM8704_USER_DEV3_ADDR,
  1155. BCM8704_USER_OPT_DIGITAL_CTRL);
  1156. if (err < 0)
  1157. return err;
  1158. err &= ~USER_ODIG_CTRL_GPIOS;
  1159. err |= (0x3 << USER_ODIG_CTRL_GPIOS_SHIFT);
  1160. err = mdio_write(np, np->phy_addr, BCM8704_USER_DEV3_ADDR,
  1161. BCM8704_USER_OPT_DIGITAL_CTRL, err);
  1162. if (err)
  1163. return err;
  1164. mdelay(1000);
  1165. return 0;
  1166. }
  1167. static int mrvl88x2011_act_led(struct niu *np, int val)
  1168. {
  1169. int err;
  1170. err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV2_ADDR,
  1171. MRVL88X2011_LED_8_TO_11_CTL);
  1172. if (err < 0)
  1173. return err;
  1174. err &= ~MRVL88X2011_LED(MRVL88X2011_LED_ACT,MRVL88X2011_LED_CTL_MASK);
  1175. err |= MRVL88X2011_LED(MRVL88X2011_LED_ACT,val);
  1176. return mdio_write(np, np->phy_addr, MRVL88X2011_USER_DEV2_ADDR,
  1177. MRVL88X2011_LED_8_TO_11_CTL, err);
  1178. }
  1179. static int mrvl88x2011_led_blink_rate(struct niu *np, int rate)
  1180. {
  1181. int err;
  1182. err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV2_ADDR,
  1183. MRVL88X2011_LED_BLINK_CTL);
  1184. if (err >= 0) {
  1185. err &= ~MRVL88X2011_LED_BLKRATE_MASK;
  1186. err |= (rate << 4);
  1187. err = mdio_write(np, np->phy_addr, MRVL88X2011_USER_DEV2_ADDR,
  1188. MRVL88X2011_LED_BLINK_CTL, err);
  1189. }
  1190. return err;
  1191. }
  1192. static int xcvr_init_10g_mrvl88x2011(struct niu *np)
  1193. {
  1194. int err;
  1195. /* Set LED functions */
  1196. err = mrvl88x2011_led_blink_rate(np, MRVL88X2011_LED_BLKRATE_134MS);
  1197. if (err)
  1198. return err;
  1199. /* led activity */
  1200. err = mrvl88x2011_act_led(np, MRVL88X2011_LED_CTL_OFF);
  1201. if (err)
  1202. return err;
  1203. err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV3_ADDR,
  1204. MRVL88X2011_GENERAL_CTL);
  1205. if (err < 0)
  1206. return err;
  1207. err |= MRVL88X2011_ENA_XFPREFCLK;
  1208. err = mdio_write(np, np->phy_addr, MRVL88X2011_USER_DEV3_ADDR,
  1209. MRVL88X2011_GENERAL_CTL, err);
  1210. if (err < 0)
  1211. return err;
  1212. err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV1_ADDR,
  1213. MRVL88X2011_PMA_PMD_CTL_1);
  1214. if (err < 0)
  1215. return err;
  1216. if (np->link_config.loopback_mode == LOOPBACK_MAC)
  1217. err |= MRVL88X2011_LOOPBACK;
  1218. else
  1219. err &= ~MRVL88X2011_LOOPBACK;
  1220. err = mdio_write(np, np->phy_addr, MRVL88X2011_USER_DEV1_ADDR,
  1221. MRVL88X2011_PMA_PMD_CTL_1, err);
  1222. if (err < 0)
  1223. return err;
  1224. /* Enable PMD */
  1225. return mdio_write(np, np->phy_addr, MRVL88X2011_USER_DEV1_ADDR,
  1226. MRVL88X2011_10G_PMD_TX_DIS, MRVL88X2011_ENA_PMDTX);
  1227. }
  1228. static int xcvr_diag_bcm870x(struct niu *np)
  1229. {
  1230. u16 analog_stat0, tx_alarm_status;
  1231. int err = 0;
  1232. #if 1
  1233. err = mdio_read(np, np->phy_addr, BCM8704_PMA_PMD_DEV_ADDR,
  1234. MII_STAT1000);
  1235. if (err < 0)
  1236. return err;
  1237. pr_info("Port %u PMA_PMD(MII_STAT1000) [%04x]\n", np->port, err);
  1238. err = mdio_read(np, np->phy_addr, BCM8704_USER_DEV3_ADDR, 0x20);
  1239. if (err < 0)
  1240. return err;
  1241. pr_info("Port %u USER_DEV3(0x20) [%04x]\n", np->port, err);
  1242. err = mdio_read(np, np->phy_addr, BCM8704_PHYXS_DEV_ADDR,
  1243. MII_NWAYTEST);
  1244. if (err < 0)
  1245. return err;
  1246. pr_info("Port %u PHYXS(MII_NWAYTEST) [%04x]\n", np->port, err);
  1247. #endif
  1248. /* XXX dig this out it might not be so useful XXX */
  1249. err = mdio_read(np, np->phy_addr, BCM8704_USER_DEV3_ADDR,
  1250. BCM8704_USER_ANALOG_STATUS0);
  1251. if (err < 0)
  1252. return err;
  1253. err = mdio_read(np, np->phy_addr, BCM8704_USER_DEV3_ADDR,
  1254. BCM8704_USER_ANALOG_STATUS0);
  1255. if (err < 0)
  1256. return err;
  1257. analog_stat0 = err;
  1258. err = mdio_read(np, np->phy_addr, BCM8704_USER_DEV3_ADDR,
  1259. BCM8704_USER_TX_ALARM_STATUS);
  1260. if (err < 0)
  1261. return err;
  1262. err = mdio_read(np, np->phy_addr, BCM8704_USER_DEV3_ADDR,
  1263. BCM8704_USER_TX_ALARM_STATUS);
  1264. if (err < 0)
  1265. return err;
  1266. tx_alarm_status = err;
  1267. if (analog_stat0 != 0x03fc) {
  1268. if ((analog_stat0 == 0x43bc) && (tx_alarm_status != 0)) {
  1269. pr_info("Port %u cable not connected or bad cable\n",
  1270. np->port);
  1271. } else if (analog_stat0 == 0x639c) {
  1272. pr_info("Port %u optical module is bad or missing\n",
  1273. np->port);
  1274. }
  1275. }
  1276. return 0;
  1277. }
  1278. static int xcvr_10g_set_lb_bcm870x(struct niu *np)
  1279. {
  1280. struct niu_link_config *lp = &np->link_config;
  1281. int err;
  1282. err = mdio_read(np, np->phy_addr, BCM8704_PCS_DEV_ADDR,
  1283. MII_BMCR);
  1284. if (err < 0)
  1285. return err;
  1286. err &= ~BMCR_LOOPBACK;
  1287. if (lp->loopback_mode == LOOPBACK_MAC)
  1288. err |= BMCR_LOOPBACK;
  1289. err = mdio_write(np, np->phy_addr, BCM8704_PCS_DEV_ADDR,
  1290. MII_BMCR, err);
  1291. if (err)
  1292. return err;
  1293. return 0;
  1294. }
  1295. static int xcvr_init_10g_bcm8706(struct niu *np)
  1296. {
  1297. int err = 0;
  1298. u64 val;
  1299. if ((np->flags & NIU_FLAGS_HOTPLUG_PHY) &&
  1300. (np->flags & NIU_FLAGS_HOTPLUG_PHY_PRESENT) == 0)
  1301. return err;
  1302. val = nr64_mac(XMAC_CONFIG);
  1303. val &= ~XMAC_CONFIG_LED_POLARITY;
  1304. val |= XMAC_CONFIG_FORCE_LED_ON;
  1305. nw64_mac(XMAC_CONFIG, val);
  1306. val = nr64(MIF_CONFIG);
  1307. val |= MIF_CONFIG_INDIRECT_MODE;
  1308. nw64(MIF_CONFIG, val);
  1309. err = bcm8704_reset(np);
  1310. if (err)
  1311. return err;
  1312. err = xcvr_10g_set_lb_bcm870x(np);
  1313. if (err)
  1314. return err;
  1315. err = bcm8706_init_user_dev3(np);
  1316. if (err)
  1317. return err;
  1318. err = xcvr_diag_bcm870x(np);
  1319. if (err)
  1320. return err;
  1321. return 0;
  1322. }
  1323. static int xcvr_init_10g_bcm8704(struct niu *np)
  1324. {
  1325. int err;
  1326. err = bcm8704_reset(np);
  1327. if (err)
  1328. return err;
  1329. err = bcm8704_init_user_dev3(np);
  1330. if (err)
  1331. return err;
  1332. err = xcvr_10g_set_lb_bcm870x(np);
  1333. if (err)
  1334. return err;
  1335. err = xcvr_diag_bcm870x(np);
  1336. if (err)
  1337. return err;
  1338. return 0;
  1339. }
  1340. static int xcvr_init_10g(struct niu *np)
  1341. {
  1342. int phy_id, err;
  1343. u64 val;
  1344. val = nr64_mac(XMAC_CONFIG);
  1345. val &= ~XMAC_CONFIG_LED_POLARITY;
  1346. val |= XMAC_CONFIG_FORCE_LED_ON;
  1347. nw64_mac(XMAC_CONFIG, val);
  1348. /* XXX shared resource, lock parent XXX */
  1349. val = nr64(MIF_CONFIG);
  1350. val |= MIF_CONFIG_INDIRECT_MODE;
  1351. nw64(MIF_CONFIG, val);
  1352. phy_id = phy_decode(np->parent->port_phy, np->port);
  1353. phy_id = np->parent->phy_probe_info.phy_id[phy_id][np->port];
  1354. /* handle different phy types */
  1355. switch (phy_id & NIU_PHY_ID_MASK) {
  1356. case NIU_PHY_ID_MRVL88X2011:
  1357. err = xcvr_init_10g_mrvl88x2011(np);
  1358. break;
  1359. default: /* bcom 8704 */
  1360. err = xcvr_init_10g_bcm8704(np);
  1361. break;
  1362. }
  1363. return 0;
  1364. }
  1365. static int mii_reset(struct niu *np)
  1366. {
  1367. int limit, err;
  1368. err = mii_write(np, np->phy_addr, MII_BMCR, BMCR_RESET);
  1369. if (err)
  1370. return err;
  1371. limit = 1000;
  1372. while (--limit >= 0) {
  1373. udelay(500);
  1374. err = mii_read(np, np->phy_addr, MII_BMCR);
  1375. if (err < 0)
  1376. return err;
  1377. if (!(err & BMCR_RESET))
  1378. break;
  1379. }
  1380. if (limit < 0) {
  1381. netdev_err(np->dev, "Port %u MII would not reset, bmcr[%04x]\n",
  1382. np->port, err);
  1383. return -ENODEV;
  1384. }
  1385. return 0;
  1386. }
  1387. static int xcvr_init_1g_rgmii(struct niu *np)
  1388. {
  1389. int err;
  1390. u64 val;
  1391. u16 bmcr, bmsr, estat;
  1392. val = nr64(MIF_CONFIG);
  1393. val &= ~MIF_CONFIG_INDIRECT_MODE;
  1394. nw64(MIF_CONFIG, val);
  1395. err = mii_reset(np);
  1396. if (err)
  1397. return err;
  1398. err = mii_read(np, np->phy_addr, MII_BMSR);
  1399. if (err < 0)
  1400. return err;
  1401. bmsr = err;
  1402. estat = 0;
  1403. if (bmsr & BMSR_ESTATEN) {
  1404. err = mii_read(np, np->phy_addr, MII_ESTATUS);
  1405. if (err < 0)
  1406. return err;
  1407. estat = err;
  1408. }
  1409. bmcr = 0;
  1410. err = mii_write(np, np->phy_addr, MII_BMCR, bmcr);
  1411. if (err)
  1412. return err;
  1413. if (bmsr & BMSR_ESTATEN) {
  1414. u16 ctrl1000 = 0;
  1415. if (estat & ESTATUS_1000_TFULL)
  1416. ctrl1000 |= ADVERTISE_1000FULL;
  1417. err = mii_write(np, np->phy_addr, MII_CTRL1000, ctrl1000);
  1418. if (err)
  1419. return err;
  1420. }
  1421. bmcr = (BMCR_SPEED1000 | BMCR_FULLDPLX);
  1422. err = mii_write(np, np->phy_addr, MII_BMCR, bmcr);
  1423. if (err)
  1424. return err;
  1425. err = mii_read(np, np->phy_addr, MII_BMCR);
  1426. if (err < 0)
  1427. return err;
  1428. bmcr = mii_read(np, np->phy_addr, MII_BMCR);
  1429. err = mii_read(np, np->phy_addr, MII_BMSR);
  1430. if (err < 0)
  1431. return err;
  1432. return 0;
  1433. }
  1434. static int mii_init_common(struct niu *np)
  1435. {
  1436. struct niu_link_config *lp = &np->link_config;
  1437. u16 bmcr, bmsr, adv, estat;
  1438. int err;
  1439. err = mii_reset(np);
  1440. if (err)
  1441. return err;
  1442. err = mii_read(np, np->phy_addr, MII_BMSR);
  1443. if (err < 0)
  1444. return err;
  1445. bmsr = err;
  1446. estat = 0;
  1447. if (bmsr & BMSR_ESTATEN) {
  1448. err = mii_read(np, np->phy_addr, MII_ESTATUS);
  1449. if (err < 0)
  1450. return err;
  1451. estat = err;
  1452. }
  1453. bmcr = 0;
  1454. err = mii_write(np, np->phy_addr, MII_BMCR, bmcr);
  1455. if (err)
  1456. return err;
  1457. if (lp->loopback_mode == LOOPBACK_MAC) {
  1458. bmcr |= BMCR_LOOPBACK;
  1459. if (lp->active_speed == SPEED_1000)
  1460. bmcr |= BMCR_SPEED1000;
  1461. if (lp->active_duplex == DUPLEX_FULL)
  1462. bmcr |= BMCR_FULLDPLX;
  1463. }
  1464. if (lp->loopback_mode == LOOPBACK_PHY) {
  1465. u16 aux;
  1466. aux = (BCM5464R_AUX_CTL_EXT_LB |
  1467. BCM5464R_AUX_CTL_WRITE_1);
  1468. err = mii_write(np, np->phy_addr, BCM5464R_AUX_CTL, aux);
  1469. if (err)
  1470. return err;
  1471. }
  1472. if (lp->autoneg) {
  1473. u16 ctrl1000;
  1474. adv = ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP;
  1475. if ((bmsr & BMSR_10HALF) &&
  1476. (lp->advertising & ADVERTISED_10baseT_Half))
  1477. adv |= ADVERTISE_10HALF;
  1478. if ((bmsr & BMSR_10FULL) &&
  1479. (lp->advertising & ADVERTISED_10baseT_Full))
  1480. adv |= ADVERTISE_10FULL;
  1481. if ((bmsr & BMSR_100HALF) &&
  1482. (lp->advertising & ADVERTISED_100baseT_Half))
  1483. adv |= ADVERTISE_100HALF;
  1484. if ((bmsr & BMSR_100FULL) &&
  1485. (lp->advertising & ADVERTISED_100baseT_Full))
  1486. adv |= ADVERTISE_100FULL;
  1487. err = mii_write(np, np->phy_addr, MII_ADVERTISE, adv);
  1488. if (err)
  1489. return err;
  1490. if (likely(bmsr & BMSR_ESTATEN)) {
  1491. ctrl1000 = 0;
  1492. if ((estat & ESTATUS_1000_THALF) &&
  1493. (lp->advertising & ADVERTISED_1000baseT_Half))
  1494. ctrl1000 |= ADVERTISE_1000HALF;
  1495. if ((estat & ESTATUS_1000_TFULL) &&
  1496. (lp->advertising & ADVERTISED_1000baseT_Full))
  1497. ctrl1000 |= ADVERTISE_1000FULL;
  1498. err = mii_write(np, np->phy_addr,
  1499. MII_CTRL1000, ctrl1000);
  1500. if (err)
  1501. return err;
  1502. }
  1503. bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART);
  1504. } else {
  1505. /* !lp->autoneg */
  1506. int fulldpx;
  1507. if (lp->duplex == DUPLEX_FULL) {
  1508. bmcr |= BMCR_FULLDPLX;
  1509. fulldpx = 1;
  1510. } else if (lp->duplex == DUPLEX_HALF)
  1511. fulldpx = 0;
  1512. else
  1513. return -EINVAL;
  1514. if (lp->speed == SPEED_1000) {
  1515. /* if X-full requested while not supported, or
  1516. X-half requested while not supported... */
  1517. if ((fulldpx && !(estat & ESTATUS_1000_TFULL)) ||
  1518. (!fulldpx && !(estat & ESTATUS_1000_THALF)))
  1519. return -EINVAL;
  1520. bmcr |= BMCR_SPEED1000;
  1521. } else if (lp->speed == SPEED_100) {
  1522. if ((fulldpx && !(bmsr & BMSR_100FULL)) ||
  1523. (!fulldpx && !(bmsr & BMSR_100HALF)))
  1524. return -EINVAL;
  1525. bmcr |= BMCR_SPEED100;
  1526. } else if (lp->speed == SPEED_10) {
  1527. if ((fulldpx && !(bmsr & BMSR_10FULL)) ||
  1528. (!fulldpx && !(bmsr & BMSR_10HALF)))
  1529. return -EINVAL;
  1530. } else
  1531. return -EINVAL;
  1532. }
  1533. err = mii_write(np, np->phy_addr, MII_BMCR, bmcr);
  1534. if (err)
  1535. return err;
  1536. #if 0
  1537. err = mii_read(np, np->phy_addr, MII_BMCR);
  1538. if (err < 0)
  1539. return err;
  1540. bmcr = err;
  1541. err = mii_read(np, np->phy_addr, MII_BMSR);
  1542. if (err < 0)
  1543. return err;
  1544. bmsr = err;
  1545. pr_info("Port %u after MII init bmcr[%04x] bmsr[%04x]\n",
  1546. np->port, bmcr, bmsr);
  1547. #endif
  1548. return 0;
  1549. }
  1550. static int xcvr_init_1g(struct niu *np)
  1551. {
  1552. u64 val;
  1553. /* XXX shared resource, lock parent XXX */
  1554. val = nr64(MIF_CONFIG);
  1555. val &= ~MIF_CONFIG_INDIRECT_MODE;
  1556. nw64(MIF_CONFIG, val);
  1557. return mii_init_common(np);
  1558. }
  1559. static int niu_xcvr_init(struct niu *np)
  1560. {
  1561. const struct niu_phy_ops *ops = np->phy_ops;
  1562. int err;
  1563. err = 0;
  1564. if (ops->xcvr_init)
  1565. err = ops->xcvr_init(np);
  1566. return err;
  1567. }
  1568. static int niu_serdes_init(struct niu *np)
  1569. {
  1570. const struct niu_phy_ops *ops = np->phy_ops;
  1571. int err;
  1572. err = 0;
  1573. if (ops->serdes_init)
  1574. err = ops->serdes_init(np);
  1575. return err;
  1576. }
  1577. static void niu_init_xif(struct niu *);
  1578. static void niu_handle_led(struct niu *, int status);
  1579. static int niu_link_status_common(struct niu *np, int link_up)
  1580. {
  1581. struct niu_link_config *lp = &np->link_config;
  1582. struct net_device *dev = np->dev;
  1583. unsigned long flags;
  1584. if (!netif_carrier_ok(dev) && link_up) {
  1585. netif_info(np, link, dev, "Link is up at %s, %s duplex\n",
  1586. lp->active_speed == SPEED_10000 ? "10Gb/sec" :
  1587. lp->active_speed == SPEED_1000 ? "1Gb/sec" :
  1588. lp->active_speed == SPEED_100 ? "100Mbit/sec" :
  1589. "10Mbit/sec",
  1590. lp->active_duplex == DUPLEX_FULL ? "full" : "half");
  1591. spin_lock_irqsave(&np->lock, flags);
  1592. niu_init_xif(np);
  1593. niu_handle_led(np, 1);
  1594. spin_unlock_irqrestore(&np->lock, flags);
  1595. netif_carrier_on(dev);
  1596. } else if (netif_carrier_ok(dev) && !link_up) {
  1597. netif_warn(np, link, dev, "Link is down\n");
  1598. spin_lock_irqsave(&np->lock, flags);
  1599. niu_handle_led(np, 0);
  1600. spin_unlock_irqrestore(&np->lock, flags);
  1601. netif_carrier_off(dev);
  1602. }
  1603. return 0;
  1604. }
  1605. static int link_status_10g_mrvl(struct niu *np, int *link_up_p)
  1606. {
  1607. int err, link_up, pma_status, pcs_status;
  1608. link_up = 0;
  1609. err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV1_ADDR,
  1610. MRVL88X2011_10G_PMD_STATUS_2);
  1611. if (err < 0)
  1612. goto out;
  1613. /* Check PMA/PMD Register: 1.0001.2 == 1 */
  1614. err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV1_ADDR,
  1615. MRVL88X2011_PMA_PMD_STATUS_1);
  1616. if (err < 0)
  1617. goto out;
  1618. pma_status = ((err & MRVL88X2011_LNK_STATUS_OK) ? 1 : 0);
  1619. /* Check PMC Register : 3.0001.2 == 1: read twice */
  1620. err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV3_ADDR,
  1621. MRVL88X2011_PMA_PMD_STATUS_1);
  1622. if (err < 0)
  1623. goto out;
  1624. err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV3_ADDR,
  1625. MRVL88X2011_PMA_PMD_STATUS_1);
  1626. if (err < 0)
  1627. goto out;
  1628. pcs_status = ((err & MRVL88X2011_LNK_STATUS_OK) ? 1 : 0);
  1629. /* Check XGXS Register : 4.0018.[0-3,12] */
  1630. err = mdio_read(np, np->phy_addr, MRVL88X2011_USER_DEV4_ADDR,
  1631. MRVL88X2011_10G_XGXS_LANE_STAT);
  1632. if (err < 0)
  1633. goto out;
  1634. if (err == (PHYXS_XGXS_LANE_STAT_ALINGED | PHYXS_XGXS_LANE_STAT_LANE3 |
  1635. PHYXS_XGXS_LANE_STAT_LANE2 | PHYXS_XGXS_LANE_STAT_LANE1 |
  1636. PHYXS_XGXS_LANE_STAT_LANE0 | PHYXS_XGXS_LANE_STAT_MAGIC |
  1637. 0x800))
  1638. link_up = (pma_status && pcs_status) ? 1 : 0;
  1639. np->link_config.active_speed = SPEED_10000;
  1640. np->link_config.active_duplex = DUPLEX_FULL;
  1641. err = 0;
  1642. out:
  1643. mrvl88x2011_act_led(np, (link_up ?
  1644. MRVL88X2011_LED_CTL_PCS_ACT :
  1645. MRVL88X2011_LED_CTL_OFF));
  1646. *link_up_p = link_up;
  1647. return err;
  1648. }
  1649. static int link_status_10g_bcm8706(struct niu *np, int *link_up_p)
  1650. {
  1651. int err, link_up;
  1652. link_up = 0;
  1653. err = mdio_read(np, np->phy_addr, BCM8704_PMA_PMD_DEV_ADDR,
  1654. BCM8704_PMD_RCV_SIGDET);
  1655. if (err < 0 || err == 0xffff)
  1656. goto out;
  1657. if (!(err & PMD_RCV_SIGDET_GLOBAL)) {
  1658. err = 0;
  1659. goto out;
  1660. }
  1661. err = mdio_read(np, np->phy_addr, BCM8704_PCS_DEV_ADDR,
  1662. BCM8704_PCS_10G_R_STATUS);
  1663. if (err < 0)
  1664. goto out;
  1665. if (!(err & PCS_10G_R_STATUS_BLK_LOCK)) {
  1666. err = 0;
  1667. goto out;
  1668. }
  1669. err = mdio_read(np, np->phy_addr, BCM8704_PHYXS_DEV_ADDR,
  1670. BCM8704_PHYXS_XGXS_LANE_STAT);
  1671. if (err < 0)
  1672. goto out;
  1673. if (err != (PHYXS_XGXS_LANE_STAT_ALINGED |
  1674. PHYXS_XGXS_LANE_STAT_MAGIC |
  1675. PHYXS_XGXS_LANE_STAT_PATTEST |
  1676. PHYXS_XGXS_LANE_STAT_LANE3 |
  1677. PHYXS_XGXS_LANE_STAT_LANE2 |
  1678. PHYXS_XGXS_LANE_STAT_LANE1 |
  1679. PHYXS_XGXS_LANE_STAT_LANE0)) {
  1680. err = 0;
  1681. np->link_config.active_speed = SPEED_INVALID;
  1682. np->link_config.active_duplex = DUPLEX_INVALID;
  1683. goto out;
  1684. }
  1685. link_up = 1;
  1686. np->link_config.active_speed = SPEED_10000;
  1687. np->link_config.active_duplex = DUPLEX_FULL;
  1688. err = 0;
  1689. out:
  1690. *link_up_p = link_up;
  1691. return err;
  1692. }
  1693. static int link_status_10g_bcom(struct niu *np, int *link_up_p)
  1694. {
  1695. int err, link_up;
  1696. link_up = 0;
  1697. err = mdio_read(np, np->phy_addr, BCM8704_PMA_PMD_DEV_ADDR,
  1698. BCM8704_PMD_RCV_SIGDET);
  1699. if (err < 0)
  1700. goto out;
  1701. if (!(err & PMD_RCV_SIGDET_GLOBAL)) {
  1702. err = 0;
  1703. goto out;
  1704. }
  1705. err = mdio_read(np, np->phy_addr, BCM8704_PCS_DEV_ADDR,
  1706. BCM8704_PCS_10G_R_STATUS);
  1707. if (err < 0)
  1708. goto out;
  1709. if (!(err & PCS_10G_R_STATUS_BLK_LOCK)) {
  1710. err = 0;
  1711. goto out;
  1712. }
  1713. err = mdio_read(np, np->phy_addr, BCM8704_PHYXS_DEV_ADDR,
  1714. BCM8704_PHYXS_XGXS_LANE_STAT);
  1715. if (err < 0)
  1716. goto out;
  1717. if (err != (PHYXS_XGXS_LANE_STAT_ALINGED |
  1718. PHYXS_XGXS_LANE_STAT_MAGIC |
  1719. PHYXS_XGXS_LANE_STAT_LANE3 |
  1720. PHYXS_XGXS_LANE_STAT_LANE2 |
  1721. PHYXS_XGXS_LANE_STAT_LANE1 |
  1722. PHYXS_XGXS_LANE_STAT_LANE0)) {
  1723. err = 0;
  1724. goto out;
  1725. }
  1726. link_up = 1;
  1727. np->link_config.active_speed = SPEED_10000;
  1728. np->link_config.active_duplex = DUPLEX_FULL;
  1729. err = 0;
  1730. out:
  1731. *link_up_p = link_up;
  1732. return err;
  1733. }
  1734. static int link_status_10g(struct niu *np, int *link_up_p)
  1735. {
  1736. unsigned long flags;
  1737. int err = -EINVAL;
  1738. spin_lock_irqsave(&np->lock, flags);
  1739. if (np->link_config.loopback_mode == LOOPBACK_DISABLED) {
  1740. int phy_id;
  1741. phy_id = phy_decode(np->parent->port_phy, np->port);
  1742. phy_id = np->parent->phy_probe_info.phy_id[phy_id][np->port];
  1743. /* handle different phy types */
  1744. switch (phy_id & NIU_PHY_ID_MASK) {
  1745. case NIU_PHY_ID_MRVL88X2011:
  1746. err = link_status_10g_mrvl(np, link_up_p);
  1747. break;
  1748. default: /* bcom 8704 */
  1749. err = link_status_10g_bcom(np, link_up_p);
  1750. break;
  1751. }
  1752. }
  1753. spin_unlock_irqrestore(&np->lock, flags);
  1754. return err;
  1755. }
  1756. static int niu_10g_phy_present(struct niu *np)
  1757. {
  1758. u64 sig, mask, val;
  1759. sig = nr64(ESR_INT_SIGNALS);
  1760. switch (np->port) {
  1761. case 0:
  1762. mask = ESR_INT_SIGNALS_P0_BITS;
  1763. val = (ESR_INT_SRDY0_P0 |
  1764. ESR_INT_DET0_P0 |
  1765. ESR_INT_XSRDY_P0 |
  1766. ESR_INT_XDP_P0_CH3 |
  1767. ESR_INT_XDP_P0_CH2 |
  1768. ESR_INT_XDP_P0_CH1 |
  1769. ESR_INT_XDP_P0_CH0);
  1770. break;
  1771. case 1:
  1772. mask = ESR_INT_SIGNALS_P1_BITS;
  1773. val = (ESR_INT_SRDY0_P1 |
  1774. ESR_INT_DET0_P1 |
  1775. ESR_INT_XSRDY_P1 |
  1776. ESR_INT_XDP_P1_CH3 |
  1777. ESR_INT_XDP_P1_CH2 |
  1778. ESR_INT_XDP_P1_CH1 |
  1779. ESR_INT_XDP_P1_CH0);
  1780. break;
  1781. default:
  1782. return 0;
  1783. }
  1784. if ((sig & mask) != val)
  1785. return 0;
  1786. return 1;
  1787. }
  1788. static int link_status_10g_hotplug(struct niu *np, int *link_up_p)
  1789. {
  1790. unsigned long flags;
  1791. int err = 0;
  1792. int phy_present;
  1793. int phy_present_prev;
  1794. spin_lock_irqsave(&np->lock, flags);
  1795. if (np->link_config.loopback_mode == LOOPBACK_DISABLED) {
  1796. phy_present_prev = (np->flags & NIU_FLAGS_HOTPLUG_PHY_PRESENT) ?
  1797. 1 : 0;
  1798. phy_present = niu_10g_phy_present(np);
  1799. if (phy_present != phy_present_prev) {
  1800. /* state change */
  1801. if (phy_present) {
  1802. /* A NEM was just plugged in */
  1803. np->flags |= NIU_FLAGS_HOTPLUG_PHY_PRESENT;
  1804. if (np->phy_ops->xcvr_init)
  1805. err = np->phy_ops->xcvr_init(np);
  1806. if (err) {
  1807. err = mdio_read(np, np->phy_addr,
  1808. BCM8704_PHYXS_DEV_ADDR, MII_BMCR);
  1809. if (err == 0xffff) {
  1810. /* No mdio, back-to-back XAUI */
  1811. goto out;
  1812. }
  1813. /* debounce */
  1814. np->flags &= ~NIU_FLAGS_HOTPLUG_PHY_PRESENT;
  1815. }
  1816. } else {
  1817. np->flags &= ~NIU_FLAGS_HOTPLUG_PHY_PRESENT;
  1818. *link_up_p = 0;
  1819. netif_warn(np, link, np->dev,
  1820. "Hotplug PHY Removed\n");
  1821. }
  1822. }
  1823. out:
  1824. if (np->flags & NIU_FLAGS_HOTPLUG_PHY_PRESENT) {
  1825. err = link_status_10g_bcm8706(np, link_up_p);
  1826. if (err ==