lan78xx.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2017 Microchip Technology Inc. All rights reserved.
  4. */
  5. #include <dm.h>
  6. #include <log.h>
  7. #include <net.h>
  8. #include <usb.h>
  9. #include <linux/bitops.h>
  10. #include "usb_ether.h"
  11. #include "lan7x.h"
  12. /* LAN78xx specific register/bit defines */
  13. #define LAN78XX_HW_CFG_LED1_EN BIT(21) /* Muxed with EEDO */
  14. #define LAN78XX_HW_CFG_LED0_EN BIT(20) /* Muxed with EECLK */
  15. #define LAN78XX_USB_CFG0 0x080
  16. #define LAN78XX_USB_CFG0_BIR BIT(6)
  17. #define LAN78XX_BURST_CAP 0x090
  18. #define LAN78XX_BULK_IN_DLY 0x094
  19. #define LAN78XX_RFE_CTL 0x0B0
  20. #define LAN78XX_FCT_RX_CTL 0x0C0
  21. #define LAN78XX_FCT_TX_CTL 0x0C4
  22. #define LAN78XX_FCT_RX_FIFO_END 0x0C8
  23. #define LAN78XX_FCT_TX_FIFO_END 0x0CC
  24. #define LAN78XX_FCT_FLOW 0x0D0
  25. #define LAN78XX_MAF_BASE 0x400
  26. #define LAN78XX_MAF_HIX 0x00
  27. #define LAN78XX_MAF_LOX 0x04
  28. #define LAN78XX_MAF_HI_BEGIN (LAN78XX_MAF_BASE + LAN78XX_MAF_HIX)
  29. #define LAN78XX_MAF_LO_BEGIN (LAN78XX_MAF_BASE + LAN78XX_MAF_LOX)
  30. #define LAN78XX_MAF_HI(index) (LAN78XX_MAF_BASE + (8 * (index)) + \
  31. LAN78XX_MAF_HIX)
  32. #define LAN78XX_MAF_LO(index) (LAN78XX_MAF_BASE + (8 * (index)) + \
  33. LAN78XX_MAF_LOX)
  34. #define LAN78XX_MAF_HI_VALID BIT(31)
  35. /* OTP registers */
  36. #define LAN78XX_OTP_BASE_ADDR 0x00001000
  37. #define LAN78XX_OTP_PWR_DN (LAN78XX_OTP_BASE_ADDR + 4 * 0x00)
  38. #define LAN78XX_OTP_PWR_DN_PWRDN_N BIT(0)
  39. #define LAN78XX_OTP_ADDR1 (LAN78XX_OTP_BASE_ADDR + 4 * 0x01)
  40. #define LAN78XX_OTP_ADDR1_15_11 0x1F
  41. #define LAN78XX_OTP_ADDR2 (LAN78XX_OTP_BASE_ADDR + 4 * 0x02)
  42. #define LAN78XX_OTP_ADDR2_10_3 0xFF
  43. #define LAN78XX_OTP_RD_DATA (LAN78XX_OTP_BASE_ADDR + 4 * 0x06)
  44. #define LAN78XX_OTP_FUNC_CMD (LAN78XX_OTP_BASE_ADDR + 4 * 0x08)
  45. #define LAN78XX_OTP_FUNC_CMD_READ BIT(0)
  46. #define LAN78XX_OTP_CMD_GO (LAN78XX_OTP_BASE_ADDR + 4 * 0x0A)
  47. #define LAN78XX_OTP_CMD_GO_GO BIT(0)
  48. #define LAN78XX_OTP_STATUS (LAN78XX_OTP_BASE_ADDR + 4 * 0x0C)
  49. #define LAN78XX_OTP_STATUS_BUSY BIT(0)
  50. #define LAN78XX_OTP_INDICATOR_1 0xF3
  51. #define LAN78XX_OTP_INDICATOR_2 0xF7
  52. /*
  53. * Lan78xx infrastructure commands
  54. */
  55. static int lan78xx_read_raw_otp(struct usb_device *udev, u32 offset,
  56. u32 length, u8 *data)
  57. {
  58. int i;
  59. int ret;
  60. u32 buf;
  61. ret = lan7x_read_reg(udev, LAN78XX_OTP_PWR_DN, &buf);
  62. if (ret)
  63. return ret;
  64. if (buf & LAN78XX_OTP_PWR_DN_PWRDN_N) {
  65. /* clear it and wait to be cleared */
  66. ret = lan7x_write_reg(udev, LAN78XX_OTP_PWR_DN, 0);
  67. if (ret)
  68. return ret;
  69. ret = lan7x_wait_for_bit(udev, "LAN78XX_OTP_PWR_DN_PWRDN_N",
  70. LAN78XX_OTP_PWR_DN,
  71. LAN78XX_OTP_PWR_DN_PWRDN_N,
  72. false, 1000, 0);
  73. if (ret)
  74. return ret;
  75. }
  76. for (i = 0; i < length; i++) {
  77. ret = lan7x_write_reg(udev, LAN78XX_OTP_ADDR1,
  78. ((offset + i) >> 8) &
  79. LAN78XX_OTP_ADDR1_15_11);
  80. if (ret)
  81. return ret;
  82. ret = lan7x_write_reg(udev, LAN78XX_OTP_ADDR2,
  83. ((offset + i) & LAN78XX_OTP_ADDR2_10_3));
  84. if (ret)
  85. return ret;
  86. ret = lan7x_write_reg(udev, LAN78XX_OTP_FUNC_CMD,
  87. LAN78XX_OTP_FUNC_CMD_READ);
  88. if (ret)
  89. return ret;
  90. ret = lan7x_write_reg(udev, LAN78XX_OTP_CMD_GO,
  91. LAN78XX_OTP_CMD_GO_GO);
  92. if (ret)
  93. return ret;
  94. ret = lan7x_wait_for_bit(udev, "LAN78XX_OTP_STATUS_BUSY",
  95. LAN78XX_OTP_STATUS,
  96. LAN78XX_OTP_STATUS_BUSY,
  97. false, 1000, 0);
  98. if (ret)
  99. return ret;
  100. ret = lan7x_read_reg(udev, LAN78XX_OTP_RD_DATA, &buf);
  101. if (ret)
  102. return ret;
  103. data[i] = (u8)(buf & 0xFF);
  104. }
  105. return 0;
  106. }
  107. static int lan78xx_read_otp(struct usb_device *udev, u32 offset,
  108. u32 length, u8 *data)
  109. {
  110. u8 sig;
  111. int ret;
  112. ret = lan78xx_read_raw_otp(udev, 0, 1, &sig);
  113. if (!ret) {
  114. if (sig == LAN78XX_OTP_INDICATOR_1)
  115. offset = offset;
  116. else if (sig == LAN78XX_OTP_INDICATOR_2)
  117. offset += 0x100;
  118. else
  119. return -EINVAL;
  120. ret = lan78xx_read_raw_otp(udev, offset, length, data);
  121. if (ret)
  122. return ret;
  123. }
  124. debug("LAN78x: MAC address from OTP = %pM\n", data);
  125. return ret;
  126. }
  127. static int lan78xx_read_otp_mac(unsigned char *enetaddr,
  128. struct usb_device *udev)
  129. {
  130. int ret;
  131. memset(enetaddr, 0, 6);
  132. ret = lan78xx_read_otp(udev,
  133. EEPROM_MAC_OFFSET,
  134. ETH_ALEN,
  135. enetaddr);
  136. if (!ret && is_valid_ethaddr(enetaddr)) {
  137. /* eeprom values are valid so use them */
  138. debug("MAC address read from OTP %pM\n", enetaddr);
  139. return 0;
  140. }
  141. debug("MAC address read from OTP invalid %pM\n", enetaddr);
  142. memset(enetaddr, 0, 6);
  143. return -EINVAL;
  144. }
  145. static int lan78xx_update_flowcontrol(struct usb_device *udev,
  146. struct ueth_data *dev)
  147. {
  148. uint32_t flow = 0, fct_flow = 0;
  149. int ret;
  150. ret = lan7x_update_flowcontrol(udev, dev, &flow, &fct_flow);
  151. if (ret)
  152. return ret;
  153. ret = lan7x_write_reg(udev, LAN78XX_FCT_FLOW, fct_flow);
  154. if (ret)
  155. return ret;
  156. return lan7x_write_reg(udev, FLOW, flow);
  157. }
  158. static int lan78xx_read_mac(unsigned char *enetaddr,
  159. struct usb_device *udev,
  160. struct lan7x_private *priv)
  161. {
  162. u32 val;
  163. int ret;
  164. int saved = 0, done = 0;
  165. /*
  166. * Depends on chip, some EEPROM pins are muxed with LED function.
  167. * disable & restore LED function to access EEPROM.
  168. */
  169. if ((priv->chipid == ID_REV_CHIP_ID_7800) ||
  170. (priv->chipid == ID_REV_CHIP_ID_7850)) {
  171. ret = lan7x_read_reg(udev, HW_CFG, &val);
  172. if (ret)
  173. return ret;
  174. saved = val;
  175. val &= ~(LAN78XX_HW_CFG_LED1_EN | LAN78XX_HW_CFG_LED0_EN);
  176. ret = lan7x_write_reg(udev, HW_CFG, val);
  177. if (ret)
  178. goto restore;
  179. }
  180. /*
  181. * Refer to the doc/README.enetaddr and doc/README.usb for
  182. * the U-Boot MAC address policy
  183. */
  184. /* try reading mac address from EEPROM, then from OTP */
  185. ret = lan7x_read_eeprom_mac(enetaddr, udev);
  186. if (!ret)
  187. done = 1;
  188. restore:
  189. if ((priv->chipid == ID_REV_CHIP_ID_7800) ||
  190. (priv->chipid == ID_REV_CHIP_ID_7850)) {
  191. ret = lan7x_write_reg(udev, HW_CFG, saved);
  192. if (ret)
  193. return ret;
  194. }
  195. /* if the EEPROM mac address is good, then exit */
  196. if (done)
  197. return 0;
  198. /* try reading mac address from OTP if the device is LAN78xx */
  199. return lan78xx_read_otp_mac(enetaddr, udev);
  200. }
  201. static int lan78xx_set_receive_filter(struct usb_device *udev)
  202. {
  203. /* No multicast in u-boot for now */
  204. return lan7x_write_reg(udev, LAN78XX_RFE_CTL,
  205. RFE_CTL_BCAST_EN | RFE_CTL_DA_PERFECT);
  206. }
  207. /* starts the TX path */
  208. static void lan78xx_start_tx_path(struct usb_device *udev)
  209. {
  210. /* Enable Tx at MAC */
  211. lan7x_write_reg(udev, MAC_TX, MAC_TX_TXEN);
  212. /* Enable Tx at SCSRs */
  213. lan7x_write_reg(udev, LAN78XX_FCT_TX_CTL, FCT_TX_CTL_EN);
  214. }
  215. /* Starts the Receive path */
  216. static void lan78xx_start_rx_path(struct usb_device *udev)
  217. {
  218. /* Enable Rx at MAC */
  219. lan7x_write_reg(udev, MAC_RX,
  220. LAN7X_MAC_RX_MAX_SIZE_DEFAULT |
  221. MAC_RX_FCS_STRIP | MAC_RX_RXEN);
  222. /* Enable Rx at SCSRs */
  223. lan7x_write_reg(udev, LAN78XX_FCT_RX_CTL, FCT_RX_CTL_EN);
  224. }
  225. static int lan78xx_basic_reset(struct usb_device *udev,
  226. struct ueth_data *dev,
  227. struct lan7x_private *priv)
  228. {
  229. int ret;
  230. u32 val;
  231. ret = lan7x_basic_reset(udev, dev);
  232. if (ret)
  233. return ret;
  234. /* Keep the chip ID */
  235. ret = lan7x_read_reg(udev, ID_REV, &val);
  236. if (ret)
  237. return ret;
  238. debug("LAN78xx ID_REV = 0x%08x\n", val);
  239. priv->chipid = (val & ID_REV_CHIP_ID_MASK) >> 16;
  240. /* Respond to the IN token with a NAK */
  241. ret = lan7x_read_reg(udev, LAN78XX_USB_CFG0, &val);
  242. if (ret)
  243. return ret;
  244. val &= ~LAN78XX_USB_CFG0_BIR;
  245. return lan7x_write_reg(udev, LAN78XX_USB_CFG0, val);
  246. }
  247. int lan78xx_write_hwaddr(struct udevice *dev)
  248. {
  249. struct usb_device *udev = dev_get_parent_priv(dev);
  250. struct eth_pdata *pdata = dev_get_platdata(dev);
  251. unsigned char *enetaddr = pdata->enetaddr;
  252. u32 addr_lo = get_unaligned_le32(&enetaddr[0]);
  253. u32 addr_hi = (u32)get_unaligned_le16(&enetaddr[4]);
  254. int ret;
  255. /* set hardware address */
  256. ret = lan7x_write_reg(udev, RX_ADDRL, addr_lo);
  257. if (ret)
  258. return ret;
  259. ret = lan7x_write_reg(udev, RX_ADDRH, addr_hi);
  260. if (ret)
  261. return ret;
  262. ret = lan7x_write_reg(udev, LAN78XX_MAF_LO(0), addr_lo);
  263. if (ret)
  264. return ret;
  265. ret = lan7x_write_reg(udev, LAN78XX_MAF_HI(0),
  266. addr_hi | LAN78XX_MAF_HI_VALID);
  267. if (ret)
  268. return ret;
  269. debug("MAC addr %pM written\n", enetaddr);
  270. return 0;
  271. }
  272. static int lan78xx_eth_start(struct udevice *dev)
  273. {
  274. struct usb_device *udev = dev_get_parent_priv(dev);
  275. struct lan7x_private *priv = dev_get_priv(dev);
  276. int ret;
  277. u32 write_buf;
  278. /* Reset and read Mac addr were done in probe() */
  279. ret = lan78xx_write_hwaddr(dev);
  280. if (ret)
  281. return ret;
  282. ret = lan7x_write_reg(udev, LAN78XX_BURST_CAP, 0);
  283. if (ret)
  284. return ret;
  285. ret = lan7x_write_reg(udev, LAN78XX_BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
  286. if (ret)
  287. return ret;
  288. ret = lan7x_write_reg(udev, INT_STS, 0xFFFFFFFF);
  289. if (ret)
  290. return ret;
  291. /* set FIFO sizes */
  292. ret = lan7x_write_reg(udev, LAN78XX_FCT_RX_FIFO_END,
  293. (MAX_RX_FIFO_SIZE - 512) / 512);
  294. if (ret)
  295. return ret;
  296. ret = lan7x_write_reg(udev, LAN78XX_FCT_TX_FIFO_END,
  297. (MAX_TX_FIFO_SIZE - 512) / 512);
  298. if (ret)
  299. return ret;
  300. /* Init Tx */
  301. ret = lan7x_write_reg(udev, FLOW, 0);
  302. if (ret)
  303. return ret;
  304. /* Init Rx. Set Vlan, keep default for VLAN on 78xx */
  305. ret = lan78xx_set_receive_filter(udev);
  306. if (ret)
  307. return ret;
  308. /* Init PHY, autonego, and link */
  309. ret = lan7x_eth_phylib_connect(dev, &priv->ueth);
  310. if (ret)
  311. return ret;
  312. ret = lan7x_eth_phylib_config_start(dev);
  313. if (ret)
  314. return ret;
  315. /*
  316. * MAC_CR has to be set after PHY init.
  317. * MAC will auto detect the PHY speed.
  318. */
  319. ret = lan7x_read_reg(udev, MAC_CR, &write_buf);
  320. if (ret)
  321. return ret;
  322. write_buf |= MAC_CR_AUTO_DUPLEX | MAC_CR_AUTO_SPEED | MAC_CR_ADP;
  323. ret = lan7x_write_reg(udev, MAC_CR, write_buf);
  324. if (ret)
  325. return ret;
  326. lan78xx_start_tx_path(udev);
  327. lan78xx_start_rx_path(udev);
  328. return lan78xx_update_flowcontrol(udev, &priv->ueth);
  329. }
  330. int lan78xx_read_rom_hwaddr(struct udevice *dev)
  331. {
  332. struct usb_device *udev = dev_get_parent_priv(dev);
  333. struct eth_pdata *pdata = dev_get_platdata(dev);
  334. struct lan7x_private *priv = dev_get_priv(dev);
  335. int ret;
  336. ret = lan78xx_read_mac(pdata->enetaddr, udev, priv);
  337. if (ret)
  338. memset(pdata->enetaddr, 0, 6);
  339. return 0;
  340. }
  341. static int lan78xx_eth_probe(struct udevice *dev)
  342. {
  343. struct usb_device *udev = dev_get_parent_priv(dev);
  344. struct lan7x_private *priv = dev_get_priv(dev);
  345. struct ueth_data *ueth = &priv->ueth;
  346. struct eth_pdata *pdata = dev_get_platdata(dev);
  347. int ret;
  348. /* Do a reset in order to get the MAC address from HW */
  349. if (lan78xx_basic_reset(udev, ueth, priv))
  350. return 0;
  351. /* Get the MAC address */
  352. /*
  353. * We must set the eth->enetaddr from HW because the upper layer
  354. * will force to use the environmental var (usbethaddr) or random if
  355. * there is no valid MAC address in eth->enetaddr.
  356. */
  357. lan78xx_read_mac(pdata->enetaddr, udev, priv);
  358. /* Do not return 0 for not finding MAC addr in HW */
  359. ret = usb_ether_register(dev, ueth, RX_URB_SIZE);
  360. if (ret)
  361. return ret;
  362. /* Register phylib */
  363. return lan7x_phylib_register(dev);
  364. }
  365. static const struct eth_ops lan78xx_eth_ops = {
  366. .start = lan78xx_eth_start,
  367. .send = lan7x_eth_send,
  368. .recv = lan7x_eth_recv,
  369. .free_pkt = lan7x_free_pkt,
  370. .stop = lan7x_eth_stop,
  371. .write_hwaddr = lan78xx_write_hwaddr,
  372. .read_rom_hwaddr = lan78xx_read_rom_hwaddr,
  373. };
  374. U_BOOT_DRIVER(lan78xx_eth) = {
  375. .name = "lan78xx_eth",
  376. .id = UCLASS_ETH,
  377. .probe = lan78xx_eth_probe,
  378. .remove = lan7x_eth_remove,
  379. .ops = &lan78xx_eth_ops,
  380. .priv_auto_alloc_size = sizeof(struct lan7x_private),
  381. .platdata_auto_alloc_size = sizeof(struct eth_pdata),
  382. };
  383. static const struct usb_device_id lan78xx_eth_id_table[] = {
  384. { USB_DEVICE(0x0424, 0x7800) }, /* LAN7800 USB Ethernet */
  385. { USB_DEVICE(0x0424, 0x7850) }, /* LAN7850 USB Ethernet */
  386. { } /* Terminating entry */
  387. };
  388. U_BOOT_USB_DEVICE(lan78xx_eth, lan78xx_eth_id_table);