sun8i_emac.c 25 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2016
  4. * Author: Amit Singh Tomar, amittomer25@gmail.com
  5. *
  6. * Ethernet driver for H3/A64/A83T based SoC's
  7. *
  8. * It is derived from the work done by
  9. * LABBE Corentin & Chen-Yu Tsai for Linux, THANKS!
  10. *
  11. */
  12. #include <cpu_func.h>
  13. #include <log.h>
  14. #include <asm/cache.h>
  15. #include <asm/io.h>
  16. #include <asm/arch/clock.h>
  17. #include <asm/arch/gpio.h>
  18. #include <common.h>
  19. #include <clk.h>
  20. #include <dm.h>
  21. #include <fdt_support.h>
  22. #include <dm/device_compat.h>
  23. #include <linux/bitops.h>
  24. #include <linux/delay.h>
  25. #include <linux/err.h>
  26. #include <malloc.h>
  27. #include <miiphy.h>
  28. #include <net.h>
  29. #include <reset.h>
  30. #include <dt-bindings/pinctrl/sun4i-a10.h>
  31. #if CONFIG_IS_ENABLED(DM_GPIO)
  32. #include <asm-generic/gpio.h>
  33. #endif
  34. #define MDIO_CMD_MII_BUSY BIT(0)
  35. #define MDIO_CMD_MII_WRITE BIT(1)
  36. #define MDIO_CMD_MII_PHY_REG_ADDR_MASK 0x000001f0
  37. #define MDIO_CMD_MII_PHY_REG_ADDR_SHIFT 4
  38. #define MDIO_CMD_MII_PHY_ADDR_MASK 0x0001f000
  39. #define MDIO_CMD_MII_PHY_ADDR_SHIFT 12
  40. #define CONFIG_TX_DESCR_NUM 32
  41. #define CONFIG_RX_DESCR_NUM 32
  42. #define CONFIG_ETH_BUFSIZE 2048 /* Note must be dma aligned */
  43. /*
  44. * The datasheet says that each descriptor can transfers up to 4096 bytes
  45. * But later, the register documentation reduces that value to 2048,
  46. * using 2048 cause strange behaviours and even BSP driver use 2047
  47. */
  48. #define CONFIG_ETH_RXSIZE 2044 /* Note must fit in ETH_BUFSIZE */
  49. #define TX_TOTAL_BUFSIZE (CONFIG_ETH_BUFSIZE * CONFIG_TX_DESCR_NUM)
  50. #define RX_TOTAL_BUFSIZE (CONFIG_ETH_BUFSIZE * CONFIG_RX_DESCR_NUM)
  51. #define H3_EPHY_DEFAULT_VALUE 0x58000
  52. #define H3_EPHY_DEFAULT_MASK GENMASK(31, 15)
  53. #define H3_EPHY_ADDR_SHIFT 20
  54. #define REG_PHY_ADDR_MASK GENMASK(4, 0)
  55. #define H3_EPHY_LED_POL BIT(17) /* 1: active low, 0: active high */
  56. #define H3_EPHY_SHUTDOWN BIT(16) /* 1: shutdown, 0: power up */
  57. #define H3_EPHY_SELECT BIT(15) /* 1: internal PHY, 0: external PHY */
  58. #define SC_RMII_EN BIT(13)
  59. #define SC_EPIT BIT(2) /* 1: RGMII, 0: MII */
  60. #define SC_ETCS_MASK GENMASK(1, 0)
  61. #define SC_ETCS_EXT_GMII 0x1
  62. #define SC_ETCS_INT_GMII 0x2
  63. #define SC_ETXDC_MASK GENMASK(12, 10)
  64. #define SC_ETXDC_OFFSET 10
  65. #define SC_ERXDC_MASK GENMASK(9, 5)
  66. #define SC_ERXDC_OFFSET 5
  67. #define CONFIG_MDIO_TIMEOUT (3 * CONFIG_SYS_HZ)
  68. #define AHB_GATE_OFFSET_EPHY 0
  69. /* IO mux settings */
  70. #define SUN8I_IOMUX_H3 2
  71. #define SUN8I_IOMUX_R40 5
  72. #define SUN8I_IOMUX 4
  73. /* H3/A64 EMAC Register's offset */
  74. #define EMAC_CTL0 0x00
  75. #define EMAC_CTL1 0x04
  76. #define EMAC_INT_STA 0x08
  77. #define EMAC_INT_EN 0x0c
  78. #define EMAC_TX_CTL0 0x10
  79. #define EMAC_TX_CTL1 0x14
  80. #define EMAC_TX_FLOW_CTL 0x1c
  81. #define EMAC_TX_DMA_DESC 0x20
  82. #define EMAC_RX_CTL0 0x24
  83. #define EMAC_RX_CTL1 0x28
  84. #define EMAC_RX_DMA_DESC 0x34
  85. #define EMAC_MII_CMD 0x48
  86. #define EMAC_MII_DATA 0x4c
  87. #define EMAC_ADDR0_HIGH 0x50
  88. #define EMAC_ADDR0_LOW 0x54
  89. #define EMAC_TX_DMA_STA 0xb0
  90. #define EMAC_TX_CUR_DESC 0xb4
  91. #define EMAC_TX_CUR_BUF 0xb8
  92. #define EMAC_RX_DMA_STA 0xc0
  93. #define EMAC_RX_CUR_DESC 0xc4
  94. DECLARE_GLOBAL_DATA_PTR;
  95. enum emac_variant {
  96. A83T_EMAC = 1,
  97. H3_EMAC,
  98. A64_EMAC,
  99. R40_GMAC,
  100. H6_EMAC,
  101. };
  102. struct emac_dma_desc {
  103. u32 status;
  104. u32 st;
  105. u32 buf_addr;
  106. u32 next;
  107. } __aligned(ARCH_DMA_MINALIGN);
  108. struct emac_eth_dev {
  109. struct emac_dma_desc rx_chain[CONFIG_TX_DESCR_NUM];
  110. struct emac_dma_desc tx_chain[CONFIG_RX_DESCR_NUM];
  111. char rxbuffer[RX_TOTAL_BUFSIZE] __aligned(ARCH_DMA_MINALIGN);
  112. char txbuffer[TX_TOTAL_BUFSIZE] __aligned(ARCH_DMA_MINALIGN);
  113. u32 interface;
  114. u32 phyaddr;
  115. u32 link;
  116. u32 speed;
  117. u32 duplex;
  118. u32 phy_configured;
  119. u32 tx_currdescnum;
  120. u32 rx_currdescnum;
  121. u32 addr;
  122. u32 tx_slot;
  123. bool use_internal_phy;
  124. enum emac_variant variant;
  125. void *mac_reg;
  126. phys_addr_t sysctl_reg;
  127. struct phy_device *phydev;
  128. struct mii_dev *bus;
  129. struct clk tx_clk;
  130. struct clk ephy_clk;
  131. struct reset_ctl tx_rst;
  132. struct reset_ctl ephy_rst;
  133. #if CONFIG_IS_ENABLED(DM_GPIO)
  134. struct gpio_desc reset_gpio;
  135. #endif
  136. };
  137. struct sun8i_eth_pdata {
  138. struct eth_pdata eth_pdata;
  139. u32 reset_delays[3];
  140. int tx_delay_ps;
  141. int rx_delay_ps;
  142. };
  143. static int sun8i_mdio_read(struct mii_dev *bus, int addr, int devad, int reg)
  144. {
  145. struct udevice *dev = bus->priv;
  146. struct emac_eth_dev *priv = dev_get_priv(dev);
  147. ulong start;
  148. u32 miiaddr = 0;
  149. int timeout = CONFIG_MDIO_TIMEOUT;
  150. miiaddr &= ~MDIO_CMD_MII_WRITE;
  151. miiaddr &= ~MDIO_CMD_MII_PHY_REG_ADDR_MASK;
  152. miiaddr |= (reg << MDIO_CMD_MII_PHY_REG_ADDR_SHIFT) &
  153. MDIO_CMD_MII_PHY_REG_ADDR_MASK;
  154. miiaddr &= ~MDIO_CMD_MII_PHY_ADDR_MASK;
  155. miiaddr |= (addr << MDIO_CMD_MII_PHY_ADDR_SHIFT) &
  156. MDIO_CMD_MII_PHY_ADDR_MASK;
  157. miiaddr |= MDIO_CMD_MII_BUSY;
  158. writel(miiaddr, priv->mac_reg + EMAC_MII_CMD);
  159. start = get_timer(0);
  160. while (get_timer(start) < timeout) {
  161. if (!(readl(priv->mac_reg + EMAC_MII_CMD) & MDIO_CMD_MII_BUSY))
  162. return readl(priv->mac_reg + EMAC_MII_DATA);
  163. udelay(10);
  164. };
  165. return -1;
  166. }
  167. static int sun8i_mdio_write(struct mii_dev *bus, int addr, int devad, int reg,
  168. u16 val)
  169. {
  170. struct udevice *dev = bus->priv;
  171. struct emac_eth_dev *priv = dev_get_priv(dev);
  172. ulong start;
  173. u32 miiaddr = 0;
  174. int ret = -1, timeout = CONFIG_MDIO_TIMEOUT;
  175. miiaddr &= ~MDIO_CMD_MII_PHY_REG_ADDR_MASK;
  176. miiaddr |= (reg << MDIO_CMD_MII_PHY_REG_ADDR_SHIFT) &
  177. MDIO_CMD_MII_PHY_REG_ADDR_MASK;
  178. miiaddr &= ~MDIO_CMD_MII_PHY_ADDR_MASK;
  179. miiaddr |= (addr << MDIO_CMD_MII_PHY_ADDR_SHIFT) &
  180. MDIO_CMD_MII_PHY_ADDR_MASK;
  181. miiaddr |= MDIO_CMD_MII_WRITE;
  182. miiaddr |= MDIO_CMD_MII_BUSY;
  183. writel(val, priv->mac_reg + EMAC_MII_DATA);
  184. writel(miiaddr, priv->mac_reg + EMAC_MII_CMD);
  185. start = get_timer(0);
  186. while (get_timer(start) < timeout) {
  187. if (!(readl(priv->mac_reg + EMAC_MII_CMD) &
  188. MDIO_CMD_MII_BUSY)) {
  189. ret = 0;
  190. break;
  191. }
  192. udelay(10);
  193. };
  194. return ret;
  195. }
  196. static int _sun8i_write_hwaddr(struct emac_eth_dev *priv, u8 *mac_id)
  197. {
  198. u32 macid_lo, macid_hi;
  199. macid_lo = mac_id[0] + (mac_id[1] << 8) + (mac_id[2] << 16) +
  200. (mac_id[3] << 24);
  201. macid_hi = mac_id[4] + (mac_id[5] << 8);
  202. writel(macid_hi, priv->mac_reg + EMAC_ADDR0_HIGH);
  203. writel(macid_lo, priv->mac_reg + EMAC_ADDR0_LOW);
  204. return 0;
  205. }
  206. static void sun8i_adjust_link(struct emac_eth_dev *priv,
  207. struct phy_device *phydev)
  208. {
  209. u32 v;
  210. v = readl(priv->mac_reg + EMAC_CTL0);
  211. if (phydev->duplex)
  212. v |= BIT(0);
  213. else
  214. v &= ~BIT(0);
  215. v &= ~0x0C;
  216. switch (phydev->speed) {
  217. case 1000:
  218. break;
  219. case 100:
  220. v |= BIT(2);
  221. v |= BIT(3);
  222. break;
  223. case 10:
  224. v |= BIT(3);
  225. break;
  226. }
  227. writel(v, priv->mac_reg + EMAC_CTL0);
  228. }
  229. static int sun8i_emac_set_syscon_ephy(struct emac_eth_dev *priv, u32 *reg)
  230. {
  231. if (priv->use_internal_phy) {
  232. /* H3 based SoC's that has an Internal 100MBit PHY
  233. * needs to be configured and powered up before use
  234. */
  235. *reg &= ~H3_EPHY_DEFAULT_MASK;
  236. *reg |= H3_EPHY_DEFAULT_VALUE;
  237. *reg |= priv->phyaddr << H3_EPHY_ADDR_SHIFT;
  238. *reg &= ~H3_EPHY_SHUTDOWN;
  239. *reg |= H3_EPHY_SELECT;
  240. } else
  241. /* This is to select External Gigabit PHY on
  242. * the boards with H3 SoC.
  243. */
  244. *reg &= ~H3_EPHY_SELECT;
  245. return 0;
  246. }
  247. static int sun8i_emac_set_syscon(struct sun8i_eth_pdata *pdata,
  248. struct emac_eth_dev *priv)
  249. {
  250. int ret;
  251. u32 reg;
  252. if (priv->variant == R40_GMAC) {
  253. /* Select RGMII for R40 */
  254. reg = readl(priv->sysctl_reg + 0x164);
  255. reg |= SC_ETCS_INT_GMII |
  256. SC_EPIT |
  257. (CONFIG_GMAC_TX_DELAY << SC_ETXDC_OFFSET);
  258. writel(reg, priv->sysctl_reg + 0x164);
  259. return 0;
  260. }
  261. reg = readl(priv->sysctl_reg + 0x30);
  262. if (priv->variant == H3_EMAC || priv->variant == H6_EMAC) {
  263. ret = sun8i_emac_set_syscon_ephy(priv, &reg);
  264. if (ret)
  265. return ret;
  266. }
  267. reg &= ~(SC_ETCS_MASK | SC_EPIT);
  268. if (priv->variant == H3_EMAC ||
  269. priv->variant == A64_EMAC ||
  270. priv->variant == H6_EMAC)
  271. reg &= ~SC_RMII_EN;
  272. switch (priv->interface) {
  273. case PHY_INTERFACE_MODE_MII:
  274. /* default */
  275. break;
  276. case PHY_INTERFACE_MODE_RGMII:
  277. reg |= SC_EPIT | SC_ETCS_INT_GMII;
  278. break;
  279. case PHY_INTERFACE_MODE_RMII:
  280. if (priv->variant == H3_EMAC ||
  281. priv->variant == A64_EMAC ||
  282. priv->variant == H6_EMAC) {
  283. reg |= SC_RMII_EN | SC_ETCS_EXT_GMII;
  284. break;
  285. }
  286. /* RMII not supported on A83T */
  287. default:
  288. debug("%s: Invalid PHY interface\n", __func__);
  289. return -EINVAL;
  290. }
  291. if (pdata->tx_delay_ps)
  292. reg |= ((pdata->tx_delay_ps / 100) << SC_ETXDC_OFFSET)
  293. & SC_ETXDC_MASK;
  294. if (pdata->rx_delay_ps)
  295. reg |= ((pdata->rx_delay_ps / 100) << SC_ERXDC_OFFSET)
  296. & SC_ERXDC_MASK;
  297. writel(reg, priv->sysctl_reg + 0x30);
  298. return 0;
  299. }
  300. static int sun8i_phy_init(struct emac_eth_dev *priv, void *dev)
  301. {
  302. struct phy_device *phydev;
  303. phydev = phy_connect(priv->bus, priv->phyaddr, dev, priv->interface);
  304. if (!phydev)
  305. return -ENODEV;
  306. phy_connect_dev(phydev, dev);
  307. priv->phydev = phydev;
  308. phy_config(priv->phydev);
  309. return 0;
  310. }
  311. static void rx_descs_init(struct emac_eth_dev *priv)
  312. {
  313. struct emac_dma_desc *desc_table_p = &priv->rx_chain[0];
  314. char *rxbuffs = &priv->rxbuffer[0];
  315. struct emac_dma_desc *desc_p;
  316. u32 idx;
  317. /* flush Rx buffers */
  318. flush_dcache_range((uintptr_t)rxbuffs, (ulong)rxbuffs +
  319. RX_TOTAL_BUFSIZE);
  320. for (idx = 0; idx < CONFIG_RX_DESCR_NUM; idx++) {
  321. desc_p = &desc_table_p[idx];
  322. desc_p->buf_addr = (uintptr_t)&rxbuffs[idx * CONFIG_ETH_BUFSIZE]
  323. ;
  324. desc_p->next = (uintptr_t)&desc_table_p[idx + 1];
  325. desc_p->st |= CONFIG_ETH_RXSIZE;
  326. desc_p->status = BIT(31);
  327. }
  328. /* Correcting the last pointer of the chain */
  329. desc_p->next = (uintptr_t)&desc_table_p[0];
  330. flush_dcache_range((uintptr_t)priv->rx_chain,
  331. (uintptr_t)priv->rx_chain +
  332. sizeof(priv->rx_chain));
  333. writel((uintptr_t)&desc_table_p[0], (priv->mac_reg + EMAC_RX_DMA_DESC));
  334. priv->rx_currdescnum = 0;
  335. }
  336. static void tx_descs_init(struct emac_eth_dev *priv)
  337. {
  338. struct emac_dma_desc *desc_table_p = &priv->tx_chain[0];
  339. char *txbuffs = &priv->txbuffer[0];
  340. struct emac_dma_desc *desc_p;
  341. u32 idx;
  342. for (idx = 0; idx < CONFIG_TX_DESCR_NUM; idx++) {
  343. desc_p = &desc_table_p[idx];
  344. desc_p->buf_addr = (uintptr_t)&txbuffs[idx * CONFIG_ETH_BUFSIZE]
  345. ;
  346. desc_p->next = (uintptr_t)&desc_table_p[idx + 1];
  347. desc_p->status = (1 << 31);
  348. desc_p->st = 0;
  349. }
  350. /* Correcting the last pointer of the chain */
  351. desc_p->next = (uintptr_t)&desc_table_p[0];
  352. /* Flush all Tx buffer descriptors */
  353. flush_dcache_range((uintptr_t)priv->tx_chain,
  354. (uintptr_t)priv->tx_chain +
  355. sizeof(priv->tx_chain));
  356. writel((uintptr_t)&desc_table_p[0], priv->mac_reg + EMAC_TX_DMA_DESC);
  357. priv->tx_currdescnum = 0;
  358. }
  359. static int _sun8i_emac_eth_init(struct emac_eth_dev *priv, u8 *enetaddr)
  360. {
  361. u32 reg, v;
  362. int timeout = 100;
  363. reg = readl((priv->mac_reg + EMAC_CTL1));
  364. if (!(reg & 0x1)) {
  365. /* Soft reset MAC */
  366. setbits_le32((priv->mac_reg + EMAC_CTL1), 0x1);
  367. do {
  368. reg = readl(priv->mac_reg + EMAC_CTL1);
  369. } while ((reg & 0x01) != 0 && (--timeout));
  370. if (!timeout) {
  371. printf("%s: Timeout\n", __func__);
  372. return -1;
  373. }
  374. }
  375. /* Rewrite mac address after reset */
  376. _sun8i_write_hwaddr(priv, enetaddr);
  377. v = readl(priv->mac_reg + EMAC_TX_CTL1);
  378. /* TX_MD Transmission starts after a full frame located in TX DMA FIFO*/
  379. v |= BIT(1);
  380. writel(v, priv->mac_reg + EMAC_TX_CTL1);
  381. v = readl(priv->mac_reg + EMAC_RX_CTL1);
  382. /* RX_MD RX DMA reads data from RX DMA FIFO to host memory after a
  383. * complete frame has been written to RX DMA FIFO
  384. */
  385. v |= BIT(1);
  386. writel(v, priv->mac_reg + EMAC_RX_CTL1);
  387. /* DMA */
  388. writel(8 << 24, priv->mac_reg + EMAC_CTL1);
  389. /* Initialize rx/tx descriptors */
  390. rx_descs_init(priv);
  391. tx_descs_init(priv);
  392. /* PHY Start Up */
  393. phy_startup(priv->phydev);
  394. sun8i_adjust_link(priv, priv->phydev);
  395. /* Start RX DMA */
  396. v = readl(priv->mac_reg + EMAC_RX_CTL1);
  397. v |= BIT(30);
  398. writel(v, priv->mac_reg + EMAC_RX_CTL1);
  399. /* Start TX DMA */
  400. v = readl(priv->mac_reg + EMAC_TX_CTL1);
  401. v |= BIT(30);
  402. writel(v, priv->mac_reg + EMAC_TX_CTL1);
  403. /* Enable RX/TX */
  404. setbits_le32(priv->mac_reg + EMAC_RX_CTL0, BIT(31));
  405. setbits_le32(priv->mac_reg + EMAC_TX_CTL0, BIT(31));
  406. return 0;
  407. }
  408. static int parse_phy_pins(struct udevice *dev)
  409. {
  410. struct emac_eth_dev *priv = dev_get_priv(dev);
  411. int offset;
  412. const char *pin_name;
  413. int drive, pull = SUN4I_PINCTRL_NO_PULL, i;
  414. offset = fdtdec_lookup_phandle(gd->fdt_blob, dev_of_offset(dev),
  415. "pinctrl-0");
  416. if (offset < 0) {
  417. printf("WARNING: emac: cannot find pinctrl-0 node\n");
  418. return offset;
  419. }
  420. drive = fdt_getprop_u32_default_node(gd->fdt_blob, offset, 0,
  421. "drive-strength", ~0);
  422. if (drive != ~0) {
  423. if (drive <= 10)
  424. drive = SUN4I_PINCTRL_10_MA;
  425. else if (drive <= 20)
  426. drive = SUN4I_PINCTRL_20_MA;
  427. else if (drive <= 30)
  428. drive = SUN4I_PINCTRL_30_MA;
  429. else
  430. drive = SUN4I_PINCTRL_40_MA;
  431. }
  432. if (fdt_get_property(gd->fdt_blob, offset, "bias-pull-up", NULL))
  433. pull = SUN4I_PINCTRL_PULL_UP;
  434. else if (fdt_get_property(gd->fdt_blob, offset, "bias-pull-down", NULL))
  435. pull = SUN4I_PINCTRL_PULL_DOWN;
  436. for (i = 0; ; i++) {
  437. int pin;
  438. pin_name = fdt_stringlist_get(gd->fdt_blob, offset,
  439. "pins", i, NULL);
  440. if (!pin_name)
  441. break;
  442. pin = sunxi_name_to_gpio(pin_name);
  443. if (pin < 0)
  444. continue;
  445. if (priv->variant == H3_EMAC)
  446. sunxi_gpio_set_cfgpin(pin, SUN8I_IOMUX_H3);
  447. else if (priv->variant == R40_GMAC || priv->variant == H6_EMAC)
  448. sunxi_gpio_set_cfgpin(pin, SUN8I_IOMUX_R40);
  449. else
  450. sunxi_gpio_set_cfgpin(pin, SUN8I_IOMUX);
  451. if (drive != ~0)
  452. sunxi_gpio_set_drv(pin, drive);
  453. if (pull != ~0)
  454. sunxi_gpio_set_pull(pin, pull);
  455. }
  456. if (!i) {
  457. printf("WARNING: emac: cannot find pins property\n");
  458. return -2;
  459. }
  460. return 0;
  461. }
  462. static int _sun8i_eth_recv(struct emac_eth_dev *priv, uchar **packetp)
  463. {
  464. u32 status, desc_num = priv->rx_currdescnum;
  465. struct emac_dma_desc *desc_p = &priv->rx_chain[desc_num];
  466. int length = -EAGAIN;
  467. int good_packet = 1;
  468. uintptr_t desc_start = (uintptr_t)desc_p;
  469. uintptr_t desc_end = desc_start +
  470. roundup(sizeof(*desc_p), ARCH_DMA_MINALIGN);
  471. ulong data_start = (uintptr_t)desc_p->buf_addr;
  472. ulong data_end;
  473. /* Invalidate entire buffer descriptor */
  474. invalidate_dcache_range(desc_start, desc_end);
  475. status = desc_p->status;
  476. /* Check for DMA own bit */
  477. if (!(status & BIT(31))) {
  478. length = (desc_p->status >> 16) & 0x3FFF;
  479. if (length < 0x40) {
  480. good_packet = 0;
  481. debug("RX: Bad Packet (runt)\n");
  482. }
  483. data_end = data_start + length;
  484. /* Invalidate received data */
  485. invalidate_dcache_range(rounddown(data_start,
  486. ARCH_DMA_MINALIGN),
  487. roundup(data_end,
  488. ARCH_DMA_MINALIGN));
  489. if (good_packet) {
  490. if (length > CONFIG_ETH_RXSIZE) {
  491. printf("Received packet is too big (len=%d)\n",
  492. length);
  493. return -EMSGSIZE;
  494. }
  495. *packetp = (uchar *)(ulong)desc_p->buf_addr;
  496. return length;
  497. }
  498. }
  499. return length;
  500. }
  501. static int _sun8i_emac_eth_send(struct emac_eth_dev *priv, void *packet,
  502. int len)
  503. {
  504. u32 v, desc_num = priv->tx_currdescnum;
  505. struct emac_dma_desc *desc_p = &priv->tx_chain[desc_num];
  506. uintptr_t desc_start = (uintptr_t)desc_p;
  507. uintptr_t desc_end = desc_start +
  508. roundup(sizeof(*desc_p), ARCH_DMA_MINALIGN);
  509. uintptr_t data_start = (uintptr_t)desc_p->buf_addr;
  510. uintptr_t data_end = data_start +
  511. roundup(len, ARCH_DMA_MINALIGN);
  512. /* Invalidate entire buffer descriptor */
  513. invalidate_dcache_range(desc_start, desc_end);
  514. desc_p->st = len;
  515. /* Mandatory undocumented bit */
  516. desc_p->st |= BIT(24);
  517. memcpy((void *)data_start, packet, len);
  518. /* Flush data to be sent */
  519. flush_dcache_range(data_start, data_end);
  520. /* frame end */
  521. desc_p->st |= BIT(30);
  522. desc_p->st |= BIT(31);
  523. /*frame begin */
  524. desc_p->st |= BIT(29);
  525. desc_p->status = BIT(31);
  526. /*Descriptors st and status field has changed, so FLUSH it */
  527. flush_dcache_range(desc_start, desc_end);
  528. /* Move to next Descriptor and wrap around */
  529. if (++desc_num >= CONFIG_TX_DESCR_NUM)
  530. desc_num = 0;
  531. priv->tx_currdescnum = desc_num;
  532. /* Start the DMA */
  533. v = readl(priv->mac_reg + EMAC_TX_CTL1);
  534. v |= BIT(31);/* mandatory */
  535. v |= BIT(30);/* mandatory */
  536. writel(v, priv->mac_reg + EMAC_TX_CTL1);
  537. return 0;
  538. }
  539. static int sun8i_eth_write_hwaddr(struct udevice *dev)
  540. {
  541. struct eth_pdata *pdata = dev_get_platdata(dev);
  542. struct emac_eth_dev *priv = dev_get_priv(dev);
  543. return _sun8i_write_hwaddr(priv, pdata->enetaddr);
  544. }
  545. static int sun8i_emac_board_setup(struct udevice *dev,
  546. struct emac_eth_dev *priv)
  547. {
  548. int ret;
  549. ret = clk_enable(&priv->tx_clk);
  550. if (ret) {
  551. dev_err(dev, "failed to enable TX clock\n");
  552. return ret;
  553. }
  554. if (reset_valid(&priv->tx_rst)) {
  555. ret = reset_deassert(&priv->tx_rst);
  556. if (ret) {
  557. dev_err(dev, "failed to deassert TX reset\n");
  558. goto err_tx_clk;
  559. }
  560. }
  561. /* Only H3/H5 have clock controls for internal EPHY */
  562. if (clk_valid(&priv->ephy_clk)) {
  563. ret = clk_enable(&priv->ephy_clk);
  564. if (ret) {
  565. dev_err(dev, "failed to enable EPHY TX clock\n");
  566. return ret;
  567. }
  568. }
  569. if (reset_valid(&priv->ephy_rst)) {
  570. ret = reset_deassert(&priv->ephy_rst);
  571. if (ret) {
  572. dev_err(dev, "failed to deassert EPHY TX clock\n");
  573. return ret;
  574. }
  575. }
  576. return 0;
  577. err_tx_clk:
  578. clk_disable(&priv->tx_clk);
  579. return ret;
  580. }
  581. #if CONFIG_IS_ENABLED(DM_GPIO)
  582. static int sun8i_mdio_reset(struct mii_dev *bus)
  583. {
  584. struct udevice *dev = bus->priv;
  585. struct emac_eth_dev *priv = dev_get_priv(dev);
  586. struct sun8i_eth_pdata *pdata = dev_get_platdata(dev);
  587. int ret;
  588. if (!dm_gpio_is_valid(&priv->reset_gpio))
  589. return 0;
  590. /* reset the phy */
  591. ret = dm_gpio_set_value(&priv->reset_gpio, 0);
  592. if (ret)
  593. return ret;
  594. udelay(pdata->reset_delays[0]);
  595. ret = dm_gpio_set_value(&priv->reset_gpio, 1);
  596. if (ret)
  597. return ret;
  598. udelay(pdata->reset_delays[1]);
  599. ret = dm_gpio_set_value(&priv->reset_gpio, 0);
  600. if (ret)
  601. return ret;
  602. udelay(pdata->reset_delays[2]);
  603. return 0;
  604. }
  605. #endif
  606. static int sun8i_mdio_init(const char *name, struct udevice *priv)
  607. {
  608. struct mii_dev *bus = mdio_alloc();
  609. if (!bus) {
  610. debug("Failed to allocate MDIO bus\n");
  611. return -ENOMEM;
  612. }
  613. bus->read = sun8i_mdio_read;
  614. bus->write = sun8i_mdio_write;
  615. snprintf(bus->name, sizeof(bus->name), name);
  616. bus->priv = (void *)priv;
  617. #if CONFIG_IS_ENABLED(DM_GPIO)
  618. bus->reset = sun8i_mdio_reset;
  619. #endif
  620. return mdio_register(bus);
  621. }
  622. static int sun8i_emac_eth_start(struct udevice *dev)
  623. {
  624. struct eth_pdata *pdata = dev_get_platdata(dev);
  625. return _sun8i_emac_eth_init(dev->priv, pdata->enetaddr);
  626. }
  627. static int sun8i_emac_eth_send(struct udevice *dev, void *packet, int length)
  628. {
  629. struct emac_eth_dev *priv = dev_get_priv(dev);
  630. return _sun8i_emac_eth_send(priv, packet, length);
  631. }
  632. static int sun8i_emac_eth_recv(struct udevice *dev, int flags, uchar **packetp)
  633. {
  634. struct emac_eth_dev *priv = dev_get_priv(dev);
  635. return _sun8i_eth_recv(priv, packetp);
  636. }
  637. static int _sun8i_free_pkt(struct emac_eth_dev *priv)
  638. {
  639. u32 desc_num = priv->rx_currdescnum;
  640. struct emac_dma_desc *desc_p = &priv->rx_chain[desc_num];
  641. uintptr_t desc_start = (uintptr_t)desc_p;
  642. uintptr_t desc_end = desc_start +
  643. roundup(sizeof(u32), ARCH_DMA_MINALIGN);
  644. /* Make the current descriptor valid again */
  645. desc_p->status |= BIT(31);
  646. /* Flush Status field of descriptor */
  647. flush_dcache_range(desc_start, desc_end);
  648. /* Move to next desc and wrap-around condition. */
  649. if (++desc_num >= CONFIG_RX_DESCR_NUM)
  650. desc_num = 0;
  651. priv->rx_currdescnum = desc_num;
  652. return 0;
  653. }
  654. static int sun8i_eth_free_pkt(struct udevice *dev, uchar *packet,
  655. int length)
  656. {
  657. struct emac_eth_dev *priv = dev_get_priv(dev);
  658. return _sun8i_free_pkt(priv);
  659. }
  660. static void sun8i_emac_eth_stop(struct udevice *dev)
  661. {
  662. struct emac_eth_dev *priv = dev_get_priv(dev);
  663. /* Stop Rx/Tx transmitter */
  664. clrbits_le32(priv->mac_reg + EMAC_RX_CTL0, BIT(31));
  665. clrbits_le32(priv->mac_reg + EMAC_TX_CTL0, BIT(31));
  666. /* Stop TX DMA */
  667. clrbits_le32(priv->mac_reg + EMAC_TX_CTL1, BIT(30));
  668. phy_shutdown(priv->phydev);
  669. }
  670. static int sun8i_emac_eth_probe(struct udevice *dev)
  671. {
  672. struct sun8i_eth_pdata *sun8i_pdata = dev_get_platdata(dev);
  673. struct eth_pdata *pdata = &sun8i_pdata->eth_pdata;
  674. struct emac_eth_dev *priv = dev_get_priv(dev);
  675. int ret;
  676. priv->mac_reg = (void *)pdata->iobase;
  677. ret = sun8i_emac_board_setup(dev, priv);
  678. if (ret)
  679. return ret;
  680. sun8i_emac_set_syscon(sun8i_pdata, priv);
  681. sun8i_mdio_init(dev->name, dev);
  682. priv->bus = miiphy_get_dev_by_name(dev->name);
  683. return sun8i_phy_init(priv, dev);
  684. }
  685. static const struct eth_ops sun8i_emac_eth_ops = {
  686. .start = sun8i_emac_eth_start,
  687. .write_hwaddr = sun8i_eth_write_hwaddr,
  688. .send = sun8i_emac_eth_send,
  689. .recv = sun8i_emac_eth_recv,
  690. .free_pkt = sun8i_eth_free_pkt,
  691. .stop = sun8i_emac_eth_stop,
  692. };
  693. static int sun8i_get_ephy_nodes(struct udevice *dev, struct emac_eth_dev *priv)
  694. {
  695. int emac_node, ephy_node, ret, ephy_handle;
  696. emac_node = fdt_path_offset(gd->fdt_blob,
  697. "/soc/ethernet@1c30000");
  698. if (emac_node < 0) {
  699. debug("failed to get emac node\n");
  700. return emac_node;
  701. }
  702. ephy_handle = fdtdec_lookup_phandle(gd->fdt_blob,
  703. emac_node, "phy-handle");
  704. /* look for mdio-mux node for internal PHY node */
  705. ephy_node = fdt_path_offset(gd->fdt_blob,
  706. "/soc/ethernet@1c30000/mdio-mux/mdio@1/ethernet-phy@1");
  707. if (ephy_node < 0) {
  708. debug("failed to get mdio-mux with internal PHY\n");
  709. return ephy_node;
  710. }
  711. /* This is not the phy we are looking for */
  712. if (ephy_node != ephy_handle)
  713. return 0;
  714. ret = fdt_node_check_compatible(gd->fdt_blob, ephy_node,
  715. "allwinner,sun8i-h3-mdio-internal");
  716. if (ret < 0) {
  717. debug("failed to find mdio-internal node\n");
  718. return ret;
  719. }
  720. ret = clk_get_by_index_nodev(offset_to_ofnode(ephy_node), 0,
  721. &priv->ephy_clk);
  722. if (ret) {
  723. dev_err(dev, "failed to get EPHY TX clock\n");
  724. return ret;
  725. }
  726. ret = reset_get_by_index_nodev(offset_to_ofnode(ephy_node), 0,
  727. &priv->ephy_rst);
  728. if (ret) {
  729. dev_err(dev, "failed to get EPHY TX reset\n");
  730. return ret;
  731. }
  732. priv->use_internal_phy = true;
  733. return 0;
  734. }
  735. static int sun8i_emac_eth_ofdata_to_platdata(struct udevice *dev)
  736. {
  737. struct sun8i_eth_pdata *sun8i_pdata = dev_get_platdata(dev);
  738. struct eth_pdata *pdata = &sun8i_pdata->eth_pdata;
  739. struct emac_eth_dev *priv = dev_get_priv(dev);
  740. const char *phy_mode;
  741. const fdt32_t *reg;
  742. int node = dev_of_offset(dev);
  743. int offset = 0;
  744. #if CONFIG_IS_ENABLED(DM_GPIO)
  745. int reset_flags = GPIOD_IS_OUT;
  746. #endif
  747. int ret;
  748. pdata->iobase = dev_read_addr(dev);
  749. if (pdata->iobase == FDT_ADDR_T_NONE) {
  750. debug("%s: Cannot find MAC base address\n", __func__);
  751. return -EINVAL;
  752. }
  753. priv->variant = dev_get_driver_data(dev);
  754. if (!priv->variant) {
  755. printf("%s: Missing variant\n", __func__);
  756. return -EINVAL;
  757. }
  758. ret = clk_get_by_name(dev, "stmmaceth", &priv->tx_clk);
  759. if (ret) {
  760. dev_err(dev, "failed to get TX clock\n");
  761. return ret;
  762. }
  763. ret = reset_get_by_name(dev, "stmmaceth", &priv->tx_rst);
  764. if (ret && ret != -ENOENT) {
  765. dev_err(dev, "failed to get TX reset\n");
  766. return ret;
  767. }
  768. offset = fdtdec_lookup_phandle(gd->fdt_blob, node, "syscon");
  769. if (offset < 0) {
  770. debug("%s: cannot find syscon node\n", __func__);
  771. return -EINVAL;
  772. }
  773. reg = fdt_getprop(gd->fdt_blob, offset, "reg", NULL);
  774. if (!reg) {
  775. debug("%s: cannot find reg property in syscon node\n",
  776. __func__);
  777. return -EINVAL;
  778. }
  779. priv->sysctl_reg = fdt_translate_address((void *)gd->fdt_blob,
  780. offset, reg);
  781. if (priv->sysctl_reg == FDT_ADDR_T_NONE) {
  782. debug("%s: Cannot find syscon base address\n", __func__);
  783. return -EINVAL;
  784. }
  785. pdata->phy_interface = -1;
  786. priv->phyaddr = -1;
  787. priv->use_internal_phy = false;
  788. offset = fdtdec_lookup_phandle(gd->fdt_blob, node, "phy-handle");
  789. if (offset < 0) {
  790. debug("%s: Cannot find PHY address\n", __func__);
  791. return -EINVAL;
  792. }
  793. priv->phyaddr = fdtdec_get_int(gd->fdt_blob, offset, "reg", -1);
  794. phy_mode = fdt_getprop(gd->fdt_blob, node, "phy-mode", NULL);
  795. if (phy_mode)
  796. pdata->phy_interface = phy_get_interface_by_name(phy_mode);
  797. printf("phy interface%d\n", pdata->phy_interface);
  798. if (pdata->phy_interface == -1) {
  799. debug("%s: Invalid PHY interface '%s'\n", __func__, phy_mode);
  800. return -EINVAL;
  801. }
  802. if (priv->variant == H3_EMAC) {
  803. ret = sun8i_get_ephy_nodes(dev, priv);
  804. if (ret)
  805. return ret;
  806. }
  807. priv->interface = pdata->phy_interface;
  808. if (!priv->use_internal_phy)
  809. parse_phy_pins(dev);
  810. sun8i_pdata->tx_delay_ps = fdtdec_get_int(gd->fdt_blob, node,
  811. "allwinner,tx-delay-ps", 0);
  812. if (sun8i_pdata->tx_delay_ps < 0 || sun8i_pdata->tx_delay_ps > 700)
  813. printf("%s: Invalid TX delay value %d\n", __func__,
  814. sun8i_pdata->tx_delay_ps);
  815. sun8i_pdata->rx_delay_ps = fdtdec_get_int(gd->fdt_blob, node,
  816. "allwinner,rx-delay-ps", 0);
  817. if (sun8i_pdata->rx_delay_ps < 0 || sun8i_pdata->rx_delay_ps > 3100)
  818. printf("%s: Invalid RX delay value %d\n", __func__,
  819. sun8i_pdata->rx_delay_ps);
  820. #if CONFIG_IS_ENABLED(DM_GPIO)
  821. if (fdtdec_get_bool(gd->fdt_blob, dev_of_offset(dev),
  822. "snps,reset-active-low"))
  823. reset_flags |= GPIOD_ACTIVE_LOW;
  824. ret = gpio_request_by_name(dev, "snps,reset-gpio", 0,
  825. &priv->reset_gpio, reset_flags);
  826. if (ret == 0) {
  827. ret = fdtdec_get_int_array(gd->fdt_blob, dev_of_offset(dev),
  828. "snps,reset-delays-us",
  829. sun8i_pdata->reset_delays, 3);
  830. } else if (ret == -ENOENT) {
  831. ret = 0;
  832. }
  833. #endif
  834. return 0;
  835. }
  836. static const struct udevice_id sun8i_emac_eth_ids[] = {
  837. {.compatible = "allwinner,sun8i-h3-emac", .data = (uintptr_t)H3_EMAC },
  838. {.compatible = "allwinner,sun50i-a64-emac",
  839. .data = (uintptr_t)A64_EMAC },
  840. {.compatible = "allwinner,sun8i-a83t-emac",
  841. .data = (uintptr_t)A83T_EMAC },
  842. {.compatible = "allwinner,sun8i-r40-gmac",
  843. .data = (uintptr_t)R40_GMAC },
  844. {.compatible = "allwinner,sun50i-h6-emac",
  845. .data = (uintptr_t)H6_EMAC },
  846. { }
  847. };
  848. U_BOOT_DRIVER(eth_sun8i_emac) = {
  849. .name = "eth_sun8i_emac",
  850. .id = UCLASS_ETH,
  851. .of_match = sun8i_emac_eth_ids,
  852. .ofdata_to_platdata = sun8i_emac_eth_ofdata_to_platdata,
  853. .probe = sun8i_emac_eth_probe,
  854. .ops = &sun8i_emac_eth_ops,
  855. .priv_auto_alloc_size = sizeof(struct emac_eth_dev),
  856. .platdata_auto_alloc_size = sizeof(struct sun8i_eth_pdata),
  857. .flags = DM_FLAG_ALLOC_PRIV_DMA,
  858. };