1/* $Id: hysdn_net.c,v 1.8.6.4 2001/09/23 22:24:54 Exp $ 2 * 3 * Linux driver for HYSDN cards, net (ethernet type) handling routines. 4 * 5 * Author Werner Cornelius (werner@titro.de) for Hypercope GmbH 6 * Copyright 1999 by Werner Cornelius (werner@titro.de) 7 * 8 * This software may be used and distributed according to the terms 9 * of the GNU General Public License, incorporated herein by reference. 10 * 11 * This net module has been inspired by the skeleton driver from 12 * Donald Becker (becker@CESDIS.gsfc.nasa.gov) 13 * 14 */ 15 16#include <linux/module.h> 17#include <linux/signal.h> 18#include <linux/kernel.h> 19#include <linux/netdevice.h> 20#include <linux/etherdevice.h> 21#include <linux/skbuff.h> 22#include <linux/inetdevice.h> 23 24#include "hysdn_defs.h" 25 26unsigned int hynet_enable = 0xffffffff; 27module_param(hynet_enable, uint, 0); 28 29/* store the actual version for log reporting */ 30char *hysdn_net_revision = "$Revision: 1.8.6.4 $"; 31 32#define MAX_SKB_BUFFERS 20 /* number of buffers for keeping TX-data */ 33 34/****************************************************************************/ 35/* structure containing the complete network data. The structure is aligned */ 36/* in a way that both, the device and statistics are kept inside it. */ 37/* for proper access, the device structure MUST be the first var/struct */ 38/* inside the definition. */ 39/****************************************************************************/ 40struct net_local { 41 /* Tx control lock. This protects the transmit buffer ring 42 * state along with the "tx full" state of the driver. This 43 * means all netif_queue flow control actions are protected 44 * by this lock as well. 45 */ 46 struct net_device *dev; 47 spinlock_t lock; 48 struct sk_buff *skbs[MAX_SKB_BUFFERS]; /* pointers to tx-skbs */ 49 int in_idx, out_idx; /* indexes to buffer ring */ 50 int sk_count; /* number of buffers currently in ring */ 51}; /* net_local */ 52 53 54 55/*********************************************************************/ 56/* Open/initialize the board. This is called (in the current kernel) */ 57/* sometime after booting when the 'ifconfig' program is run. */ 58/* This routine should set everything up anew at each open, even */ 59/* registers that "should" only need to be set once at boot, so that */ 60/* there is non-reboot way to recover if something goes wrong. */ 61/*********************************************************************/ 62static int 63net_open(struct net_device *dev) 64{ 65 struct in_device *in_dev; 66 hysdn_card *card = dev->ml_priv; 67 int i; 68 69 netif_start_queue(dev); /* start tx-queueing */ 70 71 /* Fill in the MAC-level header (if not already set) */ 72 if (!card->mac_addr[0]) { 73 for (i = 0; i < ETH_ALEN; i++) 74 dev->dev_addr[i] = 0xfc; 75 if ((in_dev = dev->ip_ptr) != NULL) { 76 struct in_ifaddr *ifa = in_dev->ifa_list; 77 if (ifa != NULL) 78 memcpy(dev->dev_addr + (ETH_ALEN - sizeof(ifa->ifa_local)), &ifa->ifa_local, sizeof(ifa->ifa_local)); 79 } 80 } else 81 memcpy(dev->dev_addr, card->mac_addr, ETH_ALEN); 82 83 return (0); 84} /* net_open */ 85 86/*******************************************/ 87/* flush the currently occupied tx-buffers */ 88/* must only be called when device closed */ 89/*******************************************/ 90static void 91flush_tx_buffers(struct net_local *nl) 92{ 93 94 while (nl->sk_count) { 95 dev_kfree_skb(nl->skbs[nl->out_idx++]); /* free skb */ 96 if (nl->out_idx >= MAX_SKB_BUFFERS) 97 nl->out_idx = 0; /* wrap around */ 98 nl->sk_count--; 99 } 100} /* flush_tx_buffers */ 101 102 103/*********************************************************************/ 104/* close/decativate the device. The device is not removed, but only */ 105/* deactivated. */ 106/*********************************************************************/ 107static int 108net_close(struct net_device *dev) 109{ 110 111 netif_stop_queue(dev); /* disable queueing */ 112 113 flush_tx_buffers((struct net_local *) dev); 114 115 return (0); /* success */ 116} /* net_close */ 117 118/************************************/ 119/* send a packet on this interface. */ 120/* new style for kernel >= 2.3.33 */ 121/************************************/ 122static netdev_tx_t 123net_send_packet(struct sk_buff *skb, struct net_device *dev) 124{ 125 struct net_local *lp = (struct net_local *) dev; 126 127 spin_lock_irq(&lp->lock); 128 129 lp->skbs[lp->in_idx++] = skb; /* add to buffer list */ 130 if (lp->in_idx >= MAX_SKB_BUFFERS) 131 lp->in_idx = 0; /* wrap around */ 132 lp->sk_count++; /* adjust counter */ 133 dev->trans_start = jiffies; 134 135 /* If we just used up the very last entry in the 136 * TX ring on this device, tell the queueing 137 * layer to send no more. 138 */ 139 if (lp->sk_count >= MAX_SKB_BUFFERS) 140 netif_stop_queue(dev); 141 142 /* When the TX completion hw interrupt arrives, this 143 * is when the transmit statistics are updated. 144 */ 145 146 spin_unlock_irq(&lp->lock); 147 148 if (lp->sk_count <= 3) { 149 schedule_work(&((hysdn_card *) dev->ml_priv)->irq_queue); 150 } 151 return NETDEV_TX_OK; /* success */ 152} /* net_send_packet */ 153 154 155 156/***********************************************************************/ 157/* acknowlegde a packet send. The network layer will be informed about */ 158/* completion */ 159/***********************************************************************/ 160void 161hysdn_tx_netack(hysdn_card * card) 162{ 163 struct net_local *lp = card->netif; 164 165 if (!lp) 166 return; /* non existing device */ 167 168 169 if (!lp->sk_count) 170 return; /* error condition */ 171 172 lp->dev->stats.tx_packets++; 173 lp->dev->stats.tx_bytes += lp->skbs[lp->out_idx]->len; 174 175 dev_kfree_skb(lp->skbs[lp->out_idx++]); /* free skb */ 176 if (lp->out_idx >= MAX_SKB_BUFFERS) 177 lp->out_idx = 0; /* wrap around */ 178 179 if (lp->sk_count-- == MAX_SKB_BUFFERS) /* dec usage count */ 180 netif_start_queue((struct net_device *) lp); 181} /* hysdn_tx_netack */ 182 183/*****************************************************/ 184/* we got a packet from the network, go and queue it */ 185/*****************************************************/ 186void 187hysdn_rx_netpkt(hysdn_card * card, unsigned char *buf, unsigned short len) 188{ 189 struct net_local *lp = card->netif; 190 struct net_device *dev; 191 struct sk_buff *skb; 192 193 if (!lp) 194 return; /* non existing device */ 195 196 dev = lp->dev; 197 dev->stats.rx_bytes += len; 198 199 skb = dev_alloc_skb(len); 200 if (skb == NULL) { 201 printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", 202 dev->name); 203 dev->stats.rx_dropped++; 204 return; 205 } 206 /* copy the data */ 207 memcpy(skb_put(skb, len), buf, len); 208 209 /* determine the used protocol */ 210 skb->protocol = eth_type_trans(skb, dev); 211 212 dev->stats.rx_packets++; /* adjust packet count */ 213 214 netif_rx(skb); 215} /* hysdn_rx_netpkt */ 216 217/*****************************************************/ 218/* return the pointer to a network packet to be send */ 219/*****************************************************/ 220struct sk_buff * 221hysdn_tx_netget(hysdn_card * card) 222{ 223 struct net_local *lp = card->netif; 224 225 if (!lp) 226 return (NULL); /* non existing device */ 227 228 if (!lp->sk_count) 229 return (NULL); /* nothing available */ 230 231 return (lp->skbs[lp->out_idx]); /* next packet to send */ 232} /* hysdn_tx_netget */ 233 234static const struct net_device_ops hysdn_netdev_ops = { 235 .ndo_open = net_open, 236 .ndo_stop = net_close, 237 .ndo_start_xmit = net_send_packet, 238 .ndo_change_mtu = eth_change_mtu, 239 .ndo_set_mac_address = eth_mac_addr, 240 .ndo_validate_addr = eth_validate_addr, 241}; 242 243 244/*****************************************************************************/ 245/* hysdn_net_create creates a new net device for the given card. If a device */ 246/* already exists, it will be deleted and created a new one. The return value */ 247/* 0 announces success, else a negative error code will be returned. */ 248/*****************************************************************************/ 249int 250hysdn_net_create(hysdn_card * card) 251{ 252 struct net_device *dev; 253 int i; 254 struct net_local *lp; 255 256 if(!card) { 257 printk(KERN_WARNING "No card-pt in hysdn_net_create!\n"); 258 return (-ENOMEM); 259 } 260 hysdn_net_release(card); /* release an existing net device */ 261 262 dev = alloc_etherdev(sizeof(struct net_local)); 263 if (!dev) { 264 printk(KERN_WARNING "HYSDN: unable to allocate mem\n"); 265 return (-ENOMEM); 266 } 267 268 lp = netdev_priv(dev); 269 lp->dev = dev; 270 271 dev->netdev_ops = &hysdn_netdev_ops; 272 spin_lock_init(&((struct net_local *) dev)->lock); 273 274 /* initialise necessary or informing fields */ 275 dev->base_addr = card->iobase; /* IO address */ 276 dev->irq = card->irq; /* irq */ 277 278 dev->netdev_ops = &hysdn_netdev_ops; 279 if ((i = register_netdev(dev))) { 280 printk(KERN_WARNING "HYSDN: unable to create network device\n"); 281 free_netdev(dev); 282 return (i); 283 } 284 dev->ml_priv = card; /* remember pointer to own data structure */ 285 card->netif = dev; /* setup the local pointer */ 286 287 if (card->debug_flags & LOG_NET_INIT) 288 hysdn_addlog(card, "network device created"); 289 return (0); /* and return success */ 290} /* hysdn_net_create */ 291 292/***************************************************************************/ 293/* hysdn_net_release deletes the net device for the given card. The return */ 294/* value 0 announces success, else a negative error code will be returned. */ 295/***************************************************************************/ 296int 297hysdn_net_release(hysdn_card * card) 298{ 299 struct net_device *dev = card->netif; 300 301 if (!dev) 302 return (0); /* non existing */ 303 304 card->netif = NULL; /* clear out pointer */ 305 net_close(dev); 306 307 flush_tx_buffers((struct net_local *) dev); /* empty buffers */ 308 309 unregister_netdev(dev); /* release the device */ 310 free_netdev(dev); /* release the memory allocated */ 311 if (card->debug_flags & LOG_NET_INIT) 312 hysdn_addlog(card, "network device deleted"); 313 314 return (0); /* always successful */ 315} /* hysdn_net_release */ 316 317/*****************************************************************************/ 318/* hysdn_net_getname returns a pointer to the name of the network interface. */ 319/* if the interface is not existing, a "-" is returned. */ 320/*****************************************************************************/ 321char * 322hysdn_net_getname(hysdn_card * card) 323{ 324 struct net_device *dev = card->netif; 325 326 if (!dev) 327 return ("-"); /* non existing */ 328 329 return (dev->name); 330} /* hysdn_net_getname */ 331