ftmac100.c 10 KB

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