ftmac100.c 10.0 KB

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