drivers/net/net_init.c

   1 /* net_init.c: Initialization for network devices. */
   2 /*
   3         Written 1993,1994,1995 by Donald Becker.
   4
   5         The author may be reached as becker@scyld.com, or C/O
   6         Scyld Computing Corporation
   7         410 Severn Ave., Suite 210
   8         Annapolis MD 21403
   9
  10         This file contains the initialization for the "pl14+" style ethernet
  11         drivers.  It should eventually replace most of drivers/net/Space.c.
  12         It's primary advantage is that it's able to allocate low-memory buffers.
  13         A secondary advantage is that the dangerous NE*000 netcards can reserve
  14         their I/O port region before the SCSI probes start.
  15
  16         Modifications/additions by Bjorn Ekwall <bj0rn@blox.se>:
  17                 ethdev_index[MAX_ETH_CARDS]
  18                 register_netdev() / unregister_netdev()
  19
  20         Modifications by Wolfgang Walter
  21                 Use dev_close cleanly so we always shut things down tidily.
  22
  23         Changed 29/10/95, Alan Cox to pass sockaddr's around for mac addresses.
  24
  25         14/06/96 - Paul Gortmaker:      Add generic eth_change_mtu() function.
  26         24/09/96 - Paul Norton: Add token-ring variants of the netdev functions.
  27
  28         08/11/99 - Alan Cox: Got fed up of the mess in this file and cleaned it
  29                         up. We now share common code and have regularised name
  30                         allocation setups. Abolished the 16 card limits.
  31         03/19/2000 - jgarzik and Urban Widmark: init_etherdev 32-byte align
  32         03/21/2001 - jgarzik: alloc_etherdev and friends
  33
  34 */
  35
  36 #include <linux/config.h>
  37 #include <linux/module.h>
  38 #include <linux/kernel.h>
  39 #include <linux/types.h>
  40 #include <linux/fs.h>
  41 #include <linux/slab.h>
  42 #include <linux/if_ether.h>
  43 #include <linux/string.h>
  44 #include <linux/netdevice.h>
  45 #include <linux/etherdevice.h>
  46 #include <linux/fddidevice.h>
  47 #include <linux/hippidevice.h>
  48 #include <linux/trdevice.h>
  49 #include <linux/fcdevice.h>
  50 #include <linux/if_arp.h>
  51 #include <linux/if_ltalk.h>
  52 #include <linux/rtnetlink.h>
  53 #include <net/neighbour.h>
  54
  55 /* The network devices currently exist only in the socket namespace, so these
  56    entries are unused.  The only ones that make sense are
  57     open        start the ethercard
  58     close       stop  the ethercard
  59     ioctl       To get statistics, perhaps set the interface port (AUI, BNC, etc.)
  60    One can also imagine getting raw packets using
  61     read & write
  62    but this is probably better handled by a raw packet socket.
  63
  64    Given that almost all of these functions are handled in the current
  65    socket-based scheme, putting ethercard devices in /dev/ seems pointless.
  66
  67    [Removed all support for /dev network devices. When someone adds
  68     streams then by magic we get them, but otherwise they are un-needed
  69         and a space waste]
  70 */
  71
  72
  73 struct net_device *alloc_netdev(int sizeof_priv, const char *mask,
  74                                        void (*setup)(struct net_device *))
  75 {
  76         void *p;
  77         struct net_device *dev;
  78         int alloc_size;
  79
  80         /* ensure 32-byte alignment of both the device and private area */
  81
  82         alloc_size = (sizeof(struct net_device) + NETDEV_ALIGN_CONST)
  83                         & ~NETDEV_ALIGN_CONST;
  84         alloc_size += sizeof_priv + NETDEV_ALIGN_CONST;
  85
  86         p = kmalloc (alloc_size, GFP_KERNEL);
  87         if (!p) {
  88                 printk(KERN_ERR "alloc_dev: Unable to allocate device.\n");
  89                 return NULL;
  90         }
  91
  92         memset(p, 0, alloc_size);
  93
  94         dev = (struct net_device *)(((long)p + NETDEV_ALIGN_CONST)
  95                                 & ~NETDEV_ALIGN_CONST);
  96         dev->padded = (char *)dev - (char *)p;
  97
  98         if (sizeof_priv)
  99                 dev->priv = netdev_priv(dev);
 100
 101         setup(dev);
 102         strcpy(dev->name, mask);
 103
 104         return dev;
 105 }
 106 EXPORT_SYMBOL(alloc_netdev);
 107
 108 /**
 109  * alloc_etherdev - Allocates and sets up an ethernet device
 110  * @sizeof_priv: Size of additional driver-private structure to be allocated
 111  *      for this ethernet device
 112  *
 113  * Fill in the fields of the device structure with ethernet-generic
 114  * values. Basically does everything except registering the device.
 115  *
 116  * Constructs a new net device, complete with a private data area of
 117  * size @sizeof_priv.  A 32-byte (not bit) alignment is enforced for
 118  * this private data area.
 119  */
 120
 121 struct net_device *alloc_etherdev(int sizeof_priv)
 122 {
 123         return alloc_netdev(sizeof_priv, "eth%d", ether_setup);
 124 }
 125
 126 EXPORT_SYMBOL(alloc_etherdev);
 127
 128 static int eth_mac_addr(struct net_device *dev, void *p)
 129 {
 130         struct sockaddr *addr=p;
 131         if (netif_running(dev))
 132                 return -EBUSY;
 133         memcpy(dev->dev_addr, addr->sa_data,dev->addr_len);
 134         return 0;
 135 }
 136
 137 static int eth_change_mtu(struct net_device *dev, int new_mtu)
 138 {
 139         if ((new_mtu < 68) || (new_mtu > 1500))
 140                 return -EINVAL;
 141         dev->mtu = new_mtu;
 142         return 0;
 143 }
 144
 145 #ifdef CONFIG_FDDI
 146
 147 /**
 148  * alloc_fddidev - Register FDDI device
 149  * @sizeof_priv: Size of additional driver-private structure to be allocated
 150  *      for this FDDI device
 151  *
 152  * Fill in the fields of the device structure with FDDI-generic values.
 153  *
 154  * Constructs a new net device, complete with a private data area of
 155  * size @sizeof_priv.  A 32-byte (not bit) alignment is enforced for
 156  * this private data area.
 157  */
 158
 159 struct net_device *alloc_fddidev(int sizeof_priv)
 160 {
 161         return alloc_netdev(sizeof_priv, "fddi%d", fddi_setup);
 162 }
 163
 164 EXPORT_SYMBOL(alloc_fddidev);
 165
 166 static int fddi_change_mtu(struct net_device *dev, int new_mtu)
 167 {
 168         if ((new_mtu < FDDI_K_SNAP_HLEN) || (new_mtu > FDDI_K_SNAP_DLEN))
 169                 return(-EINVAL);
 170         dev->mtu = new_mtu;
 171         return(0);
 172 }
 173
 174 #endif /* CONFIG_FDDI */
 175
 176 #ifdef CONFIG_HIPPI
 177
 178 static int hippi_change_mtu(struct net_device *dev, int new_mtu)
 179 {
 180         /*
 181          * HIPPI's got these nice large MTUs.
 182          */
 183         if ((new_mtu < 68) || (new_mtu > 65280))
 184                 return -EINVAL;
 185         dev->mtu = new_mtu;
 186         return(0);
 187 }
 188
 189
 190 /*
 191  * For HIPPI we will actually use the lower 4 bytes of the hardware
 192  * address as the I-FIELD rather than the actual hardware address.
 193  */
 194 static int hippi_mac_addr(struct net_device *dev, void *p)
 195 {
 196         struct sockaddr *addr = p;
 197         if (netif_running(dev))
 198                 return -EBUSY;
 199         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
 200         return 0;
 201 }
 202
 203 static int hippi_neigh_setup_dev(struct net_device *dev, struct neigh_parms *p)
 204 {
 205         /* Never send broadcast/multicast ARP messages */
 206         p->mcast_probes = 0;
 207
 208         /* In IPv6 unicast probes are valid even on NBMA,
 209         * because they are encapsulated in normal IPv6 protocol.
 210         * Should be a generic flag.
 211         */
 212         if (p->tbl->family != AF_INET6)
 213                 p->ucast_probes = 0;
 214         return 0;
 215 }
 216
 217 static void hippi_setup(struct net_device *dev)
 218 {
 219         dev->set_multicast_list = NULL;
 220         dev->change_mtu                 = hippi_change_mtu;
 221         dev->hard_header                = hippi_header;
 222         dev->rebuild_header             = hippi_rebuild_header;
 223         dev->set_mac_address            = hippi_mac_addr;
 224         dev->hard_header_parse          = NULL;
 225         dev->hard_header_cache          = NULL;
 226         dev->header_cache_update        = NULL;
 227         dev->neigh_setup                = hippi_neigh_setup_dev;
 228
 229         /*
 230          * We don't support HIPPI `ARP' for the time being, and probably
 231          * never will unless someone else implements it. However we
 232          * still need a fake ARPHRD to make ifconfig and friends play ball.
 233          */
 234         dev->type               = ARPHRD_HIPPI;
 235         dev->hard_header_len    = HIPPI_HLEN;
 236         dev->mtu                = 65280;
 237         dev->addr_len           = HIPPI_ALEN;
 238         dev->tx_queue_len       = 25 /* 5 */;
 239         memset(dev->broadcast, 0xFF, HIPPI_ALEN);
 240
 241
 242         /*
 243          * HIPPI doesn't support broadcast+multicast and we only use
 244          * static ARP tables. ARP is disabled by hippi_neigh_setup_dev.
 245          */
 246         dev->flags = 0;
 247 }
 248
 249 /**
 250  * alloc_hippi_dev - Register HIPPI device
 251  * @sizeof_priv: Size of additional driver-private structure to be allocated
 252  *      for this HIPPI device
 253  *
 254  * Fill in the fields of the device structure with HIPPI-generic values.
 255  *
 256  * Constructs a new net device, complete with a private data area of
 257  * size @sizeof_priv.  A 32-byte (not bit) alignment is enforced for
 258  * this private data area.
 259  */
 260
 261 struct net_device *alloc_hippi_dev(int sizeof_priv)
 262 {
 263         return alloc_netdev(sizeof_priv, "hip%d", hippi_setup);
 264 }
 265
 266 EXPORT_SYMBOL(alloc_hippi_dev);
 267
 268 #endif /* CONFIG_HIPPI */
 269
 270 void ether_setup(struct net_device *dev)
 271 {
 272         /* Fill in the fields of the device structure with ethernet-generic values.
 273            This should be in a common file instead of per-driver.  */
 274
 275         dev->change_mtu         = eth_change_mtu;
 276         dev->hard_header        = eth_header;
 277         dev->rebuild_header     = eth_rebuild_header;
 278         dev->set_mac_address    = eth_mac_addr;
 279         dev->hard_header_cache  = eth_header_cache;
 280         dev->header_cache_update= eth_header_cache_update;
 281         dev->hard_header_parse  = eth_header_parse;
 282
 283         dev->type               = ARPHRD_ETHER;
 284         dev->hard_header_len    = ETH_HLEN;
 285         dev->mtu                = 1500; /* eth_mtu */
 286         dev->addr_len           = ETH_ALEN;
 287         dev->tx_queue_len       = 1000; /* Ethernet wants good queues */
 288
 289         memset(dev->broadcast,0xFF, ETH_ALEN);
 290
 291         /* New-style flags. */
 292         dev->flags              = IFF_BROADCAST|IFF_MULTICAST;
 293 }
 294 EXPORT_SYMBOL(ether_setup);
 295
 296 #ifdef CONFIG_FDDI
 297
 298 void fddi_setup(struct net_device *dev)
 299 {
 300         /*
 301          * Fill in the fields of the device structure with FDDI-generic values.
 302          * This should be in a common file instead of per-driver.
 303          */
 304
 305         dev->change_mtu                 = fddi_change_mtu;
 306         dev->hard_header                = fddi_header;
 307         dev->rebuild_header             = fddi_rebuild_header;
 308
 309         dev->type                               = ARPHRD_FDDI;
 310         dev->hard_header_len    = FDDI_K_SNAP_HLEN+3;   /* Assume 802.2 SNAP hdr len + 3 pad bytes */
 311         dev->mtu                                = FDDI_K_SNAP_DLEN;             /* Assume max payload of 802.2 SNAP frame */
 312         dev->addr_len                   = FDDI_K_ALEN;
 313         dev->tx_queue_len               = 100;  /* Long queues on FDDI */
 314
 315         memset(dev->broadcast, 0xFF, FDDI_K_ALEN);
 316
 317         /* New-style flags */
 318         dev->flags              = IFF_BROADCAST | IFF_MULTICAST;
 319 }
 320 EXPORT_SYMBOL(fddi_setup);
 321
 322 #endif /* CONFIG_FDDI */
 323
 324 #if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE)
 325
 326 static int ltalk_change_mtu(struct net_device *dev, int mtu)
 327 {
 328         return -EINVAL;
 329 }
 330
 331 static int ltalk_mac_addr(struct net_device *dev, void *addr)
 332 {
 333         return -EINVAL;
 334 }
 335
 336
 337 void ltalk_setup(struct net_device *dev)
 338 {
 339         /* Fill in the fields of the device structure with localtalk-generic values. */
 340
 341         dev->change_mtu         = ltalk_change_mtu;
 342         dev->hard_header        = NULL;
 343         dev->rebuild_header     = NULL;
 344         dev->set_mac_address    = ltalk_mac_addr;
 345         dev->hard_header_cache  = NULL;
 346         dev->header_cache_update= NULL;
 347
 348         dev->type               = ARPHRD_LOCALTLK;
 349         dev->hard_header_len    = LTALK_HLEN;
 350         dev->mtu                = LTALK_MTU;
 351         dev->addr_len           = LTALK_ALEN;
 352         dev->tx_queue_len       = 10;
 353
 354         dev->broadcast[0]       = 0xFF;
 355
 356         dev->flags              = IFF_BROADCAST|IFF_MULTICAST|IFF_NOARP;
 357 }
 358 EXPORT_SYMBOL(ltalk_setup);
 359
 360 #endif /* CONFIG_ATALK || CONFIG_ATALK_MODULE */
 361
 362 int register_netdev(struct net_device *dev)
 363 {
 364         int err;
 365
 366         rtnl_lock();
 367
 368         /*
 369          *      If the name is a format string the caller wants us to
 370          *      do a name allocation
 371          */
 372
 373         if (strchr(dev->name, '%'))
 374         {
 375                 err = dev_alloc_name(dev, dev->name);
 376                 if (err < 0)
 377                         goto out;
 378         }
 379
 380         /*
 381          *      Back compatibility hook. Kill this one in 2.5
 382          */
 383
 384         if (dev->name[0]==0 || dev->name[0]==' ')
 385         {
 386                 err = dev_alloc_name(dev, "eth%d");
 387                 if (err < 0)
 388                         goto out;
 389         }
 390
 391         err = register_netdevice(dev);
 392
 393 out:
 394         rtnl_unlock();
 395         return err;
 396 }
 397
 398 void unregister_netdev(struct net_device *dev)
 399 {
 400         rtnl_lock();
 401         unregister_netdevice(dev);
 402         rtnl_unlock();
 403 }
 404
 405 EXPORT_SYMBOL(register_netdev);
 406 EXPORT_SYMBOL(unregister_netdev);
 407
 408 #ifdef CONFIG_TR
 409
 410 void tr_setup(struct net_device *dev)
 411 {
 412         /*
 413          *      Configure and register
 414          */
 415
 416         dev->hard_header        = tr_header;
 417         dev->rebuild_header     = tr_rebuild_header;
 418
 419         dev->type               = ARPHRD_IEEE802_TR;
 420         dev->hard_header_len    = TR_HLEN;
 421         dev->mtu                = 2000;
 422         dev->addr_len           = TR_ALEN;
 423         dev->tx_queue_len       = 100;  /* Long queues on tr */
 424
 425         memset(dev->broadcast,0xFF, TR_ALEN);
 426
 427         /* New-style flags. */
 428         dev->flags              = IFF_BROADCAST | IFF_MULTICAST ;
 429 }
 430
 431 /**
 432  * alloc_trdev - Register token ring device
 433  * @sizeof_priv: Size of additional driver-private structure to be allocated
 434  *      for this token ring device
 435  *
 436  * Fill in the fields of the device structure with token ring-generic values.
 437  *
 438  * Constructs a new net device, complete with a private data area of
 439  * size @sizeof_priv.  A 32-byte (not bit) alignment is enforced for
 440  * this private data area.
 441  */
 442
 443 struct net_device *alloc_trdev(int sizeof_priv)
 444 {
 445         return alloc_netdev(sizeof_priv, "tr%d", tr_setup);
 446 }
 447
 448 EXPORT_SYMBOL(tr_setup);
 449 EXPORT_SYMBOL(alloc_trdev);
 450
 451 #endif /* CONFIG_TR */
 452
 453 #ifdef CONFIG_NET_FC
 454
 455 void fc_setup(struct net_device *dev)
 456 {
 457         dev->hard_header        =        fc_header;
 458         dev->rebuild_header     =        fc_rebuild_header;
 459
 460         dev->type               =        ARPHRD_IEEE802;
 461         dev->hard_header_len    =        FC_HLEN;
 462         dev->mtu                =        2024;
 463         dev->addr_len           =        FC_ALEN;
 464         dev->tx_queue_len       =        100; /* Long queues on fc */
 465
 466         memset(dev->broadcast,0xFF, FC_ALEN);
 467
 468         /* New-style flags. */
 469         dev->flags              =        IFF_BROADCAST;
 470 }
 471
 472 /**
 473  * alloc_fcdev - Register fibre channel device
 474  * @sizeof_priv: Size of additional driver-private structure to be allocated
 475  *      for this fibre channel device
 476  *
 477  * Fill in the fields of the device structure with fibre channel-generic values.
 478  *
 479  * Constructs a new net device, complete with a private data area of
 480  * size @sizeof_priv.  A 32-byte (not bit) alignment is enforced for
 481  * this private data area.
 482  */
 483
 484 struct net_device *alloc_fcdev(int sizeof_priv)
 485 {
 486         return alloc_netdev(sizeof_priv, "fc%d", fc_setup);
 487 }
 488
 489 EXPORT_SYMBOL(fc_setup);
 490 EXPORT_SYMBOL(alloc_fcdev);
 491
 492 #endif /* CONFIG_NET_FC */
 493