root/net/inet/dev.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. min
  2. dev_add_pack
  3. dev_remove_pack
  4. dev_get
  5. dev_open
  6. dev_close
  7. dev_queue_xmit
  8. netif_rx
  9. dev_rint
  10. dev_transmit
  11. in_net_bh
  12. net_bh
  13. dev_tint
  14. dev_ifconf
  15. sprintf_stats
  16. dev_get_info
  17. bad_mask
  18. dev_ifsioc
  19. dev_ioctl
  20. dev_init

   1 /*
   2  *      NET3    Protocol independant device support routines.
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  *      Derived from the non IP parts of dev.c 1.0.19
  10  *              Authors:        Ross Biro, <bir7@leland.Stanford.Edu>
  11  *                              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12  *                              Mark Evans, <evansmp@uhura.aston.ac.uk>
  13  *
  14  *      Additional Authors:
  15  *              Florian la Roche <rzsfl@rz.uni-sb.de>
  16  *              Alan Cox <gw4pts@gw4pts.ampr.org>
  17  *              David Hinds <dhinds@allegro.stanford.edu>
  18  *
  19  *      Changes:
  20  *              Alan Cox        :       device private ioctl copies fields back.
  21  *              Alan Cox        :       Transmit queue code does relevant stunts to
  22  *                                      keep the queue safe.
  23  *
  24  *      Cleaned up and recommented by Alan Cox 2nd April 1994. I hope to have
  25  *      the rest as well commented in the end.
  26  */
  27 
  28 /*
  29  *      A lot of these includes will be going walkies very soon 
  30  */
  31  
  32 #include <asm/segment.h>
  33 #include <asm/system.h>
  34 #include <asm/bitops.h>
  35 #include <linux/config.h>
  36 #include <linux/types.h>
  37 #include <linux/kernel.h>
  38 #include <linux/sched.h>
  39 #include <linux/string.h>
  40 #include <linux/mm.h>
  41 #include <linux/socket.h>
  42 #include <linux/sockios.h>
  43 #include <linux/in.h>
  44 #include <linux/errno.h>
  45 #include <linux/interrupt.h>
  46 #include <linux/if_ether.h>
  47 #include <linux/inet.h>
  48 #include <linux/netdevice.h>
  49 #include <linux/etherdevice.h>
  50 #include "ip.h"
  51 #include "route.h"
  52 #include <linux/skbuff.h>
  53 #include "sock.h"
  54 #include "arp.h"
  55 
  56 
  57 /*
  58  *      The list of packet types we will receive (as opposed to discard)
  59  *      and the routines to invoke.
  60  */
  61 
  62 struct packet_type *ptype_base = NULL;
  63 
  64 /*
  65  *      Device drivers call our routines to queue packets here. We empty the
  66  *      queue in the bottom half handler.
  67  */
  68 
  69 static struct sk_buff_head backlog = 
  70 {
  71         (struct sk_buff *)&backlog, (struct sk_buff *)&backlog
  72 #ifdef CONFIG_SKB_CHECK
  73         ,SK_HEAD_SKB
  74 #endif
  75 };
  76 
  77 /* 
  78  *      We don't overdo the queue or we will thrash memory badly.
  79  */
  80  
  81 static int backlog_size = 0;
  82 
  83 /*
  84  *      The number of sockets open for 'all' protocol use. We have to
  85  *      know this to copy a buffer the correct number of times.
  86  */
  87  
  88 static int dev_nit=0;
  89 
  90 /*
  91  *      Return the lesser of the two values. 
  92  */
  93  
  94 static __inline__ unsigned long min(unsigned long a, unsigned long b)
     /* [previous][next][first][last][top][bottom][index][help] */
  95 {
  96   return (a < b)? a : b;
  97 }
  98 
  99 
 100 /******************************************************************************************
 101 
 102                 Protocol management and registration routines
 103 
 104 *******************************************************************************************/
 105 
 106 
 107 /*
 108  *      Add a protocol ID to the list.
 109  */
 110  
 111 void dev_add_pack(struct packet_type *pt)
     /* [previous][next][first][last][top][bottom][index][help] */
 112 {
 113         struct packet_type *p1;
 114         pt->next = ptype_base;
 115 
 116         /* 
 117          *      Don't use copy counts on ETH_P_ALL. Instead keep a global
 118          *      count of number of these and use it and pt->copy to decide
 119          *      copies 
 120          */
 121          
 122         pt->copy=0;     /* Assume we will not be copying the buffer before 
 123                          * this routine gets it
 124                          */
 125                          
 126         if(pt->type == htons(ETH_P_ALL))
 127                 dev_nit++;      /* I'd like a /dev/nit too one day 8) */
 128         else
 129         {
 130                 /*
 131                  *      See if we need to copy it - that is another process also
 132                  *      wishes to receive this type of packet.
 133                  */
 134                 for (p1 = ptype_base; p1 != NULL; p1 = p1->next) 
 135                 {
 136                         if (p1->type == pt->type) 
 137                         {
 138                                 pt->copy = 1;   /* We will need to copy */
 139                                 break;
 140                         }
 141                 }
 142         }
 143   
 144   /*
 145    *    NIT taps must go at the end or net_bh will leak!
 146    */
 147    
 148         if (pt->type == htons(ETH_P_ALL))
 149         {
 150                 pt->next=NULL;
 151                 if(ptype_base==NULL)
 152                         ptype_base=pt;
 153                 else
 154                 {
 155                         /* 
 156                          *      Move to the end of the list
 157                          */
 158                         for(p1=ptype_base;p1->next!=NULL;p1=p1->next);
 159                         /*
 160                          *      Hook on the end
 161                          */
 162                         p1->next=pt;
 163                 }
 164          }
 165         else
 166 /*
 167  *      It goes on the start 
 168  */
 169                 ptype_base = pt;
 170 }
 171 
 172 
 173 /*
 174  *      Remove a protocol ID from the list.
 175  */
 176  
 177 void dev_remove_pack(struct packet_type *pt)
     /* [previous][next][first][last][top][bottom][index][help] */
 178 {
 179         struct packet_type *lpt, *pt1;
 180 
 181         /*
 182          *      Keep the count of nit (Network Interface Tap) sockets correct.
 183          */
 184          
 185         if (pt->type == htons(ETH_P_ALL))
 186                 dev_nit--;
 187                 
 188         /*
 189          *      If we are first, just unhook us.
 190          */
 191          
 192         if (pt == ptype_base) 
 193         {
 194                 ptype_base = pt->next;
 195                 return;
 196         }
 197 
 198         lpt = NULL;
 199         
 200         /*
 201          *      This is harder. What we do is to walk the list of sockets 
 202          *      for this type. We unhook the entry, and if there is a previous
 203          *      entry that is copying _and_ we are not copying, (ie we are the
 204          *      last entry for this type) then the previous one is set to
 205          *      non-copying as it is now the last.
 206          */
 207         for (pt1 = ptype_base; pt1->next != NULL; pt1 = pt1->next) 
 208         {
 209                 if (pt1->next == pt ) 
 210                 {
 211                         cli();
 212                         if (!pt->copy && lpt) 
 213                                 lpt->copy = 0;
 214                         pt1->next = pt->next;
 215                         sti();
 216                         return;
 217                 }
 218                 if (pt1->next->type == pt->type && pt->type != htons(ETH_P_ALL))
 219                         lpt = pt1->next;
 220         }
 221 }
 222 
 223 /*****************************************************************************************
 224 
 225                             Device Inteface Subroutines
 226 
 227 ******************************************************************************************/
 228 
 229 /* 
 230  *      Find an interface by name.
 231  */
 232  
 233 struct device *dev_get(char *name)
     /* [previous][next][first][last][top][bottom][index][help] */
 234 {
 235         struct device *dev;
 236 
 237         for (dev = dev_base; dev != NULL; dev = dev->next) 
 238         {
 239                 if (strcmp(dev->name, name) == 0)
 240                         return(dev);
 241         }
 242         return(NULL);
 243 }
 244 
 245 
 246 /*
 247  *      Prepare an interface for use. 
 248  */
 249  
 250 int dev_open(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 251 {
 252         int ret = 0;
 253 
 254         /*
 255          *      Call device private open method
 256          */
 257         if (dev->open) 
 258                 ret = dev->open(dev);
 259 
 260         /*
 261          *      If it went open OK then set the flags
 262          */
 263          
 264         if (ret == 0) 
 265                 dev->flags |= (IFF_UP | IFF_RUNNING);
 266         
 267         return(ret);
 268 }
 269 
 270 
 271 /*
 272  *      Completely shutdown an interface.
 273  *
 274  *      WARNING: Both because of the way the upper layers work (that can be fixed)
 275  *      and because of races during a close (that can't be fixed any other way)
 276  *      a device may be given things to transmit EVEN WHEN IT IS DOWN. The driver
 277  *      MUST cope with this (eg by freeing and dumping the frame).
 278  */
 279  
 280 int dev_close(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 281 {
 282         /*
 283          *      Only close a device if it is up.
 284          */
 285          
 286         if (dev->flags != 0) 
 287         {
 288                 int ct=0;
 289                 dev->flags = 0;
 290                 /*
 291                  *      Call the device specific close. This cannot fail.
 292                  */
 293                 if (dev->stop) 
 294                         dev->stop(dev);
 295                 /*
 296                  *      Delete the route to the device.
 297                  */
 298 #ifdef CONFIG_INET               
 299                 ip_rt_flush(dev);
 300                 arp_device_down(dev);
 301 #endif          
 302 #ifdef CONFIG_IPX
 303                 ipxrtr_device_down(dev);
 304 #endif  
 305                 /*
 306                  *      Blank the IP addresses
 307                  */
 308                 dev->pa_addr = 0;
 309                 dev->pa_dstaddr = 0;
 310                 dev->pa_brdaddr = 0;
 311                 dev->pa_mask = 0;
 312                 /*
 313                  *      Purge any queued packets when we down the link 
 314                  */
 315                 while(ct<DEV_NUMBUFFS)
 316                 {
 317                         struct sk_buff *skb;
 318                         while((skb=skb_dequeue(&dev->buffs[ct]))!=NULL)
 319                                 if(skb->free)
 320                                         kfree_skb(skb,FREE_WRITE);
 321                         ct++;
 322                 }
 323         }
 324         return(0);
 325 }
 326 
 327 
 328 /*
 329  *      Send (or queue for sending) a packet. 
 330  *
 331  *      IMPORTANT: When this is called to resend frames. The caller MUST
 332  *      already have locked the sk_buff. Apart from that we do the
 333  *      rest of the magic.
 334  */
 335 
 336 void dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
     /* [previous][next][first][last][top][bottom][index][help] */
 337 {
 338         unsigned long flags;
 339         int nitcount;
 340         struct packet_type *ptype;
 341         int where = 0;          /* used to say if the packet should go  */
 342                                 /* at the front or the back of the      */
 343                                 /* queue - front is a retranmsit try    */
 344 
 345         if (dev == NULL) 
 346         {
 347                 printk("dev.c: dev_queue_xmit: dev = NULL\n");
 348                 return;
 349         }
 350         
 351         if(pri>=0 && !skb_device_locked(skb))
 352                 skb_device_lock(skb);   /* Shove a lock on the frame */
 353 #ifdef CONFIG_SLAVE_BALANCING
 354         save_flags(flags);
 355         cli();
 356         if(dev->slave!=NULL && dev->slave->pkt_queue < dev->pkt_queue &&
 357                                 (dev->slave->flags & IFF_UP))
 358                 dev=dev->slave;
 359         restore_flags(flags);
 360 #endif          
 361  
 362         IS_SKB(skb);
 363     
 364         skb->dev = dev;
 365 
 366         /*
 367          *      This just eliminates some race conditions, but not all... 
 368          */
 369 
 370         if (skb->next != NULL) 
 371         {
 372                 /*
 373                  *      Make sure we haven't missed an interrupt. 
 374                  */
 375                 printk("dev_queue_xmit: worked around a missed interrupt\n");
 376                 dev->hard_start_xmit(NULL, dev);
 377                 return;
 378         }
 379 
 380         /*
 381          *      Negative priority is used to flag a frame that is being pulled from the
 382          *      queue front as a retransmit attempt. It therefore goes back on the queue
 383          *      start on a failure.
 384          */
 385          
 386         if (pri < 0) 
 387         {
 388                 pri = -pri-1;
 389                 where = 1;
 390         }
 391 
 392         if (pri >= DEV_NUMBUFFS) 
 393         {
 394                 printk("bad priority in dev_queue_xmit.\n");
 395                 pri = 1;
 396         }
 397 
 398         /*
 399          *      If the address has not been resolved. Call the device header rebuilder.
 400          *      This can cover all protocols and technically not just ARP either.
 401          */
 402          
 403         if (!skb->arp && dev->rebuild_header(skb->data, dev, skb->raddr, skb)) {
 404                 skb_device_unlock(skb); /* It's now safely on the arp queue */
 405                 return;
 406         }
 407 
 408         save_flags(flags);
 409         cli();  
 410         if (!where) {
 411 #ifdef CONFIG_SLAVE_BALANCING   
 412                 skb->in_dev_queue=1;
 413 #endif          
 414                 skb_queue_tail(dev->buffs + pri,skb);
 415                 skb_device_unlock(skb);         /* Buffer is on the device queue and can be freed safely */
 416                 skb = skb_dequeue(dev->buffs + pri);
 417                 skb_device_lock(skb);           /* New buffer needs locking down */
 418 #ifdef CONFIG_SLAVE_BALANCING           
 419                 skb->in_dev_queue=0;
 420 #endif          
 421         }
 422         restore_flags(flags);
 423 
 424         /* copy outgoing packets to any sniffer packet handlers */
 425         if(!where)
 426         {
 427                 for (nitcount = dev_nit, ptype = ptype_base; nitcount > 0 && ptype != NULL; ptype = ptype->next) 
 428                 {
 429                         if (ptype->type == htons(ETH_P_ALL)) {
 430                                 struct sk_buff *skb2;
 431                                 if ((skb2 = skb_clone(skb, GFP_ATOMIC)) == NULL)
 432                                         break;
 433                                 ptype->func(skb2, skb->dev, ptype);
 434                                 nitcount--;
 435                         }
 436                 }
 437         }
 438         if (dev->hard_start_xmit(skb, dev) == 0) {
 439                 /*
 440                  *      Packet is now solely the responsibility of the driver
 441                  */
 442 #ifdef CONFIG_SLAVE_BALANCING   
 443                 dev->pkt_queue--;
 444 #endif
 445                 return;
 446         }
 447 
 448         /*
 449          *      Transmission failed, put skb back into a list. Once on the list its safe and
 450          *      no longer device locked (it can be freed safely from the device queue)
 451          */
 452         cli();
 453 #ifdef CONFIG_SLAVE_BALANCING
 454         skb->in_dev_queue=1;
 455         dev->pkt_queue++;
 456 #endif          
 457         skb_device_unlock(skb);
 458         skb_queue_head(dev->buffs + pri,skb);
 459         restore_flags(flags);
 460 }
 461 
 462 /*
 463  *      Receive a packet from a device driver and queue it for the upper
 464  *      (protocol) levels.  It always succeeds. This is the recommended 
 465  *      interface to use.
 466  */
 467 
 468 void netif_rx(struct sk_buff *skb)
     /* [previous][next][first][last][top][bottom][index][help] */
 469 {
 470         static int dropping = 0;
 471 
 472         /*
 473          *      Any received buffers are un-owned and should be discarded
 474          *      when freed. These will be updated later as the frames get
 475          *      owners.
 476          */
 477         skb->sk = NULL;
 478         skb->free = 1;
 479         if(skb->stamp.tv_sec==0)
 480                 skb->stamp = xtime;
 481 
 482         /*
 483          *      Check that we aren't oevrdoing things.
 484          */
 485 
 486         if (!backlog_size)
 487                 dropping = 0;
 488         else if (backlog_size > 100)
 489                 dropping = 1;
 490 
 491         if (dropping) 
 492         {
 493                 kfree_skb(skb, FREE_READ);
 494                 return;
 495         }
 496 
 497         /*
 498          *      Add it to the "backlog" queue. 
 499          */
 500 
 501         IS_SKB(skb);
 502         skb_queue_tail(&backlog,skb);
 503         backlog_size++;
 504   
 505         /*
 506          *      If any packet arrived, mark it for processing after the
 507          *      hardware interrupt returns.
 508          */
 509 
 510         mark_bh(NET_BH);
 511         return;
 512 }
 513 
 514 
 515 /*
 516  *      The old interface to fetch a packet from a device driver.
 517  *      This function is the base level entry point for all drivers that
 518  *      want to send a packet to the upper (protocol) levels.  It takes
 519  *      care of de-multiplexing the packet to the various modules based
 520  *      on their protocol ID.
 521  *
 522  *      Return values:  1 <- exit I can't do any more
 523  *                      0 <- feed me more (i.e. "done", "OK"). 
 524  *
 525  *      This function is OBSOLETE and should not be used by any new
 526  *      device.
 527  */
 528 
 529 int dev_rint(unsigned char *buff, long len, int flags, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 530 {
 531         static int dropping = 0;
 532         struct sk_buff *skb = NULL;
 533         unsigned char *to;
 534         int amount, left;
 535         int len2;
 536 
 537         if (dev == NULL || buff == NULL || len <= 0) 
 538                 return(1);
 539 
 540         if (flags & IN_SKBUFF) 
 541         {
 542                 skb = (struct sk_buff *) buff;
 543         }
 544         else
 545         {
 546                 if (dropping) 
 547                 {
 548                         if (skb_peek(&backlog) != NULL)
 549                                 return(1);
 550                         printk("INET: dev_rint: no longer dropping packets.\n");
 551                         dropping = 0;
 552                 }
 553 
 554                 skb = alloc_skb(len, GFP_ATOMIC);
 555                 if (skb == NULL) 
 556                 {
 557                         printk("dev_rint: packet dropped on %s (no memory) !\n",
 558                                dev->name);
 559                         dropping = 1;
 560                         return(1);
 561                 }
 562 
 563                 /* 
 564                  *      First we copy the packet into a buffer, and save it for later. We
 565                  *      in effect handle the incoming data as if it were from a circular buffer
 566                  */
 567 
 568                 to = skb->data;
 569                 left = len;
 570 
 571                 len2 = len;
 572                 while (len2 > 0) 
 573                 {
 574                         amount = min(len2, (unsigned long) dev->rmem_end -
 575                                                 (unsigned long) buff);
 576                         memcpy(to, buff, amount);
 577                         len2 -= amount;
 578                         left -= amount;
 579                         buff += amount;
 580                         to += amount;
 581                         if ((unsigned long) buff == dev->rmem_end)
 582                                 buff = (unsigned char *) dev->rmem_start;
 583                 }
 584         }
 585 
 586         /*
 587          *      Tag the frame and kick it to the proper receive routine
 588          */
 589          
 590         skb->len = len;
 591         skb->dev = dev;
 592         skb->free = 1;
 593 
 594         netif_rx(skb);
 595         /*
 596          *      OK, all done. 
 597          */
 598         return(0);
 599 }
 600 
 601 
 602 /*
 603  *      This routine causes all interfaces to try to send some data. 
 604  */
 605  
 606 void dev_transmit(void)
     /* [previous][next][first][last][top][bottom][index][help] */
 607 {
 608         struct device *dev;
 609 
 610         for (dev = dev_base; dev != NULL; dev = dev->next) 
 611         {
 612                 if (dev->flags != 0 && !dev->tbusy) {
 613                         /*
 614                          *      Kick the device
 615                          */
 616                         dev_tint(dev);
 617                 }
 618         }
 619 }
 620 
 621 
 622 /**********************************************************************************
 623 
 624                         Receive Queue Processor
 625                         
 626 ***********************************************************************************/
 627 
 628 /*
 629  *      This is a single non-rentrant routine which takes the received packet
 630  *      queue and throws it at the networking layers in the hope that something
 631  *      useful will emerge.
 632  */
 633  
 634 volatile char in_bh = 0;        /* Non-rentrant remember */
 635 
 636 int in_net_bh() /* Used by timer.c */
     /* [previous][next][first][last][top][bottom][index][help] */
 637 {
 638         return(in_bh==0?0:1);
 639 }
 640 
 641 /*
 642  *      When we are called the queue is ready to grab, the interrupts are
 643  *      on and hardware can interrupt and queue to the receive queue a we
 644  *      run with no problems.
 645  *      This is run as a bottom half after an interrupt handler that does
 646  *      mark_bh(NET_BH);
 647  */
 648  
 649 void net_bh(void *tmp)
     /* [previous][next][first][last][top][bottom][index][help] */
 650 {
 651         struct sk_buff *skb;
 652         struct packet_type *ptype;
 653         unsigned short type;
 654         unsigned char flag = 0;
 655         int nitcount;
 656 
 657         /*
 658          *      Atomically check and mark our BUSY state. 
 659          */
 660 
 661         if (set_bit(1, (void*)&in_bh))
 662                 return;
 663 
 664         /*
 665          *      Can we send anything now? We want to clear the
 666          *      decks for any more sends that get done as we
 667          *      process the input.
 668          */
 669 
 670         dev_transmit();
 671   
 672         /*
 673          *      Any data left to process. This may occur because a
 674          *      mark_bh() is done after we empty the queue including
 675          *      that from the device which does a mark_bh() just after
 676          */
 677 
 678         cli();
 679         
 680         /*
 681          *      While the queue is not empty
 682          */
 683          
 684         while((skb=skb_dequeue(&backlog))!=NULL)
 685         {
 686                 /*
 687                  *      We have a packet. Therefore the queue has shrunk
 688                  */
 689                 backlog_size--;
 690 
 691                 nitcount=dev_nit;
 692                 flag=0;
 693                 sti();
 694                 
 695                /*
 696                 *       Bump the pointer to the next structure.
 697                 *       This assumes that the basic 'skb' pointer points to
 698                 *       the MAC header, if any (as indicated by its "length"
 699                 *       field).  Take care now!
 700                 */
 701 
 702                 skb->h.raw = skb->data + skb->dev->hard_header_len;
 703                 skb->len -= skb->dev->hard_header_len;
 704 
 705                /*
 706                 *       Fetch the packet protocol ID.  This is also quite ugly, as
 707                 *       it depends on the protocol driver (the interface itself) to
 708                 *       know what the type is, or where to get it from.  The Ethernet
 709                 *       interfaces fetch the ID from the two bytes in the Ethernet MAC
 710                 *       header (the h_proto field in struct ethhdr), but other drivers
 711                 *       may either use the ethernet ID's or extra ones that do not
 712                 *       clash (eg ETH_P_AX25). We could set this before we queue the
 713                 *       frame. In fact I may change this when I have time.
 714                 */
 715                 
 716                 type = skb->dev->type_trans(skb, skb->dev);
 717 
 718                 /*
 719                  *      We got a packet ID.  Now loop over the "known protocols"
 720                  *      table (which is actually a linked list, but this will
 721                  *      change soon if I get my way- FvK), and forward the packet
 722                  *      to anyone who wants it.
 723                  *
 724                  *      [FvK didn't get his way but he is right this ought to be
 725                  *      hashed so we typically get a single hit. The speed cost
 726                  *      here is minimal but no doubt adds up at the 4,000+ pkts/second
 727                  *      rate we can hit flat out]
 728                  */
 729                  
 730                 for (ptype = ptype_base; ptype != NULL; ptype = ptype->next) 
 731                 {
 732                         if (ptype->type == type || ptype->type == htons(ETH_P_ALL)) 
 733                         {
 734                                 struct sk_buff *skb2;
 735 
 736                                 if (ptype->type == htons(ETH_P_ALL))
 737                                         nitcount--;
 738                                 if (ptype->copy || nitcount) 
 739                                 {       
 740                                         /*
 741                                          *      copy if we need to
 742                                          */
 743 #ifdef OLD
 744                                         skb2 = alloc_skb(skb->len, GFP_ATOMIC);
 745                                         if (skb2 == NULL) 
 746                                                 continue;
 747                                         memcpy(skb2, skb, skb2->mem_len);
 748                                         skb2->mem_addr = skb2;
 749                                         skb2->h.raw = (unsigned char *)(
 750                                             (unsigned long) skb2 +
 751                                             (unsigned long) skb->h.raw -
 752                                             (unsigned long) skb
 753                                         );
 754                                         skb2->free = 1;
 755 #else
 756                                         skb2=skb_clone(skb, GFP_ATOMIC);
 757                                         if(skb2==NULL)
 758                                                 continue;
 759 #endif                          
 760                                 } 
 761                                 else 
 762                                 {
 763                                         skb2 = skb;
 764                                 }
 765 
 766                                 /*
 767                                  *      Protocol located. 
 768                                  */
 769                                  
 770                                 flag = 1;
 771 
 772                                 /*
 773                                  *      Kick the protocol handler. This should be fast
 774                                  *      and efficient code.
 775                                  */
 776 
 777                                 ptype->func(skb2, skb->dev, ptype);
 778                         }
 779                 } /* End of protocol list loop */
 780 
 781                 /*
 782                  *      Has an unknown packet has been received ?
 783                  */
 784          
 785                 if (!flag) 
 786                 {
 787                         kfree_skb(skb, FREE_WRITE);
 788                 }
 789 
 790                 /*
 791                  *      Again, see if we can transmit anything now. 
 792                  */
 793 
 794                 dev_transmit();
 795                 cli();
 796         }       /* End of queue loop */
 797         
 798         /*
 799          *      We have emptied the queue
 800          */
 801          
 802         in_bh = 0;
 803         sti();
 804         
 805         /*
 806          *      One last output flush.
 807          */
 808          
 809         dev_transmit();
 810 }
 811 
 812 
 813 /*
 814  *      This routine is called when an device driver (i.e. an
 815  *      interface) is ready to transmit a packet.
 816  */
 817  
 818 void dev_tint(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 819 {
 820         int i;
 821         struct sk_buff *skb;
 822         unsigned long flags;
 823         
 824         save_flags(flags);      
 825         /*
 826          *      Work the queues in priority order
 827          */
 828          
 829         for(i = 0;i < DEV_NUMBUFFS; i++) 
 830         {
 831                 /*
 832                  *      Pull packets from the queue
 833                  */
 834                  
 835 
 836                 cli();
 837                 while((skb=skb_dequeue(&dev->buffs[i]))!=NULL)
 838                 {
 839                         /*
 840                          *      Stop anyone freeing the buffer while we retransmit it
 841                          */
 842                         skb_device_lock(skb);
 843                         restore_flags(flags);
 844                         /*
 845                          *      Feed them to the output stage and if it fails
 846                          *      indicate they re-queue at the front.
 847                          */
 848                         dev_queue_xmit(skb,dev,-i - 1);
 849                         /*
 850                          *      If we can take no more then stop here.
 851                          */
 852                         if (dev->tbusy)
 853                                 return;
 854                         cli();
 855                 }
 856         }
 857         restore_flags(flags);
 858 }
 859 
 860 
 861 /*
 862  *      Perform a SIOCGIFCONF call. This structure will change
 863  *      size shortly, and there is nothing I can do about it.
 864  *      Thus we will need a 'compatibility mode'.
 865  */
 866 
 867 static int dev_ifconf(char *arg)
     /* [previous][next][first][last][top][bottom][index][help] */
 868 {
 869         struct ifconf ifc;
 870         struct ifreq ifr;
 871         struct device *dev;
 872         char *pos;
 873         int len;
 874         int err;
 875 
 876         /*
 877          *      Fetch the caller's info block. 
 878          */
 879          
 880         err=verify_area(VERIFY_WRITE, arg, sizeof(struct ifconf));
 881         if(err)
 882                 return err;
 883         memcpy_fromfs(&ifc, arg, sizeof(struct ifconf));
 884         len = ifc.ifc_len;
 885         pos = ifc.ifc_buf;
 886 
 887         /*
 888          *      We now walk the device list filling each active device
 889          *      into the array.
 890          */
 891          
 892         err=verify_area(VERIFY_WRITE,pos,len);
 893         if(err)
 894                 return err;
 895         
 896         /*
 897          *      Loop over the interfaces, and write an info block for each. 
 898          */
 899 
 900         for (dev = dev_base; dev != NULL; dev = dev->next) 
 901         {
 902                 if(!(dev->flags & IFF_UP))      /* Downed devices don't count */
 903                         continue;
 904                 memset(&ifr, 0, sizeof(struct ifreq));
 905                 strcpy(ifr.ifr_name, dev->name);
 906                 (*(struct sockaddr_in *) &ifr.ifr_addr).sin_family = dev->family;
 907                 (*(struct sockaddr_in *) &ifr.ifr_addr).sin_addr.s_addr = dev->pa_addr;
 908 
 909                 /*
 910                  *      Write this block to the caller's space. 
 911                  */
 912                  
 913                 memcpy_tofs(pos, &ifr, sizeof(struct ifreq));
 914                 pos += sizeof(struct ifreq);
 915                 len -= sizeof(struct ifreq);
 916                 
 917                 /*
 918                  *      Have we run out of space here ?
 919                  */
 920         
 921                 if (len < sizeof(struct ifreq)) 
 922                         break;
 923         }
 924 
 925         /*
 926          *      All done.  Write the updated control block back to the caller. 
 927          */
 928          
 929         ifc.ifc_len = (pos - ifc.ifc_buf);
 930         ifc.ifc_req = (struct ifreq *) ifc.ifc_buf;
 931         memcpy_tofs(arg, &ifc, sizeof(struct ifconf));
 932         
 933         /*
 934          *      Report how much was filled in
 935          */
 936          
 937         return(pos - arg);
 938 }
 939 
 940 
 941 /*
 942  *      This is invoked by the /proc filesystem handler to display a device
 943  *      in detail.
 944  */
 945 
 946 static int sprintf_stats(char *buffer, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 947 {
 948         struct enet_statistics *stats = (dev->get_stats ? dev->get_stats(dev): NULL);
 949         int size;
 950         
 951         if (stats)
 952                 size = sprintf(buffer, "%6s:%7d %4d %4d %4d %4d %8d %4d %4d %4d %5d %4d\n",
 953                    dev->name,
 954                    stats->rx_packets, stats->rx_errors,
 955                    stats->rx_dropped + stats->rx_missed_errors,
 956                    stats->rx_fifo_errors,
 957                    stats->rx_length_errors + stats->rx_over_errors
 958                    + stats->rx_crc_errors + stats->rx_frame_errors,
 959                    stats->tx_packets, stats->tx_errors, stats->tx_dropped,
 960                    stats->tx_fifo_errors, stats->collisions,
 961                    stats->tx_carrier_errors + stats->tx_aborted_errors
 962                    + stats->tx_window_errors + stats->tx_heartbeat_errors);
 963         else
 964                 size = sprintf(buffer, "%6s: No statistics available.\n", dev->name);
 965 
 966         return size;
 967 }
 968 
 969 /*
 970  *      Called from the PROCfs module. This now uses the new arbitary sized /proc/net interface
 971  *      to create /proc/net/dev
 972  */
 973  
 974 int dev_get_info(char *buffer, char **start, off_t offset, int length)
     /* [previous][next][first][last][top][bottom][index][help] */
 975 {
 976         int len=0;
 977         off_t begin=0;
 978         off_t pos=0;
 979         int size;
 980         
 981         struct device *dev;
 982 
 983 
 984         size = sprintf(buffer, "Inter-|   Receive                  |  Transmit\n"
 985                             " face |packets errs drop fifo frame|packets errs drop fifo colls carrier\n");
 986         
 987         pos+=size;
 988         len+=size;
 989         
 990 
 991         for (dev = dev_base; dev != NULL; dev = dev->next) 
 992         {
 993                 size = sprintf_stats(buffer+len, dev);
 994                 len+=size;
 995                 pos=begin+len;
 996                                 
 997                 if(pos<offset)
 998                 {
 999                         len=0;
1000                         begin=pos;
1001                 }
1002                 if(pos>offset+length)
1003                         break;
1004         }
1005         
1006         *start=buffer+(offset-begin);   /* Start of wanted data */
1007         len-=(offset-begin);            /* Start slop */
1008         if(len>length)
1009                 len=length;             /* Ending slop */
1010         return len;
1011 }
1012 
1013 
1014 /*
1015  *      This checks bitmasks for the ioctl calls for devices.
1016  */
1017  
1018 static inline int bad_mask(unsigned long mask, unsigned long addr)
     /* [previous][next][first][last][top][bottom][index][help] */
1019 {
1020         if (addr & (mask = ~mask))
1021                 return 1;
1022         mask = ntohl(mask);
1023         if (mask & (mask+1))
1024                 return 1;
1025         return 0;
1026 }
1027 
1028 /*
1029  *      Perform the SIOCxIFxxx calls. 
1030  *
1031  *      The socket layer has seen an ioctl the address family thinks is
1032  *      for the device. At this point we get invoked to make a decision
1033  */
1034  
1035 static int dev_ifsioc(void *arg, unsigned int getset)
     /* [previous][next][first][last][top][bottom][index][help] */
1036 {
1037         struct ifreq ifr;
1038         struct device *dev;
1039         int ret;
1040 
1041         /*
1042          *      Fetch the caller's info block into kernel space
1043          */
1044 
1045         int err=verify_area(VERIFY_WRITE, arg, sizeof(struct ifreq));
1046         if(err)
1047                 return err;
1048         
1049         memcpy_fromfs(&ifr, arg, sizeof(struct ifreq));
1050 
1051         /*
1052          *      See which interface the caller is talking about. 
1053          */
1054          
1055         if ((dev = dev_get(ifr.ifr_name)) == NULL) 
1056                 return(-ENODEV);
1057 
1058         switch(getset) 
1059         {
1060                 case SIOCGIFFLAGS:      /* Get interface flags */
1061                         ifr.ifr_flags = dev->flags;
1062                         memcpy_tofs(arg, &ifr, sizeof(struct ifreq));
1063                         ret = 0;
1064                         break;
1065                 case SIOCSIFFLAGS:      /* Set interface flags */
1066                         {
1067                                 int old_flags = dev->flags;
1068 #ifdef CONFIG_SLAVE_BALANCING                           
1069                                 if(dev->flags&IFF_SLAVE)
1070                                         return -EBUSY;
1071 #endif                                  
1072                                 dev->flags = ifr.ifr_flags & (
1073                                         IFF_UP | IFF_BROADCAST | IFF_DEBUG | IFF_LOOPBACK |
1074                                         IFF_POINTOPOINT | IFF_NOTRAILERS | IFF_RUNNING |
1075                                         IFF_NOARP | IFF_PROMISC | IFF_ALLMULTI | IFF_SLAVE | IFF_MASTER);
1076 #ifdef CONFIG_SLAVE_BALANCING                           
1077                                 if(!(dev->flags&IFF_MASTER) && dev->slave)
1078                                 {
1079                                         dev->slave->flags&=~IFF_SLAVE;
1080                                         dev->slave=NULL;
1081                                 }
1082 #endif                          
1083                                 
1084                                 /*
1085                                  *      Has promiscuous mode been turned off
1086                                  */     
1087                                 if ( (old_flags & IFF_PROMISC) && ((dev->flags & IFF_PROMISC) == 0))
1088                                         dev->set_multicast_list(dev,0,NULL);
1089                                         
1090                                 /*
1091                                  *      Has it been turned on
1092                                  */
1093         
1094                                 if ( (dev->flags & IFF_PROMISC) && ((old_flags & IFF_PROMISC) == 0))
1095                                         dev->set_multicast_list(dev,-1,NULL);
1096                                         
1097                                 /*
1098                                  *      Have we downed the interface
1099                                  */
1100                 
1101                                 if ((old_flags & IFF_UP) && ((dev->flags & IFF_UP) == 0)) 
1102                                 {
1103                                         ret = dev_close(dev);
1104                                 }
1105                                 else
1106                                 {
1107                                         /*
1108                                          *      Have we upped the interface 
1109                                          */
1110                                          
1111                                         ret = (! (old_flags & IFF_UP) && (dev->flags & IFF_UP))
1112                                                 ? dev_open(dev) : 0;
1113                                         /* 
1114                                          *      Check the flags.
1115                                          */
1116                                         if(ret<0)
1117                                                 dev->flags&=~IFF_UP;    /* Didnt open so down the if */
1118                                 }
1119                         }
1120                         break;
1121                 
1122                 case SIOCGIFADDR:       /* Get interface address (and family) */
1123                         (*(struct sockaddr_in *)
1124                                   &ifr.ifr_addr).sin_addr.s_addr = dev->pa_addr;
1125                         (*(struct sockaddr_in *)
1126                                   &ifr.ifr_addr).sin_family = dev->family;
1127                         (*(struct sockaddr_in *)
1128                                   &ifr.ifr_addr).sin_port = 0;
1129                         memcpy_tofs(arg, &ifr, sizeof(struct ifreq));
1130                         ret = 0;
1131                         break;
1132         
1133                 case SIOCSIFADDR:       /* Set interface address (and family) */
1134                         dev->pa_addr = (*(struct sockaddr_in *)
1135                                  &ifr.ifr_addr).sin_addr.s_addr;
1136                         dev->family = ifr.ifr_addr.sa_family;
1137                         
1138 #ifdef CONFIG_INET      
1139                         /* This is naughty. When net-032e comes out It wants moving into the net032
1140                            code not the kernel. Till then it can sit here (SIGH) */             
1141                         dev->pa_mask = ip_get_mask(dev->pa_addr);
1142 #endif                  
1143                         dev->pa_brdaddr = dev->pa_addr | ~dev->pa_mask;
1144                         ret = 0;
1145                         break;
1146                         
1147                 case SIOCGIFBRDADDR:    /* Get the broadcast address */
1148                         (*(struct sockaddr_in *)
1149                                 &ifr.ifr_broadaddr).sin_addr.s_addr = dev->pa_brdaddr;
1150                         (*(struct sockaddr_in *)
1151                                 &ifr.ifr_broadaddr).sin_family = dev->family;
1152                         (*(struct sockaddr_in *)
1153                                 &ifr.ifr_broadaddr).sin_port = 0;
1154                         memcpy_tofs(arg, &ifr, sizeof(struct ifreq));
1155                         ret = 0;
1156                         break;
1157 
1158                 case SIOCSIFBRDADDR:    /* Set the broadcast address */
1159                         dev->pa_brdaddr = (*(struct sockaddr_in *)
1160                                 &ifr.ifr_broadaddr).sin_addr.s_addr;
1161                         ret = 0;
1162                         break;
1163                         
1164                 case SIOCGIFDSTADDR:    /* Get the destination address (for point-to-point links) */
1165                         (*(struct sockaddr_in *)
1166                                 &ifr.ifr_dstaddr).sin_addr.s_addr = dev->pa_dstaddr;
1167                         (*(struct sockaddr_in *)
1168                                 &ifr.ifr_broadaddr).sin_family = dev->family;
1169                         (*(struct sockaddr_in *)
1170                                 &ifr.ifr_broadaddr).sin_port = 0;
1171                                 memcpy_tofs(arg, &ifr, sizeof(struct ifreq));
1172                         ret = 0;
1173                         break;
1174         
1175                 case SIOCSIFDSTADDR:    /* Set the destination address (for point-to-point links) */
1176                         dev->pa_dstaddr = (*(struct sockaddr_in *)
1177                                 &ifr.ifr_dstaddr).sin_addr.s_addr;
1178                         ret = 0;
1179                         break;
1180                         
1181                 case SIOCGIFNETMASK:    /* Get the netmask for the interface */
1182                         (*(struct sockaddr_in *)
1183                                 &ifr.ifr_netmask).sin_addr.s_addr = dev->pa_mask;
1184                         (*(struct sockaddr_in *)
1185                                 &ifr.ifr_netmask).sin_family = dev->family;
1186                         (*(struct sockaddr_in *)
1187                                 &ifr.ifr_netmask).sin_port = 0;
1188                         memcpy_tofs(arg, &ifr, sizeof(struct ifreq));
1189                         ret = 0;
1190                         break;
1191 
1192                 case SIOCSIFNETMASK:    /* Set the netmask for the interface */
1193                         {
1194                                 unsigned long mask = (*(struct sockaddr_in *)
1195                                         &ifr.ifr_netmask).sin_addr.s_addr;
1196                                 ret = -EINVAL;
1197                                 /*
1198                                  *      The mask we set must be legal.
1199                                  */
1200                                 if (bad_mask(mask,0))
1201                                         break;
1202                                 dev->pa_mask = mask;
1203                                 ret = 0;
1204                         }
1205                         break;
1206                         
1207                 case SIOCGIFMETRIC:     /* Get the metric on the inteface (currently unused) */
1208                         
1209                         ifr.ifr_metric = dev->metric;
1210                         memcpy_tofs(arg, &ifr, sizeof(struct ifreq));
1211                         ret = 0;
1212                         break;
1213                         
1214                 case SIOCSIFMETRIC:     /* Set the metric on the interface (currently unused) */
1215                         dev->metric = ifr.ifr_metric;
1216                         ret = 0;
1217                         break;
1218         
1219                 case SIOCGIFMTU:        /* Get the MTU of a device */
1220                         ifr.ifr_mtu = dev->mtu;
1221                         memcpy_tofs(arg, &ifr, sizeof(struct ifreq));
1222                         ret = 0;
1223                         break;
1224         
1225                 case SIOCSIFMTU:        /* Set the MTU of a device */
1226                 
1227                         /*
1228                          *      MTU must be positive and under the page size problem
1229                          */
1230                          
1231                         if(ifr.ifr_mtu<1 || ifr.ifr_mtu>3800)
1232                                 return -EINVAL;
1233                         dev->mtu = ifr.ifr_mtu;
1234                         ret = 0;
1235                         break;
1236         
1237                 case SIOCGIFMEM:        /* Get the per device memory space. We can add this but currently
1238                                            do not support it */
1239                         printk("NET: ioctl(SIOCGIFMEM, 0x%08X)\n", (int)arg);
1240                         ret = -EINVAL;
1241                         break;
1242                 
1243                 case SIOCSIFMEM:        /* Set the per device memory buffer space. Not applicable in our case */
1244                         printk("NET: ioctl(SIOCSIFMEM, 0x%08X)\n", (int)arg);
1245                         ret = -EINVAL;
1246                         break;
1247 
1248                 case OLD_SIOCGIFHWADDR: /* Get the hardware address. This will change and SIFHWADDR will be added */
1249                         memcpy(ifr.old_ifr_hwaddr,dev->dev_addr, MAX_ADDR_LEN);
1250                         memcpy_tofs(arg,&ifr,sizeof(struct ifreq));
1251                         ret=0;
1252                         break;
1253 
1254                 case SIOCGIFHWADDR:
1255                         memcpy(ifr.ifr_hwaddr.sa_data,dev->dev_addr, MAX_ADDR_LEN);
1256                         ifr.ifr_hwaddr.sa_family=dev->type;                     
1257                         memcpy_tofs(arg,&ifr,sizeof(struct ifreq));
1258                         ret=0;
1259                         break;
1260                         
1261                 case SIOCSIFHWADDR:
1262                         if(dev->set_mac_address==NULL)
1263                                 return -EOPNOTSUPP;
1264                         if(ifr.ifr_hwaddr.sa_family!=dev->type)
1265                                 return -EINVAL;
1266                         ret=dev->set_mac_address(dev,ifr.ifr_hwaddr.sa_data);
1267                         break;
1268                 
1269                 case SIOCDEVPRIVATE:
1270                         if(dev->do_ioctl==NULL)
1271                                 return -EOPNOTSUPP;
1272                         ret=dev->do_ioctl(dev, &ifr);
1273                         memcpy_tofs(arg,&ifr,sizeof(struct ifreq));
1274                         break;
1275                         
1276                 case SIOCGIFMAP:
1277                         ifr.ifr_map.mem_start=dev->mem_start;
1278                         ifr.ifr_map.mem_end=dev->mem_end;
1279                         ifr.ifr_map.base_addr=dev->base_addr;
1280                         ifr.ifr_map.irq=dev->irq;
1281                         ifr.ifr_map.dma=dev->dma;
1282                         ifr.ifr_map.port=dev->if_port;
1283                         memcpy_tofs(arg,&ifr,sizeof(struct ifreq));
1284                         ret=0;
1285                         break;
1286                         
1287                 case SIOCSIFMAP:
1288                         if(dev->set_config==NULL)
1289                                 return -EOPNOTSUPP;
1290                         return dev->set_config(dev,&ifr.ifr_map);
1291                         
1292                 case SIOCGIFSLAVE:
1293 #ifdef CONFIG_SLAVE_BALANCING           
1294                         if(dev->slave==NULL)
1295                                 return -ENOENT;
1296                         strncpy(ifr.ifr_name,dev->name,sizeof(ifr.ifr_name));
1297                         memcpy_tofs(arg,&ifr,sizeof(struct ifreq));
1298                         ret=0;
1299 #else
1300                         return -ENOENT;
1301 #endif                  
1302                         break;
1303 #ifdef CONFIG_SLAVE_BALANCING                   
1304                 case SIOCSIFSLAVE:
1305                 {
1306                 
1307                 /*
1308                  *      Fun game. Get the device up and the flags right without
1309                  *      letting some scummy user confuse us.
1310                  */
1311                         unsigned long flags;
1312                         struct device *slave=dev_get(ifr.ifr_slave);
1313                         save_flags(flags);
1314                         if(slave==NULL)
1315                         {
1316                                 return -ENODEV;
1317                         }
1318                         cli();
1319                         if((slave->flags&(IFF_UP|IFF_RUNNING))!=(IFF_UP|IFF_RUNNING))
1320                         {
1321                                 restore_flags(flags);
1322                                 return -EINVAL;
1323                         }
1324                         if(dev->flags&IFF_SLAVE)
1325                         {
1326                                 restore_flags(flags);
1327                                 return -EBUSY;
1328                         }
1329                         if(dev->slave!=NULL)
1330                         {
1331                                 restore_flags(flags);
1332                                 return -EBUSY;
1333                         }
1334                         if(slave->flags&IFF_SLAVE)
1335                         {
1336                                 restore_flags(flags);
1337                                 return -EBUSY;
1338                         }
1339                         dev->slave=slave;
1340                         slave->flags|=IFF_SLAVE;
1341                         dev->flags|=IFF_MASTER;
1342                         restore_flags(flags);
1343                         ret=0;
1344                 }
1345                 break;
1346 #endif                  
1347                 /*
1348                  *      Unknown ioctl
1349                  */
1350 
1351                 default:
1352                         ret = -EINVAL;
1353         }
1354         return(ret);
1355 }
1356 
1357 
1358 /*
1359  *      This function handles all "interface"-type I/O control requests. The actual
1360  *      'doing' part of this is dev_ifsioc above.
1361  */
1362 
1363 int dev_ioctl(unsigned int cmd, void *arg)
     /* [previous][next][first][last][top][bottom][index][help] */
1364 {
1365         switch(cmd) 
1366         {
1367                 /*
1368                  *      The old old setup ioctl. Even its name and this entry will soon be
1369                  *      just so much ionization on a backup tape.
1370                  */
1371 
1372                 case SIOCGIFCONF:
1373                         (void) dev_ifconf((char *) arg);
1374                         return 0;
1375 
1376                 /*
1377                  *      Ioctl calls that can be done by all.
1378                  */
1379                  
1380                 case SIOCGIFFLAGS:
1381                 case SIOCGIFADDR:
1382                 case SIOCGIFDSTADDR:
1383                 case SIOCGIFBRDADDR:
1384                 case SIOCGIFNETMASK:
1385                 case SIOCGIFMETRIC:
1386                 case SIOCGIFMTU:
1387                 case SIOCGIFMEM:
1388                 case SIOCGIFHWADDR:
1389                 case SIOCSIFHWADDR:
1390                 case OLD_SIOCGIFHWADDR:
1391                 case SIOCGIFSLAVE:
1392                 case SIOCGIFMAP:
1393                         return dev_ifsioc(arg, cmd);
1394 
1395                 /*
1396                  *      Ioctl calls requiring the power of a superuser
1397                  */
1398                  
1399                 case SIOCSIFFLAGS:
1400                 case SIOCSIFADDR:
1401                 case SIOCSIFDSTADDR:
1402                 case SIOCSIFBRDADDR:
1403                 case SIOCSIFNETMASK:
1404                 case SIOCSIFMETRIC:
1405                 case SIOCSIFMTU:
1406                 case SIOCSIFMEM:
1407                 case SIOCSIFMAP:
1408                 case SIOCSIFSLAVE:
1409                 case SIOCDEVPRIVATE:
1410                         if (!suser())
1411                                 return -EPERM;
1412                         return dev_ifsioc(arg, cmd);
1413         
1414                 case SIOCSIFLINK:
1415                         return -EINVAL;
1416 
1417                 /*
1418                  *      Unknown ioctl.
1419                  */     
1420                  
1421                 default:
1422                         return -EINVAL;
1423         }
1424 }
1425 
1426 
1427 /*
1428  *      Initialize the DEV module. At boot time this walks the device list and
1429  *      unhooks any devices that fail to initialise (normally hardware not 
1430  *      present) and leaves us with a valid list of present and active devices.
1431  *
1432  *      The PCMICA code may need to change this a little, and add a pair
1433  *      of register_inet_device() unregister_inet_device() calls. This will be
1434  *      needed for ethernet as modules support.
1435  */
1436  
1437 void dev_init(void)
     /* [previous][next][first][last][top][bottom][index][help] */
1438 {
1439         struct device *dev, *dev2;
1440 
1441         /*
1442          *      Add the devices.
1443          *      If the call to dev->init fails, the dev is removed
1444          *      from the chain disconnecting the device until the
1445          *      next reboot.
1446          */
1447          
1448         dev2 = NULL;
1449         for (dev = dev_base; dev != NULL; dev=dev->next) 
1450         {
1451                 if (dev->init && dev->init(dev)) 
1452                 {
1453                         /*
1454                          *      It failed to come up. Unhook it.
1455                          */
1456                          
1457                         if (dev2 == NULL) 
1458                                 dev_base = dev->next;
1459                         else 
1460                                 dev2->next = dev->next;
1461                 } 
1462                 else
1463                 {
1464                         dev2 = dev;
1465                 }
1466         }
1467 }

/* [previous][next][first][last][top][bottom][index][help] */