irlan_eth.c 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359
  1. /*********************************************************************
  2. *
  3. * Filename: irlan_eth.c
  4. * Version:
  5. * Description:
  6. * Status: Experimental.
  7. * Author: Dag Brattli <dagb@cs.uit.no>
  8. * Created at: Thu Oct 15 08:37:58 1998
  9. * Modified at: Tue Mar 21 09:06:41 2000
  10. * Modified by: Dag Brattli <dagb@cs.uit.no>
  11. * Sources: skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
  12. * slip.c by Laurence Culhane, <loz@holmes.demon.co.uk>
  13. * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
  14. *
  15. * Copyright (c) 1998-2000 Dag Brattli, All Rights Reserved.
  16. *
  17. * This program is free software; you can redistribute it and/or
  18. * modify it under the terms of the GNU General Public License as
  19. * published by the Free Software Foundation; either version 2 of
  20. * the License, or (at your option) any later version.
  21. *
  22. * Neither Dag Brattli nor University of Tromsø admit liability nor
  23. * provide warranty for any of this software. This material is
  24. * provided "AS-IS" and at no charge.
  25. *
  26. ********************************************************************/
  27. #include <linux/netdevice.h>
  28. #include <linux/etherdevice.h>
  29. #include <linux/inetdevice.h>
  30. #include <linux/if_arp.h>
  31. #include <linux/module.h>
  32. #include <net/arp.h>
  33. #include <net/irda/irda.h>
  34. #include <net/irda/irmod.h>
  35. #include <net/irda/irlan_common.h>
  36. #include <net/irda/irlan_client.h>
  37. #include <net/irda/irlan_event.h>
  38. #include <net/irda/irlan_eth.h>
  39. static int irlan_eth_open(struct net_device *dev);
  40. static int irlan_eth_close(struct net_device *dev);
  41. static netdev_tx_t irlan_eth_xmit(struct sk_buff *skb,
  42. struct net_device *dev);
  43. static void irlan_eth_set_multicast_list( struct net_device *dev);
  44. static struct net_device_stats *irlan_eth_get_stats(struct net_device *dev);
  45. static const struct net_device_ops irlan_eth_netdev_ops = {
  46. .ndo_open = irlan_eth_open,
  47. .ndo_stop = irlan_eth_close,
  48. .ndo_start_xmit = irlan_eth_xmit,
  49. .ndo_get_stats = irlan_eth_get_stats,
  50. .ndo_set_multicast_list = irlan_eth_set_multicast_list,
  51. .ndo_change_mtu = eth_change_mtu,
  52. .ndo_validate_addr = eth_validate_addr,
  53. };
  54. /*
  55. * Function irlan_eth_setup (dev)
  56. *
  57. * The network device initialization function.
  58. *
  59. */
  60. static void irlan_eth_setup(struct net_device *dev)
  61. {
  62. ether_setup(dev);
  63. dev->netdev_ops = &irlan_eth_netdev_ops;
  64. dev->destructor = free_netdev;
  65. /*
  66. * Lets do all queueing in IrTTP instead of this device driver.
  67. * Queueing here as well can introduce some strange latency
  68. * problems, which we will avoid by setting the queue size to 0.
  69. */
  70. /*
  71. * The bugs in IrTTP and IrLAN that created this latency issue
  72. * have now been fixed, and we can propagate flow control properly
  73. * to the network layer. However, this requires a minimal queue of
  74. * packets for the device.
  75. * Without flow control, the Tx Queue is 14 (ttp) + 0 (dev) = 14
  76. * With flow control, the Tx Queue is 7 (ttp) + 4 (dev) = 11
  77. * See irlan_eth_flow_indication()...
  78. * Note : this number was randomly selected and would need to
  79. * be adjusted.
  80. * Jean II */
  81. dev->tx_queue_len = 4;
  82. }
  83. /*
  84. * Function alloc_irlandev
  85. *
  86. * Allocate network device and control block
  87. *
  88. */
  89. struct net_device *alloc_irlandev(const char *name)
  90. {
  91. return alloc_netdev(sizeof(struct irlan_cb), name,
  92. irlan_eth_setup);
  93. }
  94. /*
  95. * Function irlan_eth_open (dev)
  96. *
  97. * Network device has been opened by user
  98. *
  99. */
  100. static int irlan_eth_open(struct net_device *dev)
  101. {
  102. struct irlan_cb *self = netdev_priv(dev);
  103. IRDA_DEBUG(2, "%s()\n", __func__ );
  104. /* Ready to play! */
  105. netif_stop_queue(dev); /* Wait until data link is ready */
  106. /* We are now open, so time to do some work */
  107. self->disconnect_reason = 0;
  108. irlan_client_wakeup(self, self->saddr, self->daddr);
  109. /* Make sure we have a hardware address before we return,
  110. so DHCP clients gets happy */
  111. return wait_event_interruptible(self->open_wait,
  112. !self->tsap_data->connected);
  113. }
  114. /*
  115. * Function irlan_eth_close (dev)
  116. *
  117. * Stop the ether network device, his function will usually be called by
  118. * ifconfig down. We should now disconnect the link, We start the
  119. * close timer, so that the instance will be removed if we are unable
  120. * to discover the remote device after the disconnect.
  121. */
  122. static int irlan_eth_close(struct net_device *dev)
  123. {
  124. struct irlan_cb *self = netdev_priv(dev);
  125. IRDA_DEBUG(2, "%s()\n", __func__ );
  126. /* Stop device */
  127. netif_stop_queue(dev);
  128. irlan_close_data_channel(self);
  129. irlan_close_tsaps(self);
  130. irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
  131. irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
  132. /* Remove frames queued on the control channel */
  133. skb_queue_purge(&self->client.txq);
  134. self->client.tx_busy = 0;
  135. return 0;
  136. }
  137. /*
  138. * Function irlan_eth_tx (skb)
  139. *
  140. * Transmits ethernet frames over IrDA link.
  141. *
  142. */
  143. static netdev_tx_t irlan_eth_xmit(struct sk_buff *skb,
  144. struct net_device *dev)
  145. {
  146. struct irlan_cb *self = netdev_priv(dev);
  147. int ret;
  148. /* skb headroom large enough to contain all IrDA-headers? */
  149. if ((skb_headroom(skb) < self->max_header_size) || (skb_shared(skb))) {
  150. struct sk_buff *new_skb =
  151. skb_realloc_headroom(skb, self->max_header_size);
  152. /* We have to free the original skb anyway */
  153. dev_kfree_skb(skb);
  154. /* Did the realloc succeed? */
  155. if (new_skb == NULL)
  156. return NETDEV_TX_OK;
  157. /* Use the new skb instead */
  158. skb = new_skb;
  159. }
  160. dev->trans_start = jiffies;
  161. /* Now queue the packet in the transport layer */
  162. if (self->use_udata)
  163. ret = irttp_udata_request(self->tsap_data, skb);
  164. else
  165. ret = irttp_data_request(self->tsap_data, skb);
  166. if (ret < 0) {
  167. /*
  168. * IrTTPs tx queue is full, so we just have to
  169. * drop the frame! You might think that we should
  170. * just return -1 and don't deallocate the frame,
  171. * but that is dangerous since it's possible that
  172. * we have replaced the original skb with a new
  173. * one with larger headroom, and that would really
  174. * confuse do_dev_queue_xmit() in dev.c! I have
  175. * tried :-) DB
  176. */
  177. /* irttp_data_request already free the packet */
  178. self->stats.tx_dropped++;
  179. } else {
  180. self->stats.tx_packets++;
  181. self->stats.tx_bytes += skb->len;
  182. }
  183. return NETDEV_TX_OK;
  184. }
  185. /*
  186. * Function irlan_eth_receive (handle, skb)
  187. *
  188. * This function gets the data that is received on the data channel
  189. *
  190. */
  191. int irlan_eth_receive(void *instance, void *sap, struct sk_buff *skb)
  192. {
  193. struct irlan_cb *self = instance;
  194. if (skb == NULL) {
  195. ++self->stats.rx_dropped;
  196. return 0;
  197. }
  198. if (skb->len < ETH_HLEN) {
  199. IRDA_DEBUG(0, "%s() : IrLAN frame too short (%d)\n",
  200. __func__, skb->len);
  201. ++self->stats.rx_dropped;
  202. dev_kfree_skb(skb);
  203. return 0;
  204. }
  205. /*
  206. * Adopt this frame! Important to set all these fields since they
  207. * might have been previously set by the low level IrDA network
  208. * device driver
  209. */
  210. skb->protocol = eth_type_trans(skb, self->dev); /* Remove eth header */
  211. self->stats.rx_packets++;
  212. self->stats.rx_bytes += skb->len;
  213. netif_rx(skb); /* Eat it! */
  214. return 0;
  215. }
  216. /*
  217. * Function irlan_eth_flow (status)
  218. *
  219. * Do flow control between IP/Ethernet and IrLAN/IrTTP. This is done by
  220. * controlling the queue stop/start.
  221. *
  222. * The IrDA link layer has the advantage to have flow control, and
  223. * IrTTP now properly handles that. Flow controlling the higher layers
  224. * prevent us to drop Tx packets in here (up to 15% for a TCP socket,
  225. * more for UDP socket).
  226. * Also, this allow us to reduce the overall transmit queue, which means
  227. * less latency in case of mixed traffic.
  228. * Jean II
  229. */
  230. void irlan_eth_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
  231. {
  232. struct irlan_cb *self;
  233. struct net_device *dev;
  234. self = (struct irlan_cb *) instance;
  235. IRDA_ASSERT(self != NULL, return;);
  236. IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
  237. dev = self->dev;
  238. IRDA_ASSERT(dev != NULL, return;);
  239. IRDA_DEBUG(0, "%s() : flow %s ; running %d\n", __func__,
  240. flow == FLOW_STOP ? "FLOW_STOP" : "FLOW_START",
  241. netif_running(dev));
  242. switch (flow) {
  243. case FLOW_STOP:
  244. /* IrTTP is full, stop higher layers */
  245. netif_stop_queue(dev);
  246. break;
  247. case FLOW_START:
  248. default:
  249. /* Tell upper layers that its time to transmit frames again */
  250. /* Schedule network layer */
  251. netif_wake_queue(dev);
  252. break;
  253. }
  254. }
  255. /*
  256. * Function set_multicast_list (dev)
  257. *
  258. * Configure the filtering of the device
  259. *
  260. */
  261. #define HW_MAX_ADDRS 4 /* Must query to get it! */
  262. static void irlan_eth_set_multicast_list(struct net_device *dev)
  263. {
  264. struct irlan_cb *self = netdev_priv(dev);
  265. IRDA_DEBUG(2, "%s()\n", __func__ );
  266. /* Check if data channel has been connected yet */
  267. if (self->client.state != IRLAN_DATA) {
  268. IRDA_DEBUG(1, "%s(), delaying!\n", __func__ );
  269. return;
  270. }
  271. if (dev->flags & IFF_PROMISC) {
  272. /* Enable promiscuous mode */
  273. IRDA_WARNING("Promiscuous mode not implemented by IrLAN!\n");
  274. }
  275. else if ((dev->flags & IFF_ALLMULTI) || dev->mc_count > HW_MAX_ADDRS) {
  276. /* Disable promiscuous mode, use normal mode. */
  277. IRDA_DEBUG(4, "%s(), Setting multicast filter\n", __func__ );
  278. /* hardware_set_filter(NULL); */
  279. irlan_set_multicast_filter(self, TRUE);
  280. }
  281. else if (dev->mc_count) {
  282. IRDA_DEBUG(4, "%s(), Setting multicast filter\n", __func__ );
  283. /* Walk the address list, and load the filter */
  284. /* hardware_set_filter(dev->mc_list); */
  285. irlan_set_multicast_filter(self, TRUE);
  286. }
  287. else {
  288. IRDA_DEBUG(4, "%s(), Clearing multicast filter\n", __func__ );
  289. irlan_set_multicast_filter(self, FALSE);
  290. }
  291. if (dev->flags & IFF_BROADCAST)
  292. irlan_set_broadcast_filter(self, TRUE);
  293. else
  294. irlan_set_broadcast_filter(self, FALSE);
  295. }
  296. /*
  297. * Function irlan_get_stats (dev)
  298. *
  299. * Get the current statistics for this device
  300. *
  301. */
  302. static struct net_device_stats *irlan_eth_get_stats(struct net_device *dev)
  303. {
  304. struct irlan_cb *self = netdev_priv(dev);
  305. return &self->stats;
  306. }