ftmac100.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Faraday FTMAC100 Ethernet
  4. *
  5. * (C) Copyright 2009 Faraday Technology
  6. * Po-Yu Chuang <ratbert@faraday-tech.com>
  7. */
  8. #include <config.h>
  9. #include <common.h>
  10. #include <cpu_func.h>
  11. #include <env.h>
  12. #include <malloc.h>
  13. #include <net.h>
  14. #include <asm/global_data.h>
  15. #include <linux/delay.h>
  16. #include <linux/io.h>
  17. #include "ftmac100.h"
  18. #ifdef CONFIG_DM_ETH
  19. #include <dm.h>
  20. DECLARE_GLOBAL_DATA_PTR;
  21. #endif
  22. #define ETH_ZLEN 60
  23. struct ftmac100_data {
  24. struct ftmac100_txdes txdes[1];
  25. struct ftmac100_rxdes rxdes[PKTBUFSRX];
  26. int rx_index;
  27. const char *name;
  28. phys_addr_t iobase;
  29. };
  30. /*
  31. * Reset MAC
  32. */
  33. static void ftmac100_reset(struct ftmac100_data *priv)
  34. {
  35. struct ftmac100 *ftmac100 = (struct ftmac100 *)(uintptr_t)priv->iobase;
  36. debug ("%s()\n", __func__);
  37. writel (FTMAC100_MACCR_SW_RST, &ftmac100->maccr);
  38. while (readl (&ftmac100->maccr) & FTMAC100_MACCR_SW_RST)
  39. mdelay(1);
  40. /*
  41. * When soft reset complete, write mac address immediately maybe fail somehow
  42. * Wait for a while can avoid this problem
  43. */
  44. mdelay(1);
  45. }
  46. /*
  47. * Set MAC address
  48. */
  49. static void ftmac100_set_mac(struct ftmac100_data *priv ,
  50. const unsigned char *mac)
  51. {
  52. struct ftmac100 *ftmac100 = (struct ftmac100 *)(uintptr_t)priv->iobase;
  53. unsigned int maddr = mac[0] << 8 | mac[1];
  54. unsigned int laddr = mac[2] << 24 | mac[3] << 16 | mac[4] << 8 | mac[5];
  55. debug ("%s(%x %x)\n", __func__, maddr, laddr);
  56. writel (maddr, &ftmac100->mac_madr);
  57. writel (laddr, &ftmac100->mac_ladr);
  58. }
  59. /*
  60. * Disable MAC
  61. */
  62. static void _ftmac100_halt(struct ftmac100_data *priv)
  63. {
  64. struct ftmac100 *ftmac100 = (struct ftmac100 *)(uintptr_t)priv->iobase;
  65. debug ("%s()\n", __func__);
  66. writel (0, &ftmac100->maccr);
  67. }
  68. /*
  69. * Initialize MAC
  70. */
  71. static int _ftmac100_init(struct ftmac100_data *priv, unsigned char enetaddr[6])
  72. {
  73. struct ftmac100 *ftmac100 = (struct ftmac100 *)(uintptr_t)priv->iobase;
  74. struct ftmac100_txdes *txdes = priv->txdes;
  75. struct ftmac100_rxdes *rxdes = priv->rxdes;
  76. unsigned int maccr;
  77. int i;
  78. debug ("%s()\n", __func__);
  79. ftmac100_reset(priv);
  80. /* set the ethernet address */
  81. ftmac100_set_mac(priv, enetaddr);
  82. /* disable all interrupts */
  83. writel (0, &ftmac100->imr);
  84. /* initialize descriptors */
  85. priv->rx_index = 0;
  86. txdes[0].txdes1 = FTMAC100_TXDES1_EDOTR;
  87. rxdes[PKTBUFSRX - 1].rxdes1 = FTMAC100_RXDES1_EDORR;
  88. for (i = 0; i < PKTBUFSRX; i++) {
  89. /* RXBUF_BADR */
  90. rxdes[i].rxdes2 = (unsigned int)(unsigned long)net_rx_packets[i];
  91. rxdes[i].rxdes1 |= FTMAC100_RXDES1_RXBUF_SIZE (PKTSIZE_ALIGN);
  92. rxdes[i].rxdes0 = FTMAC100_RXDES0_RXDMA_OWN;
  93. }
  94. /* transmit ring */
  95. writel ((unsigned long)txdes, &ftmac100->txr_badr);
  96. /* receive ring */
  97. writel ((unsigned long)rxdes, &ftmac100->rxr_badr);
  98. /* poll receive descriptor automatically */
  99. writel (FTMAC100_APTC_RXPOLL_CNT (1), &ftmac100->aptc);
  100. /* enable transmitter, receiver */
  101. maccr = FTMAC100_MACCR_XMT_EN |
  102. FTMAC100_MACCR_RCV_EN |
  103. FTMAC100_MACCR_XDMA_EN |
  104. FTMAC100_MACCR_RDMA_EN |
  105. FTMAC100_MACCR_CRC_APD |
  106. FTMAC100_MACCR_ENRX_IN_HALFTX |
  107. FTMAC100_MACCR_RX_RUNT |
  108. FTMAC100_MACCR_RX_BROADPKT;
  109. writel (maccr, &ftmac100->maccr);
  110. return 0;
  111. }
  112. /*
  113. * Free receiving buffer
  114. */
  115. static int _ftmac100_free_pkt(struct ftmac100_data *priv)
  116. {
  117. struct ftmac100_rxdes *curr_des;
  118. curr_des = &priv->rxdes[priv->rx_index];
  119. /* release buffer to DMA */
  120. curr_des->rxdes0 |= FTMAC100_RXDES0_RXDMA_OWN;
  121. priv->rx_index = (priv->rx_index + 1) % PKTBUFSRX;
  122. return 0;
  123. }
  124. /*
  125. * Receive a data block via Ethernet
  126. */
  127. static int __ftmac100_recv(struct ftmac100_data *priv)
  128. {
  129. struct ftmac100_rxdes *curr_des;
  130. unsigned short rxlen;
  131. curr_des = &priv->rxdes[priv->rx_index];
  132. if (curr_des->rxdes0 & FTMAC100_RXDES0_RXDMA_OWN)
  133. return 0;
  134. if (curr_des->rxdes0 & (FTMAC100_RXDES0_RX_ERR |
  135. FTMAC100_RXDES0_CRC_ERR |
  136. FTMAC100_RXDES0_FTL |
  137. FTMAC100_RXDES0_RUNT |
  138. FTMAC100_RXDES0_RX_ODD_NB)) {
  139. return 0;
  140. }
  141. rxlen = FTMAC100_RXDES0_RFL (curr_des->rxdes0);
  142. invalidate_dcache_range(curr_des->rxdes2,curr_des->rxdes2+rxlen);
  143. debug ("%s(): RX buffer %d, %x received\n",
  144. __func__, priv->rx_index, rxlen);
  145. return rxlen;
  146. }
  147. /*
  148. * Send a data block via Ethernet
  149. */
  150. static int _ftmac100_send(struct ftmac100_data *priv, void *packet, int length)
  151. {
  152. struct ftmac100 *ftmac100 = (struct ftmac100 *)(uintptr_t)priv->iobase;
  153. struct ftmac100_txdes *curr_des = priv->txdes;
  154. ulong start;
  155. if (curr_des->txdes0 & FTMAC100_TXDES0_TXDMA_OWN) {
  156. debug ("%s(): no TX descriptor available\n", __func__);
  157. return -1;
  158. }
  159. debug ("%s(%lx, %x)\n", __func__, (unsigned long)packet, length);
  160. length = (length < ETH_ZLEN) ? ETH_ZLEN : length;
  161. /* initiate a transmit sequence */
  162. flush_dcache_range((unsigned long)packet,(unsigned long)packet+length);
  163. curr_des->txdes2 = (unsigned int)(unsigned long)packet; /* TXBUF_BADR */
  164. curr_des->txdes1 &= FTMAC100_TXDES1_EDOTR;
  165. curr_des->txdes1 |= FTMAC100_TXDES1_FTS |
  166. FTMAC100_TXDES1_LTS |
  167. FTMAC100_TXDES1_TXBUF_SIZE (length);
  168. curr_des->txdes0 = FTMAC100_TXDES0_TXDMA_OWN;
  169. /* start transmit */
  170. writel (1, &ftmac100->txpd);
  171. /* wait for transfer to succeed */
  172. start = get_timer(0);
  173. while (curr_des->txdes0 & FTMAC100_TXDES0_TXDMA_OWN) {
  174. if (get_timer(start) >= 5) {
  175. debug ("%s(): timed out\n", __func__);
  176. return -1;
  177. }
  178. }
  179. debug ("%s(): packet sent\n", __func__);
  180. return 0;
  181. }
  182. #ifndef CONFIG_DM_ETH
  183. /*
  184. * disable transmitter, receiver
  185. */
  186. static void ftmac100_halt(struct eth_device *dev)
  187. {
  188. struct ftmac100_data *priv = dev->priv;
  189. return _ftmac100_halt(priv);
  190. }
  191. static int ftmac100_init(struct eth_device *dev, struct bd_info *bd)
  192. {
  193. struct ftmac100_data *priv = dev->priv;
  194. return _ftmac100_init(priv , dev->enetaddr);
  195. }
  196. static int _ftmac100_recv(struct ftmac100_data *priv)
  197. {
  198. struct ftmac100_rxdes *curr_des;
  199. unsigned short len;
  200. curr_des = &priv->rxdes[priv->rx_index];
  201. len = __ftmac100_recv(priv);
  202. if (len) {
  203. /* pass the packet up to the protocol layers. */
  204. net_process_received_packet((void *)curr_des->rxdes2, len);
  205. _ftmac100_free_pkt(priv);
  206. }
  207. return len ? 1 : 0;
  208. }
  209. /*
  210. * Get a data block via Ethernet
  211. */
  212. static int ftmac100_recv(struct eth_device *dev)
  213. {
  214. struct ftmac100_data *priv = dev->priv;
  215. return _ftmac100_recv(priv);
  216. }
  217. /*
  218. * Send a data block via Ethernet
  219. */
  220. static int ftmac100_send(struct eth_device *dev, void *packet, int length)
  221. {
  222. struct ftmac100_data *priv = dev->priv;
  223. return _ftmac100_send(priv , packet , length);
  224. }
  225. int ftmac100_initialize (struct bd_info *bd)
  226. {
  227. struct eth_device *dev;
  228. struct ftmac100_data *priv;
  229. dev = malloc (sizeof *dev);
  230. if (!dev) {
  231. printf ("%s(): failed to allocate dev\n", __func__);
  232. goto out;
  233. }
  234. /* Transmit and receive descriptors should align to 16 bytes */
  235. priv = memalign (16, sizeof (struct ftmac100_data));
  236. if (!priv) {
  237. printf ("%s(): failed to allocate priv\n", __func__);
  238. goto free_dev;
  239. }
  240. memset (dev, 0, sizeof (*dev));
  241. memset (priv, 0, sizeof (*priv));
  242. strcpy(dev->name, "FTMAC100");
  243. dev->iobase = CONFIG_FTMAC100_BASE;
  244. dev->init = ftmac100_init;
  245. dev->halt = ftmac100_halt;
  246. dev->send = ftmac100_send;
  247. dev->recv = ftmac100_recv;
  248. dev->priv = priv;
  249. priv->iobase = dev->iobase;
  250. eth_register (dev);
  251. return 1;
  252. free_dev:
  253. free (dev);
  254. out:
  255. return 0;
  256. }
  257. #endif
  258. #ifdef CONFIG_DM_ETH
  259. static int ftmac100_start(struct udevice *dev)
  260. {
  261. struct eth_pdata *plat = dev_get_plat(dev);
  262. struct ftmac100_data *priv = dev_get_priv(dev);
  263. return _ftmac100_init(priv, plat->enetaddr);
  264. }
  265. static void ftmac100_stop(struct udevice *dev)
  266. {
  267. struct ftmac100_data *priv = dev_get_priv(dev);
  268. _ftmac100_halt(priv);
  269. }
  270. static int ftmac100_send(struct udevice *dev, void *packet, int length)
  271. {
  272. struct ftmac100_data *priv = dev_get_priv(dev);
  273. int ret;
  274. ret = _ftmac100_send(priv , packet , length);
  275. return ret ? 0 : -ETIMEDOUT;
  276. }
  277. static int ftmac100_recv(struct udevice *dev, int flags, uchar **packetp)
  278. {
  279. struct ftmac100_data *priv = dev_get_priv(dev);
  280. struct ftmac100_rxdes *curr_des;
  281. curr_des = &priv->rxdes[priv->rx_index];
  282. int len;
  283. len = __ftmac100_recv(priv);
  284. if (len)
  285. *packetp = (uchar *)(unsigned long)curr_des->rxdes2;
  286. return len ? len : -EAGAIN;
  287. }
  288. static int ftmac100_free_pkt(struct udevice *dev, uchar *packet, int length)
  289. {
  290. struct ftmac100_data *priv = dev_get_priv(dev);
  291. _ftmac100_free_pkt(priv);
  292. return 0;
  293. }
  294. int ftmac100_read_rom_hwaddr(struct udevice *dev)
  295. {
  296. struct eth_pdata *pdata = dev_get_plat(dev);
  297. eth_env_get_enetaddr("ethaddr", pdata->enetaddr);
  298. return 0;
  299. }
  300. static const char *dtbmacaddr(u32 ifno)
  301. {
  302. int node, len;
  303. char enet[16];
  304. const char *mac;
  305. const char *path;
  306. if (gd->fdt_blob == NULL) {
  307. printf("%s: don't have a valid gd->fdt_blob!\n", __func__);
  308. return NULL;
  309. }
  310. node = fdt_path_offset(gd->fdt_blob, "/aliases");
  311. if (node < 0)
  312. return NULL;
  313. sprintf(enet, "ethernet%d", ifno);
  314. path = fdt_getprop(gd->fdt_blob, node, enet, NULL);
  315. if (!path) {
  316. printf("no alias for %s\n", enet);
  317. return NULL;
  318. }
  319. node = fdt_path_offset(gd->fdt_blob, path);
  320. mac = fdt_getprop(gd->fdt_blob, node, "mac-address", &len);
  321. if (mac && is_valid_ethaddr((u8 *)mac))
  322. return mac;
  323. return NULL;
  324. }
  325. static int ftmac100_of_to_plat(struct udevice *dev)
  326. {
  327. struct ftmac100_data *priv = dev_get_priv(dev);
  328. struct eth_pdata *pdata = dev_get_plat(dev);
  329. const char *mac;
  330. pdata->iobase = dev_read_addr(dev);
  331. priv->iobase = pdata->iobase;
  332. mac = dtbmacaddr(0);
  333. if (mac)
  334. memcpy(pdata->enetaddr , mac , 6);
  335. return 0;
  336. }
  337. static int ftmac100_probe(struct udevice *dev)
  338. {
  339. struct ftmac100_data *priv = dev_get_priv(dev);
  340. priv->name = dev->name;
  341. return 0;
  342. }
  343. static int ftmac100_bind(struct udevice *dev)
  344. {
  345. return device_set_name(dev, dev->name);
  346. }
  347. static const struct eth_ops ftmac100_ops = {
  348. .start = ftmac100_start,
  349. .send = ftmac100_send,
  350. .recv = ftmac100_recv,
  351. .stop = ftmac100_stop,
  352. .free_pkt = ftmac100_free_pkt,
  353. };
  354. static const struct udevice_id ftmac100_ids[] = {
  355. { .compatible = "andestech,atmac100" },
  356. { }
  357. };
  358. U_BOOT_DRIVER(ftmac100) = {
  359. .name = "nds32_mac",
  360. .id = UCLASS_ETH,
  361. .of_match = ftmac100_ids,
  362. .bind = ftmac100_bind,
  363. .of_to_plat = ftmac100_of_to_plat,
  364. .probe = ftmac100_probe,
  365. .ops = &ftmac100_ops,
  366. .priv_auto = sizeof(struct ftmac100_data),
  367. .plat_auto = sizeof(struct eth_pdata),
  368. .flags = DM_FLAG_ALLOC_PRIV_DMA,
  369. };
  370. #endif