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 494
This page was automatically generated by LXR 0.3.1. • Linux is a registered trademark of Linus Torvalds