mipsnet.c 8.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370
  1. /*
  2. * This file is subject to the terms and conditions of the GNU General Public
  3. * License. See the file "COPYING" in the main directory of this archive
  4. * for more details.
  5. */
  6. #define DEBUG
  7. #include <linux/init.h>
  8. #include <linux/kernel.h>
  9. #include <linux/module.h>
  10. #include <linux/netdevice.h>
  11. #include <linux/etherdevice.h>
  12. #include <linux/netdevice.h>
  13. #include <linux/platform_device.h>
  14. #include <asm/io.h>
  15. #include <asm/mips-boards/simint.h>
  16. #include "mipsnet.h" /* actual device IO mapping */
  17. #define MIPSNET_VERSION "2005-06-20"
  18. #define mipsnet_reg_address(dev, field) (dev->base_addr + field_offset(field))
  19. struct mipsnet_priv {
  20. struct net_device_stats stats;
  21. };
  22. static struct platform_device *mips_plat_dev;
  23. static char mipsnet_string[] = "mipsnet";
  24. /*
  25. * Copy data from the MIPSNET rx data port
  26. */
  27. static int ioiocpy_frommipsnet(struct net_device *dev, unsigned char *kdata,
  28. int len)
  29. {
  30. uint32_t available_len = inl(mipsnet_reg_address(dev, rxDataCount));
  31. if (available_len < len)
  32. return -EFAULT;
  33. for (; len > 0; len--, kdata++) {
  34. *kdata = inb(mipsnet_reg_address(dev, rxDataBuffer));
  35. }
  36. return inl(mipsnet_reg_address(dev, rxDataCount));
  37. }
  38. static inline ssize_t mipsnet_put_todevice(struct net_device *dev,
  39. struct sk_buff *skb)
  40. {
  41. int count_to_go = skb->len;
  42. char *buf_ptr = skb->data;
  43. struct mipsnet_priv *mp = netdev_priv(dev);
  44. pr_debug("%s: %s(): telling MIPSNET txDataCount(%d)\n",
  45. dev->name, __FUNCTION__, skb->len);
  46. outl(skb->len, mipsnet_reg_address(dev, txDataCount));
  47. pr_debug("%s: %s(): sending data to MIPSNET txDataBuffer(%d)\n",
  48. dev->name, __FUNCTION__, skb->len);
  49. for (; count_to_go; buf_ptr++, count_to_go--) {
  50. outb(*buf_ptr, mipsnet_reg_address(dev, txDataBuffer));
  51. }
  52. mp->stats.tx_packets++;
  53. mp->stats.tx_bytes += skb->len;
  54. return skb->len;
  55. }
  56. static int mipsnet_xmit(struct sk_buff *skb, struct net_device *dev)
  57. {
  58. pr_debug("%s:%s(): transmitting %d bytes\n",
  59. dev->name, __FUNCTION__, skb->len);
  60. /* Only one packet at a time. Once TXDONE interrupt is serviced, the
  61. * queue will be restarted.
  62. */
  63. netif_stop_queue(dev);
  64. mipsnet_put_todevice(dev, skb);
  65. return 0;
  66. }
  67. static inline ssize_t mipsnet_get_fromdev(struct net_device *dev, size_t count)
  68. {
  69. struct sk_buff *skb;
  70. size_t len = count;
  71. struct mipsnet_priv *mp = netdev_priv(dev);
  72. if (!(skb = alloc_skb(len + 2, GFP_KERNEL))) {
  73. mp->stats.rx_dropped++;
  74. return -ENOMEM;
  75. }
  76. skb_reserve(skb, 2);
  77. if (ioiocpy_frommipsnet(dev, skb_put(skb, len), len))
  78. return -EFAULT;
  79. skb->dev = dev;
  80. skb->protocol = eth_type_trans(skb, dev);
  81. skb->ip_summed = CHECKSUM_UNNECESSARY;
  82. pr_debug("%s:%s(): pushing RXed data to kernel\n",
  83. dev->name, __FUNCTION__);
  84. netif_rx(skb);
  85. mp->stats.rx_packets++;
  86. mp->stats.rx_bytes += len;
  87. return count;
  88. }
  89. static irqreturn_t mipsnet_interrupt(int irq, void *dev_id)
  90. {
  91. struct net_device *dev = dev_id;
  92. irqreturn_t retval = IRQ_NONE;
  93. uint64_t interruptFlags;
  94. if (irq == dev->irq) {
  95. pr_debug("%s:%s(): irq %d for device\n",
  96. dev->name, __FUNCTION__, irq);
  97. retval = IRQ_HANDLED;
  98. interruptFlags =
  99. inl(mipsnet_reg_address(dev, interruptControl));
  100. pr_debug("%s:%s(): intCtl=0x%016llx\n", dev->name,
  101. __FUNCTION__, interruptFlags);
  102. if (interruptFlags & MIPSNET_INTCTL_TXDONE) {
  103. pr_debug("%s:%s(): got TXDone\n",
  104. dev->name, __FUNCTION__);
  105. outl(MIPSNET_INTCTL_TXDONE,
  106. mipsnet_reg_address(dev, interruptControl));
  107. // only one packet at a time, we are done.
  108. netif_wake_queue(dev);
  109. } else if (interruptFlags & MIPSNET_INTCTL_RXDONE) {
  110. pr_debug("%s:%s(): got RX data\n",
  111. dev->name, __FUNCTION__);
  112. mipsnet_get_fromdev(dev,
  113. inl(mipsnet_reg_address(dev, rxDataCount)));
  114. pr_debug("%s:%s(): clearing RX int\n",
  115. dev->name, __FUNCTION__);
  116. outl(MIPSNET_INTCTL_RXDONE,
  117. mipsnet_reg_address(dev, interruptControl));
  118. } else if (interruptFlags & MIPSNET_INTCTL_TESTBIT) {
  119. pr_debug("%s:%s(): got test interrupt\n",
  120. dev->name, __FUNCTION__);
  121. // TESTBIT is cleared on read.
  122. // And takes effect after a write with 0
  123. outl(0, mipsnet_reg_address(dev, interruptControl));
  124. } else {
  125. pr_debug("%s:%s(): no valid fags 0x%016llx\n",
  126. dev->name, __FUNCTION__, interruptFlags);
  127. // Maybe shared IRQ, just ignore, no clearing.
  128. retval = IRQ_NONE;
  129. }
  130. } else {
  131. printk(KERN_INFO "%s: %s(): irq %d for unknown device\n",
  132. dev->name, __FUNCTION__, irq);
  133. retval = IRQ_NONE;
  134. }
  135. return retval;
  136. } //mipsnet_interrupt()
  137. static int mipsnet_open(struct net_device *dev)
  138. {
  139. int err;
  140. pr_debug("%s: mipsnet_open\n", dev->name);
  141. err = request_irq(dev->irq, &mipsnet_interrupt,
  142. IRQF_SHARED, dev->name, (void *) dev);
  143. if (err) {
  144. pr_debug("%s: %s(): can't get irq %d\n",
  145. dev->name, __FUNCTION__, dev->irq);
  146. release_region(dev->base_addr, MIPSNET_IO_EXTENT);
  147. return err;
  148. }
  149. pr_debug("%s: %s(): got IO region at 0x%04lx and irq %d for dev.\n",
  150. dev->name, __FUNCTION__, dev->base_addr, dev->irq);
  151. netif_start_queue(dev);
  152. // test interrupt handler
  153. outl(MIPSNET_INTCTL_TESTBIT,
  154. mipsnet_reg_address(dev, interruptControl));
  155. return 0;
  156. }
  157. static int mipsnet_close(struct net_device *dev)
  158. {
  159. pr_debug("%s: %s()\n", dev->name, __FUNCTION__);
  160. netif_stop_queue(dev);
  161. return 0;
  162. }
  163. static struct net_device_stats *mipsnet_get_stats(struct net_device *dev)
  164. {
  165. struct mipsnet_priv *mp = netdev_priv(dev);
  166. return &mp->stats;
  167. }
  168. static void mipsnet_set_mclist(struct net_device *dev)
  169. {
  170. // we don't do anything
  171. return;
  172. }
  173. static int __init mipsnet_probe(struct device *dev)
  174. {
  175. struct net_device *netdev;
  176. int err;
  177. netdev = alloc_etherdev(sizeof(struct mipsnet_priv));
  178. if (!netdev) {
  179. err = -ENOMEM;
  180. goto out;
  181. }
  182. dev_set_drvdata(dev, netdev);
  183. netdev->open = mipsnet_open;
  184. netdev->stop = mipsnet_close;
  185. netdev->hard_start_xmit = mipsnet_xmit;
  186. netdev->get_stats = mipsnet_get_stats;
  187. netdev->set_multicast_list = mipsnet_set_mclist;
  188. /*
  189. * TODO: probe for these or load them from PARAM
  190. */
  191. netdev->base_addr = 0x4200;
  192. netdev->irq = MIPSCPU_INT_BASE + MIPSCPU_INT_MB0 +
  193. inl(mipsnet_reg_address(netdev, interruptInfo));
  194. // Get the io region now, get irq on open()
  195. if (!request_region(netdev->base_addr, MIPSNET_IO_EXTENT, "mipsnet")) {
  196. pr_debug("%s: %s(): IO region {start: 0x%04lux, len: %d} "
  197. "for dev is not availble.\n", netdev->name,
  198. __FUNCTION__, netdev->base_addr, MIPSNET_IO_EXTENT);
  199. err = -EBUSY;
  200. goto out_free_netdev;
  201. }
  202. /*
  203. * Lacking any better mechanism to allocate a MAC address we use a
  204. * random one ...
  205. */
  206. random_ether_addr(netdev->dev_addr);
  207. err = register_netdev(netdev);
  208. if (err) {
  209. printk(KERN_ERR "MIPSNet: failed to register netdev.\n");
  210. goto out_free_region;
  211. }
  212. return 0;
  213. out_free_region:
  214. release_region(netdev->base_addr, MIPSNET_IO_EXTENT);
  215. out_free_netdev:
  216. free_netdev(netdev);
  217. out:
  218. return err;
  219. }
  220. static int __devexit mipsnet_device_remove(struct device *device)
  221. {
  222. struct net_device *dev = dev_get_drvdata(device);
  223. unregister_netdev(dev);
  224. release_region(dev->base_addr, MIPSNET_IO_EXTENT);
  225. free_netdev(dev);
  226. dev_set_drvdata(device, NULL);
  227. return 0;
  228. }
  229. static struct device_driver mipsnet_driver = {
  230. .name = mipsnet_string,
  231. .bus = &platform_bus_type,
  232. .probe = mipsnet_probe,
  233. .remove = __devexit_p(mipsnet_device_remove),
  234. };
  235. static void mipsnet_platform_release(struct device *device)
  236. {
  237. struct platform_device *pldev;
  238. /* free device */
  239. pldev = to_platform_device(device);
  240. kfree(pldev);
  241. }
  242. static int __init mipsnet_init_module(void)
  243. {
  244. struct platform_device *pldev;
  245. int err;
  246. printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "
  247. "(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION);
  248. if (driver_register(&mipsnet_driver)) {
  249. printk(KERN_ERR "Driver registration failed\n");
  250. err = -ENODEV;
  251. goto out;
  252. }
  253. if (!(pldev = kmalloc (sizeof (*pldev), GFP_KERNEL))) {
  254. err = -ENOMEM;
  255. goto out_unregister_driver;
  256. }
  257. memset (pldev, 0, sizeof (*pldev));
  258. pldev->name = mipsnet_string;
  259. pldev->id = 0;
  260. pldev->dev.release = mipsnet_platform_release;
  261. if (platform_device_register(pldev)) {
  262. err = -ENODEV;
  263. goto out_free_pldev;
  264. }
  265. if (!pldev->dev.driver) {
  266. /*
  267. * The driver was not bound to this device, there was
  268. * no hardware at this address. Unregister it, as the
  269. * release fuction will take care of freeing the
  270. * allocated structure
  271. */
  272. platform_device_unregister (pldev);
  273. }
  274. mips_plat_dev = pldev;
  275. return 0;
  276. out_free_pldev:
  277. kfree(pldev);
  278. out_unregister_driver:
  279. driver_unregister(&mipsnet_driver);
  280. out:
  281. return err;
  282. }
  283. static void __exit mipsnet_exit_module(void)
  284. {
  285. pr_debug("MIPSNet Ethernet driver exiting\n");
  286. driver_unregister(&mipsnet_driver);
  287. }
  288. module_init(mipsnet_init_module);
  289. module_exit(mipsnet_exit_module);