drivers/isdn/i4l/isdn_net.h

   1 /* $Id: isdn_net.h,v 1.1.2.2 2004/01/12 22:37:19 keil Exp $
   2  *
   3  * header for Linux ISDN subsystem, network related functions (linklevel).
   4  *
   5  * Copyright 1994-1999  by Fritz Elfert (fritz@isdn4linux.de)
   6  * Copyright 1995,96    by Thinking Objects Software GmbH Wuerzburg
   7  * Copyright 1995,96    by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de)
   8  *
   9  * This software may be used and distributed according to the terms
  10  * of the GNU General Public License, incorporated herein by reference.
  11  *
  12  */
  13
  14                               /* Definitions for hupflags:                */
  15 #define ISDN_WAITCHARGE  1      /* did not get a charge info yet            */
  16 #define ISDN_HAVECHARGE  2      /* We know a charge info                    */
  17 #define ISDN_CHARGEHUP   4      /* We want to use the charge mechanism      */
  18 #define ISDN_INHUP       8      /* Even if incoming, close after huptimeout */
  19 #define ISDN_MANCHARGE  16      /* Charge Interval manually set             */
  20
  21 /*
  22  * Definitions for Cisco-HDLC header.
  23  */
  24
  25 #define CISCO_ADDR_UNICAST    0x0f
  26 #define CISCO_ADDR_BROADCAST  0x8f
  27 #define CISCO_CTRL            0x00
  28 #define CISCO_TYPE_CDP        0x2000
  29 #define CISCO_TYPE_SLARP      0x8035
  30 #define CISCO_SLARP_REQUEST   0
  31 #define CISCO_SLARP_REPLY     1
  32 #define CISCO_SLARP_KEEPALIVE 2
  33
  34 extern char *isdn_net_new(char *, struct net_device *);
  35 extern char *isdn_net_newslave(char *);
  36 extern int isdn_net_rm(char *);
  37 extern int isdn_net_rmall(void);
  38 extern int isdn_net_stat_callback(int, isdn_ctrl *);
  39 extern int isdn_net_setcfg(isdn_net_ioctl_cfg *);
  40 extern int isdn_net_getcfg(isdn_net_ioctl_cfg *);
  41 extern int isdn_net_addphone(isdn_net_ioctl_phone *);
  42 extern int isdn_net_getphones(isdn_net_ioctl_phone *, char *);
  43 extern int isdn_net_getpeer(isdn_net_ioctl_phone *, isdn_net_ioctl_phone *);
  44 extern int isdn_net_delphone(isdn_net_ioctl_phone *);
  45 extern int isdn_net_find_icall(int, int, int, setup_parm *);
  46 extern void isdn_net_hangup(struct net_device *);
  47 extern void isdn_net_dial(void);
  48 extern void isdn_net_autohup(void);
  49 extern int isdn_net_force_hangup(char *);
  50 extern int isdn_net_force_dial(char *);
  51 extern isdn_net_dev *isdn_net_findif(char *);
  52 extern int isdn_net_rcv_skb(int, struct sk_buff *);
  53 extern int isdn_net_dial_req(isdn_net_local *);
  54 extern void isdn_net_writebuf_skb(isdn_net_local *lp, struct sk_buff *skb);
  55 extern void isdn_net_write_super(isdn_net_local *lp, struct sk_buff *skb);
  56
  57 #define ISDN_NET_MAX_QUEUE_LENGTH 2
  58
  59 /*
  60  * is this particular channel busy?
  61  */
  62 static __inline__ int isdn_net_lp_busy(isdn_net_local *lp)
  63 {
  64         if (atomic_read(&lp->frame_cnt) < ISDN_NET_MAX_QUEUE_LENGTH)
  65                 return 0;
  66         else
  67                 return 1;
  68 }
  69
  70 /*
  71  * For the given net device, this will get a non-busy channel out of the
  72  * corresponding bundle. The returned channel is locked.
  73  */
  74 static __inline__ isdn_net_local * isdn_net_get_locked_lp(isdn_net_dev *nd)
  75 {
  76         unsigned long flags;
  77         isdn_net_local *lp;
  78
  79         spin_lock_irqsave(&nd->queue_lock, flags);
  80         lp = nd->queue;         /* get lp on top of queue */
  81         spin_lock_bh(&nd->queue->xmit_lock);
  82         while (isdn_net_lp_busy(nd->queue)) {
  83                 spin_unlock_bh(&nd->queue->xmit_lock);
  84                 nd->queue = nd->queue->next;
  85                 if (nd->queue == lp) { /* not found -- should never happen */
  86                         lp = NULL;
  87                         goto errout;
  88                 }
  89                 spin_lock_bh(&nd->queue->xmit_lock);
  90         }
  91         lp = nd->queue;
  92         nd->queue = nd->queue->next;
  93 errout:
  94         spin_unlock_irqrestore(&nd->queue_lock, flags);
  95         return lp;
  96 }
  97
  98 /*
  99  * add a channel to a bundle
 100  */
 101 static __inline__ void isdn_net_add_to_bundle(isdn_net_dev *nd, isdn_net_local *nlp)
 102 {
 103         isdn_net_local *lp;
 104         unsigned long flags;
 105
 106         spin_lock_irqsave(&nd->queue_lock, flags);
 107
 108         lp = nd->queue;
 109 //      printk(KERN_DEBUG "%s: lp:%s(%p) nlp:%s(%p) last(%p)\n",
 110 //              __FUNCTION__, lp->name, lp, nlp->name, nlp, lp->last);
 111         nlp->last = lp->last;
 112         lp->last->next = nlp;
 113         lp->last = nlp;
 114         nlp->next = lp;
 115         nd->queue = nlp;
 116
 117         spin_unlock_irqrestore(&nd->queue_lock, flags);
 118 }
 119 /*
 120  * remove a channel from the bundle it belongs to
 121  */
 122 static __inline__ void isdn_net_rm_from_bundle(isdn_net_local *lp)
 123 {
 124         isdn_net_local *master_lp = lp;
 125         unsigned long flags;
 126
 127         if (lp->master)
 128                 master_lp = (isdn_net_local *) lp->master->priv;
 129
 130 //      printk(KERN_DEBUG "%s: lp:%s(%p) mlp:%s(%p) last(%p) next(%p) mndq(%p)\n",
 131 //              __FUNCTION__, lp->name, lp, master_lp->name, master_lp, lp->last, lp->next, master_lp->netdev->queue);
 132         spin_lock_irqsave(&master_lp->netdev->queue_lock, flags);
 133         lp->last->next = lp->next;
 134         lp->next->last = lp->last;
 135         if (master_lp->netdev->queue == lp) {
 136                 master_lp->netdev->queue = lp->next;
 137                 if (lp->next == lp) { /* last in queue */
 138                         master_lp->netdev->queue = master_lp->netdev->local;
 139                 }
 140         }
 141         lp->next = lp->last = lp;       /* (re)set own pointers */
 142 //      printk(KERN_DEBUG "%s: mndq(%p)\n",
 143 //              __FUNCTION__, master_lp->netdev->queue);
 144         spin_unlock_irqrestore(&master_lp->netdev->queue_lock, flags);
 145 }
 146
 147 static inline int
 148 put_u8(unsigned char *p, u8 x)
 149 {
 150         *p = x;
 151         return 1;
 152 }
 153
 154 static inline int
 155 put_u16(unsigned char *p, u16 x)
 156 {
 157         *((u16 *)p) = htons(x);
 158         return 2;
 159 }
 160
 161 static inline int
 162 put_u32(unsigned char *p, u32 x)
 163 {
 164         *((u32 *)p) = htonl(x);
 165         return 4;
 166 }
 167
 168 static inline int
 169 get_u8(unsigned char *p, u8 *x)
 170 {
 171         *x = *p;
 172         return 1;
 173 }
 174
 175 static inline int
 176 get_u16(unsigned char *p, u16 *x)
 177 {
 178         *x = ntohs(*((u16 *)p));
 179         return 2;
 180 }
 181
 182 static inline int
 183 get_u32(unsigned char *p, u32 *x)
 184 {
 185         *x = ntohl(*((u32 *)p));
 186         return 4;
 187 }
 188
 189