git.oblomov.eu Git - linux-2.6/blob - drivers/isdn/mISDN/l1oip_core.c

   1 /*
   2
   3  * l1oip.c  low level driver for tunneling layer 1 over IP
   4  *
   5  * NOTE: It is not compatible with TDMoIP nor "ISDN over IP".
   6  *
   7  * Author       Andreas Eversberg (jolly@eversberg.eu)
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2, or (at your option)
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  */
  24
  25 /* module parameters:
  26  * type:
  27         Value 1 = BRI
  28         Value 2 = PRI
  29         Value 3 = BRI (multi channel frame, not supported yet)
  30         Value 4 = PRI (multi channel frame, not supported yet)
  31         A multi channel frame reduces overhead to a single frame for all
  32         b-channels, but increases delay.
  33         (NOTE: Multi channel frames are not implemented yet.)
  34
  35  * codec:
  36         Value 0 = transparent (default)
  37         Value 1 = transfer ALAW
  38         Value 2 = transfer ULAW
  39         Value 3 = transfer generic 4 bit compression.
  40
  41  * ulaw:
  42         0 = we use a-Law (default)
  43         1 = we use u-Law
  44
  45  * limit:
  46         limitation of B-channels to control bandwidth (1...126)
  47         BRI: 1 or 2
  48         PRI: 1-30, 31-126 (126, because dchannel ist not counted here)
  49         Also limited ressources are used for stack, resulting in less channels.
  50         It is possible to have more channels than 30 in PRI mode, this must
  51         be supported by the application.
  52
  53  * ip:
  54         byte representation of remote ip address (127.0.0.1 -> 127,0,0,1)
  55         If not given or four 0, no remote address is set.
  56         For multiple interfaces, concat ip addresses. (127,0,0,1,127,0,0,1)
  57
  58  * port:
  59         port number (local interface)
  60         If not given or 0, port 931 is used for fist instance, 932 for next...
  61         For multiple interfaces, different ports must be given.
  62
  63  * remoteport:
  64         port number (remote interface)
  65         If not given or 0, remote port equals local port
  66         For multiple interfaces on equal sites, different ports must be given.
  67
  68  * ondemand:
  69         0 = fixed (always transmit packets, even when remote side timed out)
  70         1 = on demand (only transmit packets, when remote side is detected)
  71         the default is 0
  72         NOTE: ID must also be set for on demand.
  73
  74  * id:
  75         optional value to identify frames. This value must be equal on both
  76         peers and should be random. If omitted or 0, no ID is transmitted.
  77
  78  * debug:
  79         NOTE: only one debug value must be given for all cards
  80         enable debugging (see l1oip.h for debug options)
  81
  82
  83 Special mISDN controls:
  84
  85  op = MISDN_CTRL_SETPEER*
  86  p1 = bytes 0-3 : remote IP address in network order (left element first)
  87  p2 = bytes 1-2 : remote port in network order (high byte first)
  88  optional:
  89  p2 = bytes 3-4 : local port in network order (high byte first)
  90
  91  op = MISDN_CTRL_UNSETPEER*
  92
  93  * Use l1oipctrl for comfortable setting or removing ip address.
  94    (Layer 1 Over IP CTRL)
  95
  96
  97 L1oIP-Protocol
  98 --------------
  99
 100 Frame Header:
 101
 102  7 6 5 4 3 2 1 0
 103 +---------------+
 104 |Ver|T|I|Coding |
 105 +---------------+
 106 |  ID byte 3 *  |
 107 +---------------+
 108 |  ID byte 2 *  |
 109 +---------------+
 110 |  ID byte 1 *  |
 111 +---------------+
 112 |  ID byte 0 *  |
 113 +---------------+
 114 |M|   Channel   |
 115 +---------------+
 116 |    Length *   |
 117 +---------------+
 118 | Time Base MSB |
 119 +---------------+
 120 | Time Base LSB |
 121 +---------------+
 122 | Data....      |
 123
 124 ...
 125
 126 |               |
 127 +---------------+
 128 |M|   Channel   |
 129 +---------------+
 130 |    Length *   |
 131 +---------------+
 132 | Time Base MSB |
 133 +---------------+
 134 | Time Base LSB |
 135 +---------------+
 136 | Data....      |
 137
 138 ...
 139
 140
 141 * Only included in some cases.
 142
 143 - Ver = Version
 144 If version is missmatch, the frame must be ignored.
 145
 146 - T = Type of interface
 147 Must be 0 for S0 or 1 for E1.
 148
 149 - I = Id present
 150 If bit is set, four ID bytes are included in frame.
 151
 152 - ID = Connection ID
 153 Additional ID to prevent Denial of Service attacs. Also it prevents hijacking
 154 connections with dynamic IP. The ID should be random and must not be 0.
 155
 156 - Coding = Type of codec
 157 Must be 0 for no transcoding. Also for D-channel and other HDLC frames.
 158  1 and 2 are reserved for explicitly use of a-LAW or u-LAW codec.
 159  3 is used for generic table compressor.
 160
 161 - M = More channels to come. If this flag is 1, the following byte contains
 162 the length of the channel data. After the data block, the next channel will
 163 be defined. The flag for the last channel block (or if only one channel is
 164 transmitted), must be 0 and no length is given.
 165
 166 - Channel = Channel number
 167 0 reserved
 168 1-3 channel data for S0 (3 is D-channel)
 169 1-31 channel data for E1 (16 is D-channel)
 170 32-127 channel data for extended E1 (16 is D-channel)
 171
 172 - The length is used if the M-flag is 1. It is used to find the next channel
 173 inside frame.
 174 NOTE: A value of 0 equals 256 bytes of data.
 175  -> For larger data blocks, a single frame must be used.
 176  -> For larger streams, a single frame or multiple blocks with same channel ID
 177    must be used.
 178
 179 - Time Base = Timestamp of first sample in frame
 180 The "Time Base" is used to rearange packets and to detect packet loss.
 181 The 16 bits are sent in network order (MSB first) and count 1/8000 th of a
 182 second. This causes a wrap arround each 8,192 seconds. There is no requirement
 183 for the initial "Time Base", but 0 should be used for the first packet.
 184 In case of HDLC data, this timestamp counts the packet or byte number.
 185
 186
 187 Two Timers:
 188
 189 After initialisation, a timer of 15 seconds is started. Whenever a packet is
 190 transmitted, the timer is reset to 15 seconds again. If the timer expires, an
 191 empty packet is transmitted. This keep the connection alive.
 192
 193 When a valid packet is received, a timer 65 seconds is started. The interface
 194 become ACTIVE. If the timer expires, the interface becomes INACTIVE.
 195
 196
 197 Dynamic IP handling:
 198
 199 To allow dynamic IP, the ID must be non 0. In this case, any packet with the
 200 correct port number and ID will be accepted. If the remote side changes its IP
 201 the new IP is used for all transmitted packets until it changes again.
 202
 203
 204 On Demand:
 205
 206 If the ondemand parameter is given, the remote IP is set to 0 on timeout.
 207 This will stop keepalive traffic to remote. If the remote is online again,
 208 traffic will continue to the remote address. This is usefull for road warriors.
 209 This feature only works with ID set, otherwhise it is highly unsecure.
 210
 211
 212 Socket and Thread
 213 -----------------
 214
 215 The complete socket opening and closing is done by a thread.
 216 When the thread opened a socket, the hc->socket descriptor is set. Whenever a
 217 packet shall be sent to the socket, the hc->socket must be checked wheter not
 218 NULL. To prevent change in socket descriptor, the hc->socket_lock must be used.
 219 To change the socket, a recall of l1oip_socket_open() will safely kill the
 220 socket process and create a new one.
 221
 222 */
 223
 224 #define L1OIP_VERSION   0       /* 0...3 */
 225
 226 #include <linux/module.h>
 227 #include <linux/delay.h>
 228 #include <linux/mISDNif.h>
 229 #include <linux/mISDNhw.h>
 230 #include <linux/mISDNdsp.h>
 231 #include <linux/init.h>
 232 #include <linux/in.h>
 233 #include <linux/inet.h>
 234 #include <linux/workqueue.h>
 235 #include <linux/kthread.h>
 236 #include <net/sock.h>
 237 #include "core.h"
 238 #include "l1oip.h"
 239
 240 static const char *l1oip_revision = "2.00";
 241
 242 static int l1oip_cnt;
 243 static spinlock_t l1oip_lock;
 244 static struct list_head l1oip_ilist;
 245
 246 #define MAX_CARDS       16
 247 static u_int type[MAX_CARDS];
 248 static u_int codec[MAX_CARDS];
 249 static u_int ip[MAX_CARDS*4];
 250 static u_int port[MAX_CARDS];
 251 static u_int remoteport[MAX_CARDS];
 252 static u_int ondemand[MAX_CARDS];
 253 static u_int limit[MAX_CARDS];
 254 static u_int id[MAX_CARDS];
 255 static int debug;
 256 static int ulaw;
 257
 258 MODULE_AUTHOR("Andreas Eversberg");
 259 MODULE_LICENSE("GPL");
 260 module_param_array(type, uint, NULL, S_IRUGO | S_IWUSR);
 261 module_param_array(codec, uint, NULL, S_IRUGO | S_IWUSR);
 262 module_param_array(ip, uint, NULL, S_IRUGO | S_IWUSR);
 263 module_param_array(port, uint, NULL, S_IRUGO | S_IWUSR);
 264 module_param_array(remoteport, uint, NULL, S_IRUGO | S_IWUSR);
 265 module_param_array(ondemand, uint, NULL, S_IRUGO | S_IWUSR);
 266 module_param_array(limit, uint, NULL, S_IRUGO | S_IWUSR);
 267 module_param_array(id, uint, NULL, S_IRUGO | S_IWUSR);
 268 module_param(ulaw, uint, S_IRUGO | S_IWUSR);
 269 module_param(debug, uint, S_IRUGO | S_IWUSR);
 270
 271 /*
 272  * send a frame via socket, if open and restart timer
 273  */
 274 static int
 275 l1oip_socket_send(struct l1oip *hc, u8 localcodec, u8 channel, u32 chanmask,
 276         u16 timebase, u8 *buf, int len)
 277 {
 278         u8 *p;
 279         int multi = 0;
 280         u8 frame[len+32];
 281         struct socket *socket = NULL;
 282         mm_segment_t oldfs;
 283
 284         if (debug & DEBUG_L1OIP_MSG)
 285                 printk(KERN_DEBUG "%s: sending data to socket (len = %d)\n",
 286                         __func__, len);
 287
 288         p = frame;
 289
 290         /* restart timer */
 291         if ((int)(hc->keep_tl.expires-jiffies) < 5*HZ) {
 292                 del_timer(&hc->keep_tl);
 293                 hc->keep_tl.expires = jiffies + L1OIP_KEEPALIVE*HZ;
 294                 add_timer(&hc->keep_tl);
 295         } else
 296                 hc->keep_tl.expires = jiffies + L1OIP_KEEPALIVE*HZ;
 297
 298         if (debug & DEBUG_L1OIP_MSG)
 299                 printk(KERN_DEBUG "%s: resetting timer\n", __func__);
 300
 301         /* drop if we have no remote ip or port */
 302         if (!hc->sin_remote.sin_addr.s_addr || !hc->sin_remote.sin_port) {
 303                 if (debug & DEBUG_L1OIP_MSG)
 304                         printk(KERN_DEBUG "%s: dropping frame, because remote "
 305                                 "IP is not set.\n", __func__);
 306                 return len;
 307         }
 308
 309         /* assemble frame */
 310         *p++ = (L1OIP_VERSION<<6) /* version and coding */
 311              | (hc->pri?0x20:0x00) /* type */
 312              | (hc->id?0x10:0x00) /* id */
 313              | localcodec;
 314         if (hc->id) {
 315                 *p++ = hc->id>>24; /* id */
 316                 *p++ = hc->id>>16;
 317                 *p++ = hc->id>>8;
 318                 *p++ = hc->id;
 319         }
 320         *p++ = (multi == 1)?0x80:0x00 + channel; /* m-flag, channel */
 321         if (multi == 1)
 322                 *p++ = len; /* length */
 323         *p++ = timebase>>8; /* time base */
 324         *p++ = timebase;
 325
 326         if (buf && len) { /* add data to frame */
 327                 if (localcodec == 1 && ulaw)
 328                         l1oip_ulaw_to_alaw(buf, len, p);
 329                 else if (localcodec == 2 && !ulaw)
 330                         l1oip_alaw_to_ulaw(buf, len, p);
 331                 else if (localcodec == 3)
 332                         len = l1oip_law_to_4bit(buf, len, p,
 333                                 &hc->chan[channel].codecstate);
 334                 else
 335                         memcpy(p, buf, len);
 336         }
 337         len += p - frame;
 338
 339         /* check for socket in safe condition */
 340         spin_lock(&hc->socket_lock);
 341         if (!hc->socket) {
 342                 spin_unlock(&hc->socket_lock);
 343                 return 0;
 344         }
 345         /* seize socket */
 346         socket = hc->socket;
 347         hc->socket = NULL;
 348         spin_unlock(&hc->socket_lock);
 349         /* send packet */
 350         if (debug & DEBUG_L1OIP_MSG)
 351                 printk(KERN_DEBUG "%s: sending packet to socket (len "
 352                         "= %d)\n", __func__, len);
 353         hc->sendiov.iov_base = frame;
 354         hc->sendiov.iov_len  = len;
 355         oldfs = get_fs();
 356         set_fs(KERNEL_DS);
 357         len = sock_sendmsg(socket, &hc->sendmsg, len);
 358         set_fs(oldfs);
 359         /* give socket back */
 360         hc->socket = socket; /* no locking required */
 361
 362         return len;
 363 }
 364
 365
 366 /*
 367  * receive channel data from socket
 368  */
 369 static void
 370 l1oip_socket_recv(struct l1oip *hc, u8 remotecodec, u8 channel, u16 timebase,
 371         u8 *buf, int len)
 372 {
 373         struct sk_buff *nskb;
 374         struct bchannel *bch;
 375         struct dchannel *dch;
 376         u8 *p;
 377         u32 rx_counter;
 378
 379         if (len == 0) {
 380                 if (debug & DEBUG_L1OIP_MSG)
 381                         printk(KERN_DEBUG "%s: received empty keepalive data, "
 382                                 "ignoring\n", __func__);
 383                 return;
 384         }
 385
 386         if (debug & DEBUG_L1OIP_MSG)
 387                 printk(KERN_DEBUG "%s: received data, sending to mISDN (%d)\n",
 388                         __func__, len);
 389
 390         if (channel < 1 || channel > 127) {
 391                 printk(KERN_WARNING "%s: packet error - channel %d out of "
 392                         "range\n", __func__, channel);
 393                 return;
 394         }
 395         dch = hc->chan[channel].dch;
 396         bch = hc->chan[channel].bch;
 397         if (!dch && !bch) {
 398                 printk(KERN_WARNING "%s: packet error - channel %d not in "
 399                         "stack\n", __func__, channel);
 400                 return;
 401         }
 402
 403         /* prepare message */
 404         nskb = mI_alloc_skb((remotecodec == 3)?(len<<1):len, GFP_ATOMIC);
 405         if (!nskb) {
 406                 printk(KERN_ERR "%s: No mem for skb.\n", __func__);
 407                 return;
 408         }
 409         p = skb_put(nskb, (remotecodec == 3)?(len<<1):len);
 410
 411         if (remotecodec == 1 && ulaw)
 412                 l1oip_alaw_to_ulaw(buf, len, p);
 413         else if (remotecodec == 2 && !ulaw)
 414                 l1oip_ulaw_to_alaw(buf, len, p);
 415         else if (remotecodec == 3)
 416                 len = l1oip_4bit_to_law(buf, len, p);
 417         else
 418                 memcpy(p, buf, len);
 419
 420         /* send message up */
 421         if (dch && len >= 2) {
 422                 dch->rx_skb = nskb;
 423                 recv_Dchannel(dch);
 424         }
 425         if (bch) {
 426                 /* expand 16 bit sequence number to 32 bit sequence number */
 427                 rx_counter = hc->chan[channel].rx_counter;
 428                 if (((s16)(timebase - rx_counter)) >= 0) {
 429                         /* time has changed forward */
 430                         if (timebase >= (rx_counter & 0xffff))
 431                                 rx_counter =
 432                                         (rx_counter & 0xffff0000) | timebase;
 433                         else
 434                                 rx_counter = ((rx_counter & 0xffff0000)+0x10000)
 435                                         | timebase;
 436                 } else {
 437                         /* time has changed backwards */
 438                         if (timebase < (rx_counter & 0xffff))
 439                                 rx_counter =
 440                                         (rx_counter & 0xffff0000) | timebase;
 441                         else
 442                                 rx_counter = ((rx_counter & 0xffff0000)-0x10000)
 443                                         | timebase;
 444                 }
 445                 hc->chan[channel].rx_counter = rx_counter;
 446
 447 #ifdef REORDER_DEBUG
 448                 if (hc->chan[channel].disorder_flag) {
 449                         struct sk_buff *skb;
 450                         int cnt;
 451                         skb = hc->chan[channel].disorder_skb;
 452                         hc->chan[channel].disorder_skb = nskb;
 453                         nskb = skb;
 454                         cnt = hc->chan[channel].disorder_cnt;
 455                         hc->chan[channel].disorder_cnt = rx_counter;
 456                         rx_counter = cnt;
 457                 }
 458                 hc->chan[channel].disorder_flag ^= 1;
 459                 if (nskb)
 460 #endif
 461                 queue_ch_frame(&bch->ch, PH_DATA_IND, rx_counter, nskb);
 462         }
 463 }
 464
 465
 466 /*
 467  * parse frame and extract channel data
 468  */
 469 static void
 470 l1oip_socket_parse(struct l1oip *hc, struct sockaddr_in *sin, u8 *buf, int len)
 471 {
 472         u32                     id;
 473         u8                      channel;
 474         u8                      remotecodec;
 475         u16                     timebase;
 476         int                     m, mlen;
 477         int                     len_start = len; /* initial frame length */
 478         struct dchannel         *dch = hc->chan[hc->d_idx].dch;
 479
 480         if (debug & DEBUG_L1OIP_MSG)
 481                 printk(KERN_DEBUG "%s: received frame, parsing... (%d)\n",
 482                         __func__, len);
 483
 484         /* check lenght */
 485         if (len < 1+1+2) {
 486                 printk(KERN_WARNING "%s: packet error - length %d below "
 487                         "4 bytes\n", __func__, len);
 488                 return;
 489         }
 490
 491         /* check version */
 492         if (((*buf)>>6) != L1OIP_VERSION) {
 493                 printk(KERN_WARNING "%s: packet error - unknown version %d\n",
 494                         __func__, buf[0]>>6);
 495                 return;
 496         }
 497
 498         /* check type */
 499         if (((*buf)&0x20) && !hc->pri) {
 500                 printk(KERN_WARNING "%s: packet error - received E1 packet "
 501                         "on S0 interface\n", __func__);
 502                 return;
 503         }
 504         if (!((*buf)&0x20) && hc->pri) {
 505                 printk(KERN_WARNING "%s: packet error - received S0 packet "
 506                         "on E1 interface\n", __func__);
 507                 return;
 508         }
 509
 510         /* get id flag */
 511         id = (*buf>>4)&1;
 512
 513         /* check coding */
 514         remotecodec = (*buf) & 0x0f;
 515         if (remotecodec > 3) {
 516                 printk(KERN_WARNING "%s: packet error - remotecodec %d "
 517                         "unsupported\n", __func__, remotecodec);
 518                 return;
 519         }
 520         buf++;
 521         len--;
 522
 523         /* check id */
 524         if (id) {
 525                 if (!hc->id) {
 526                         printk(KERN_WARNING "%s: packet error - packet has id "
 527                                 "0x%x, but we have not\n", __func__, id);
 528                         return;
 529                 }
 530                 if (len < 4) {
 531                         printk(KERN_WARNING "%s: packet error - packet too "
 532                                 "short for ID value\n", __func__);
 533                         return;
 534                 }
 535                 id = (*buf++) << 24;
 536                 id += (*buf++) << 16;
 537                 id += (*buf++) << 8;
 538                 id += (*buf++);
 539                 len -= 4;
 540
 541                 if (id != hc->id) {
 542                         printk(KERN_WARNING "%s: packet error - ID mismatch, "
 543                                 "got 0x%x, we 0x%x\n",
 544                                 __func__, id, hc->id);
 545                         return;
 546                 }
 547         } else {
 548                 if (hc->id) {
 549                         printk(KERN_WARNING "%s: packet error - packet has no "
 550                                 "ID, but we have\n", __func__);
 551                         return;
 552                 }
 553         }
 554
 555 multiframe:
 556         if (len < 1) {
 557                 printk(KERN_WARNING "%s: packet error - packet too short, "
 558                         "channel expected at position %d.\n",
 559                         __func__, len-len_start+1);
 560                 return;
 561         }
 562
 563         /* get channel and multiframe flag */
 564         channel = *buf&0x7f;
 565         m = *buf >> 7;
 566         buf++;
 567         len--;
 568
 569         /* check length on multiframe */
 570         if (m) {
 571                 if (len < 1) {
 572                         printk(KERN_WARNING "%s: packet error - packet too "
 573                                 "short, length expected at position %d.\n",
 574                                 __func__, len_start-len-1);
 575                         return;
 576                 }
 577
 578                 mlen = *buf++;
 579                 len--;
 580                 if (mlen == 0)
 581                         mlen = 256;
 582                 if (len < mlen+3) {
 583                         printk(KERN_WARNING "%s: packet error - length %d at "
 584                                 "position %d exceeds total length %d.\n",
 585                                 __func__, mlen, len_start-len-1, len_start);
 586                         return;
 587                 }
 588                 if (len == mlen+3) {
 589                         printk(KERN_WARNING "%s: packet error - length %d at "
 590                                 "position %d will not allow additional "
 591                                 "packet.\n",
 592                                 __func__, mlen, len_start-len+1);
 593                         return;
 594                 }
 595         } else
 596                 mlen = len-2; /* single frame, substract timebase */
 597
 598         if (len < 2) {
 599                 printk(KERN_WARNING "%s: packet error - packet too short, time "
 600                         "base expected at position %d.\n",
 601                         __func__, len-len_start+1);
 602                 return;
 603         }
 604
 605         /* get time base */
 606         timebase = (*buf++) << 8;
 607         timebase |= (*buf++);
 608         len -= 2;
 609
 610         /* if inactive, we send up a PH_ACTIVATE and activate */
 611         if (!test_bit(FLG_ACTIVE, &dch->Flags)) {
 612                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
 613                         printk(KERN_DEBUG "%s: interface become active due to "
 614                                 "received packet\n", __func__);
 615                 test_and_set_bit(FLG_ACTIVE, &dch->Flags);
 616                 _queue_data(&dch->dev.D, PH_ACTIVATE_IND, MISDN_ID_ANY, 0,
 617                         NULL, GFP_ATOMIC);
 618         }
 619
 620         /* distribute packet */
 621         l1oip_socket_recv(hc, remotecodec, channel, timebase, buf, mlen);
 622         buf += mlen;
 623         len -= mlen;
 624
 625         /* multiframe */
 626         if (m)
 627                 goto multiframe;
 628
 629         /* restart timer */
 630         if ((int)(hc->timeout_tl.expires-jiffies) < 5*HZ || !hc->timeout_on) {
 631                 hc->timeout_on = 1;
 632                 del_timer(&hc->timeout_tl);
 633                 hc->timeout_tl.expires = jiffies + L1OIP_TIMEOUT*HZ;
 634                 add_timer(&hc->timeout_tl);
 635         } else /* only adjust timer */
 636                 hc->timeout_tl.expires = jiffies + L1OIP_TIMEOUT*HZ;
 637
 638         /* if ip or source port changes */
 639         if ((hc->sin_remote.sin_addr.s_addr != sin->sin_addr.s_addr)
 640          || (hc->sin_remote.sin_port != sin->sin_port)) {
 641                 if (debug & DEBUG_L1OIP_SOCKET)
 642                         printk(KERN_DEBUG "%s: remote address changes from "
 643                                 "0x%08x to 0x%08x (port %d to %d)\n", __func__,
 644                                 ntohl(hc->sin_remote.sin_addr.s_addr),
 645                                 ntohl(sin->sin_addr.s_addr),
 646                                 ntohs(hc->sin_remote.sin_port),
 647                                 ntohs(sin->sin_port));
 648                 hc->sin_remote.sin_addr.s_addr = sin->sin_addr.s_addr;
 649                 hc->sin_remote.sin_port = sin->sin_port;
 650         }
 651 }
 652
 653
 654 /*
 655  * socket stuff
 656  */
 657 static int
 658 l1oip_socket_thread(void *data)
 659 {
 660         struct l1oip *hc = (struct l1oip *)data;
 661         int ret = 0;
 662         struct msghdr msg;
 663         struct iovec iov;
 664         mm_segment_t oldfs;
 665         struct sockaddr_in sin_rx;
 666         unsigned char recvbuf[1500];
 667         int recvlen;
 668         struct socket *socket = NULL;
 669         DECLARE_COMPLETION(wait);
 670
 671         /* make daemon */
 672         allow_signal(SIGTERM);
 673
 674         /* create socket */
 675         if (sock_create(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &socket)) {
 676                 printk(KERN_ERR "%s: Failed to create socket.\n", __func__);
 677                 return -EIO;
 678         }
 679
 680         /* set incoming address */
 681         hc->sin_local.sin_family = AF_INET;
 682         hc->sin_local.sin_addr.s_addr = INADDR_ANY;
 683         hc->sin_local.sin_port = htons((unsigned short)hc->localport);
 684
 685         /* set outgoing address */
 686         hc->sin_remote.sin_family = AF_INET;
 687         hc->sin_remote.sin_addr.s_addr = htonl(hc->remoteip);
 688         hc->sin_remote.sin_port = htons((unsigned short)hc->remoteport);
 689
 690         /* bind to incomming port */
 691         if (socket->ops->bind(socket, (struct sockaddr *)&hc->sin_local,
 692             sizeof(hc->sin_local))) {
 693                 printk(KERN_ERR "%s: Failed to bind socket to port %d.\n",
 694                         __func__, hc->localport);
 695                 ret = -EINVAL;
 696                 goto fail;
 697         }
 698
 699         /* check sk */
 700         if (socket->sk == NULL) {
 701                 printk(KERN_ERR "%s: socket->sk == NULL\n", __func__);
 702                 ret = -EIO;
 703                 goto fail;
 704         }
 705
 706         /* build receive message */
 707         msg.msg_name = &sin_rx;
 708         msg.msg_namelen = sizeof(sin_rx);
 709         msg.msg_control = NULL;
 710         msg.msg_controllen = 0;
 711         msg.msg_iov = &iov;
 712         msg.msg_iovlen = 1;
 713
 714         /* build send message */
 715         hc->sendmsg.msg_name = &hc->sin_remote;
 716         hc->sendmsg.msg_namelen = sizeof(hc->sin_remote);
 717         hc->sendmsg.msg_control = NULL;
 718         hc->sendmsg.msg_controllen = 0;
 719         hc->sendmsg.msg_iov    = &hc->sendiov;
 720         hc->sendmsg.msg_iovlen = 1;
 721
 722         /* give away socket */
 723         spin_lock(&hc->socket_lock);
 724         hc->socket = socket;
 725         spin_unlock(&hc->socket_lock);
 726
 727         /* read loop */
 728         if (debug & DEBUG_L1OIP_SOCKET)
 729                 printk(KERN_DEBUG "%s: socket created and open\n",
 730                         __func__);
 731         while (!signal_pending(current)) {
 732                 iov.iov_base = recvbuf;
 733                 iov.iov_len = sizeof(recvbuf);
 734                 oldfs = get_fs();
 735                 set_fs(KERNEL_DS);
 736                 recvlen = sock_recvmsg(socket, &msg, sizeof(recvbuf), 0);
 737                 set_fs(oldfs);
 738                 if (recvlen > 0) {
 739                         l1oip_socket_parse(hc, &sin_rx, recvbuf, recvlen);
 740                 } else {
 741                         if (debug & DEBUG_L1OIP_SOCKET)
 742                             printk(KERN_WARNING "%s: broken pipe on socket\n",
 743                                 __func__);
 744                 }
 745         }
 746
 747         /* get socket back, check first if in use, maybe by send function */
 748         spin_lock(&hc->socket_lock);
 749         /* if hc->socket is NULL, it is in use until it is given back */
 750         while (!hc->socket) {
 751                 spin_unlock(&hc->socket_lock);
 752                 schedule_timeout(HZ/10);
 753                 spin_lock(&hc->socket_lock);
 754         }
 755         hc->socket = NULL;
 756         spin_unlock(&hc->socket_lock);
 757
 758         if (debug & DEBUG_L1OIP_SOCKET)
 759                 printk(KERN_DEBUG "%s: socket thread terminating\n",
 760                         __func__);
 761
 762 fail:
 763         /* close socket */
 764         if (socket)
 765                 sock_release(socket);
 766
 767         /* if we got killed, signal completion */
 768         complete(&hc->socket_complete);
 769         hc->socket_thread = NULL; /* show termination of thread */
 770
 771         if (debug & DEBUG_L1OIP_SOCKET)
 772                 printk(KERN_DEBUG "%s: socket thread terminated\n",
 773                         __func__);
 774         return ret;
 775 }
 776
 777 static void
 778 l1oip_socket_close(struct l1oip *hc)
 779 {
 780         /* kill thread */
 781         if (hc->socket_thread) {
 782                 if (debug & DEBUG_L1OIP_SOCKET)
 783                         printk(KERN_DEBUG "%s: socket thread exists, "
 784                                 "killing...\n", __func__);
 785                 send_sig(SIGTERM, hc->socket_thread, 0);
 786                 wait_for_completion(&hc->socket_complete);
 787         }
 788 }
 789
 790 static int
 791 l1oip_socket_open(struct l1oip *hc)
 792 {
 793         /* in case of reopen, we need to close first */
 794         l1oip_socket_close(hc);
 795
 796         init_completion(&hc->socket_complete);
 797
 798         /* create receive process */
 799         hc->socket_thread = kthread_run(l1oip_socket_thread, hc, "l1oip_%s",
 800                 hc->name);
 801         if (IS_ERR(hc->socket_thread)) {
 802                 int err = PTR_ERR(hc->socket_thread);
 803                 printk(KERN_ERR "%s: Failed (%d) to create socket process.\n",
 804                         __func__, err);
 805                 hc->socket_thread = NULL;
 806                 sock_release(hc->socket);
 807                 return err;
 808         }
 809         if (debug & DEBUG_L1OIP_SOCKET)
 810                 printk(KERN_DEBUG "%s: socket thread created\n", __func__);
 811
 812         return 0;
 813 }
 814
 815
 816 static void
 817 l1oip_send_bh(struct work_struct *work)
 818 {
 819         struct l1oip *hc = container_of(work, struct l1oip, workq);
 820
 821         if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
 822                 printk(KERN_DEBUG "%s: keepalive timer expired, sending empty "
 823                         "frame on dchannel\n", __func__);
 824
 825         /* send an empty l1oip frame at D-channel */
 826         l1oip_socket_send(hc, 0, hc->d_idx, 0, 0, NULL, 0);
 827 }
 828
 829
 830 /*
 831  * timer stuff
 832  */
 833 static void
 834 l1oip_keepalive(void *data)
 835 {
 836         struct l1oip *hc = (struct l1oip *)data;
 837
 838         schedule_work(&hc->workq);
 839 }
 840
 841 static void
 842 l1oip_timeout(void *data)
 843 {
 844         struct l1oip                    *hc = (struct l1oip *)data;
 845         struct dchannel         *dch = hc->chan[hc->d_idx].dch;
 846
 847         if (debug & DEBUG_L1OIP_MSG)
 848                 printk(KERN_DEBUG "%s: timeout timer expired, turn layer one "
 849                         "down.\n", __func__);
 850
 851         hc->timeout_on = 0; /* state that timer must be initialized next time */
 852
 853         /* if timeout, we send up a PH_DEACTIVATE and deactivate */
 854         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
 855                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
 856                         printk(KERN_DEBUG "%s: interface become deactivated "
 857                                 "due to timeout\n", __func__);
 858                 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
 859                 _queue_data(&dch->dev.D, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
 860                         NULL, GFP_ATOMIC);
 861         }
 862
 863         /* if we have ondemand set, we remove ip address */
 864         if (hc->ondemand) {
 865                 if (debug & DEBUG_L1OIP_MSG)
 866                         printk(KERN_DEBUG "%s: on demand causes ip address to "
 867                                 "be removed\n", __func__);
 868                 hc->sin_remote.sin_addr.s_addr = 0;
 869         }
 870 }
 871
 872
 873 /*
 874  * message handling
 875  */
 876 static int
 877 handle_dmsg(struct mISDNchannel *ch, struct sk_buff *skb)
 878 {
 879         struct mISDNdevice      *dev = container_of(ch, struct mISDNdevice, D);
 880         struct dchannel         *dch = container_of(dev, struct dchannel, dev);
 881         struct l1oip                    *hc = dch->hw;
 882         struct mISDNhead        *hh = mISDN_HEAD_P(skb);
 883         int                     ret = -EINVAL;
 884         int                     l, ll;
 885         unsigned char           *p;
 886
 887         switch (hh->prim) {
 888         case PH_DATA_REQ:
 889                 if (skb->len < 1) {
 890                         printk(KERN_WARNING "%s: skb too small\n",
 891                                 __func__);
 892                         break;
 893                 }
 894                 if (skb->len > MAX_DFRAME_LEN_L1 || skb->len > L1OIP_MAX_LEN) {
 895                         printk(KERN_WARNING "%s: skb too large\n",
 896                                 __func__);
 897                         break;
 898                 }
 899                 /* send frame */
 900                 p = skb->data;
 901                 l = skb->len;
 902                 while (l) {
 903                         ll = (l < L1OIP_MAX_PERFRAME)?l:L1OIP_MAX_PERFRAME;
 904                         l1oip_socket_send(hc, 0, dch->slot, 0,
 905                                 hc->chan[dch->slot].tx_counter++, p, ll);
 906                         p += ll;
 907                         l -= ll;
 908                 }
 909                 skb_trim(skb, 0);
 910                 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
 911                 return 0;
 912         case PH_ACTIVATE_REQ:
 913                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
 914                         printk(KERN_DEBUG "%s: PH_ACTIVATE channel %d (1..%d)\n"
 915                                 , __func__, dch->slot, hc->b_num+1);
 916                 skb_trim(skb, 0);
 917                 if (test_bit(FLG_ACTIVE, &dch->Flags))
 918                         queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
 919                 else
 920                         queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
 921                 return 0;
 922         case PH_DEACTIVATE_REQ:
 923                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
 924                         printk(KERN_DEBUG "%s: PH_DEACTIVATE channel %d "
 925                                 "(1..%d)\n", __func__, dch->slot,
 926                                 hc->b_num+1);
 927                 skb_trim(skb, 0);
 928                 if (test_bit(FLG_ACTIVE, &dch->Flags))
 929                         queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
 930                 else
 931                         queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
 932                 return 0;
 933         }
 934         if (!ret)
 935                 dev_kfree_skb(skb);
 936         return ret;
 937 }
 938
 939 static int
 940 channel_dctrl(struct dchannel *dch, struct mISDN_ctrl_req *cq)
 941 {
 942         int     ret = 0;
 943         struct l1oip    *hc = dch->hw;
 944
 945         switch (cq->op) {
 946         case MISDN_CTRL_GETOP:
 947                 cq->op = MISDN_CTRL_SETPEER | MISDN_CTRL_UNSETPEER;
 948                 break;
 949         case MISDN_CTRL_SETPEER:
 950                 hc->remoteip = (u32)cq->p1;
 951                 hc->remoteport = cq->p2 & 0xffff;
 952                 hc->localport = cq->p2 >> 16;
 953                 if (!hc->remoteport)
 954                         hc->remoteport = hc->localport;
 955                 if (debug & DEBUG_L1OIP_SOCKET)
 956                         printk(KERN_DEBUG "%s: got new ip address from user "
 957                                 "space.\n", __func__);
 958                         l1oip_socket_open(hc);
 959                 break;
 960         case MISDN_CTRL_UNSETPEER:
 961                 if (debug & DEBUG_L1OIP_SOCKET)
 962                         printk(KERN_DEBUG "%s: removing ip address.\n",
 963                                 __func__);
 964                 hc->remoteip = 0;
 965                 l1oip_socket_open(hc);
 966                 break;
 967         default:
 968                 printk(KERN_WARNING "%s: unknown Op %x\n",
 969                     __func__, cq->op);
 970                 ret = -EINVAL;
 971                 break;
 972         }
 973         return ret;
 974 }
 975
 976 static int
 977 open_dchannel(struct l1oip *hc, struct dchannel *dch, struct channel_req *rq)
 978 {
 979         if (debug & DEBUG_HW_OPEN)
 980                 printk(KERN_DEBUG "%s: dev(%d) open from %p\n", __func__,
 981                     dch->dev.id, __builtin_return_address(0));
 982         if (rq->protocol == ISDN_P_NONE)
 983                 return -EINVAL;
 984         if ((dch->dev.D.protocol != ISDN_P_NONE) &&
 985             (dch->dev.D.protocol != rq->protocol)) {
 986                 if (debug & DEBUG_HW_OPEN)
 987                         printk(KERN_WARNING "%s: change protocol %x to %x\n",
 988                         __func__, dch->dev.D.protocol, rq->protocol);
 989         }
 990         if (dch->dev.D.protocol != rq->protocol)
 991                 dch->dev.D.protocol = rq->protocol;
 992
 993         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
 994                 _queue_data(&dch->dev.D, PH_ACTIVATE_IND, MISDN_ID_ANY,
 995                     0, NULL, GFP_KERNEL);
 996         }
 997         rq->ch = &dch->dev.D;
 998         if (!try_module_get(THIS_MODULE))
 999                 printk(KERN_WARNING "%s:cannot get module\n", __func__);
1000         return 0;
1001 }
1002
1003 static int
1004 open_bchannel(struct l1oip *hc, struct dchannel *dch, struct channel_req *rq)
1005 {
1006         struct bchannel *bch;
1007         int             ch;
1008
1009         if (!test_channelmap(rq->adr.channel, dch->dev.channelmap))
1010                 return -EINVAL;
1011         if (rq->protocol == ISDN_P_NONE)
1012                 return -EINVAL;
1013         ch = rq->adr.channel; /* BRI: 1=B1 2=B2  PRI: 1..15,17.. */
1014         bch = hc->chan[ch].bch;
1015         if (!bch) {
1016                 printk(KERN_ERR "%s:internal error ch %d has no bch\n",
1017                     __func__, ch);
1018                 return -EINVAL;
1019         }
1020         if (test_and_set_bit(FLG_OPEN, &bch->Flags))
1021                 return -EBUSY; /* b-channel can be only open once */
1022         bch->ch.protocol = rq->protocol;
1023         rq->ch = &bch->ch;
1024         if (!try_module_get(THIS_MODULE))
1025                 printk(KERN_WARNING "%s:cannot get module\n", __func__);
1026         return 0;
1027 }
1028
1029 static int
1030 l1oip_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1031 {
1032         struct mISDNdevice      *dev = container_of(ch, struct mISDNdevice, D);
1033         struct dchannel         *dch = container_of(dev, struct dchannel, dev);
1034         struct l1oip                    *hc = dch->hw;
1035         struct channel_req      *rq;
1036         int                     err = 0;
1037
1038         if (dch->debug & DEBUG_HW)
1039                 printk(KERN_DEBUG "%s: cmd:%x %p\n",
1040                     __func__, cmd, arg);
1041         switch (cmd) {
1042         case OPEN_CHANNEL:
1043                 rq = arg;
1044                 switch (rq->protocol) {
1045                 case ISDN_P_TE_S0:
1046                 case ISDN_P_NT_S0:
1047                         if (hc->pri) {
1048                                 err = -EINVAL;
1049                                 break;
1050                         }
1051                         err = open_dchannel(hc, dch, rq);
1052                         break;
1053                 case ISDN_P_TE_E1:
1054                 case ISDN_P_NT_E1:
1055                         if (!hc->pri) {
1056                                 err = -EINVAL;
1057                                 break;
1058                         }
1059                         err = open_dchannel(hc, dch, rq);
1060                         break;
1061                 default:
1062                         err = open_bchannel(hc, dch, rq);
1063                 }
1064                 break;
1065         case CLOSE_CHANNEL:
1066                 if (debug & DEBUG_HW_OPEN)
1067                         printk(KERN_DEBUG "%s: dev(%d) close from %p\n",
1068                             __func__, dch->dev.id,
1069                             __builtin_return_address(0));
1070                 module_put(THIS_MODULE);
1071                 break;
1072         case CONTROL_CHANNEL:
1073                 err = channel_dctrl(dch, arg);
1074                 break;
1075         default:
1076                 if (dch->debug & DEBUG_HW)
1077                         printk(KERN_DEBUG "%s: unknown command %x\n",
1078                             __func__, cmd);
1079                 err = -EINVAL;
1080         }
1081         return err;
1082 }
1083
1084 static int
1085 handle_bmsg(struct mISDNchannel *ch, struct sk_buff *skb)
1086 {
1087         struct bchannel         *bch = container_of(ch, struct bchannel, ch);
1088         struct l1oip                    *hc = bch->hw;
1089         int                     ret = -EINVAL;
1090         struct mISDNhead        *hh = mISDN_HEAD_P(skb);
1091         int                     l, ll, i;
1092         unsigned char           *p;
1093
1094         switch (hh->prim) {
1095         case PH_DATA_REQ:
1096                 if (skb->len <= 0) {
1097                         printk(KERN_WARNING "%s: skb too small\n",
1098                                 __func__);
1099                         break;
1100                 }
1101                 if (skb->len > MAX_DFRAME_LEN_L1 || skb->len > L1OIP_MAX_LEN) {
1102                         printk(KERN_WARNING "%s: skb too large\n",
1103                                 __func__);
1104                         break;
1105                 }
1106                 /* check for AIS / ulaw-silence */
1107                 p = skb->data;
1108                 l = skb->len;
1109                 for (i = 0; i < l; i++) {
1110                         if (*p++ != 0xff)
1111                                 break;
1112                 }
1113                 if (i == l) {
1114                         if (debug & DEBUG_L1OIP_MSG)
1115                                 printk(KERN_DEBUG "%s: got AIS, not sending, "
1116                                         "but counting\n", __func__);
1117                         hc->chan[bch->slot].tx_counter += l;
1118                         skb_trim(skb, 0);
1119                         queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1120                         return 0;
1121                 }
1122                 /* check for silence */
1123                 p = skb->data;
1124                 l = skb->len;
1125                 for (i = 0; i < l; i++) {
1126                         if (*p++ != 0x2a)
1127                                 break;
1128                 }
1129                 if (i == l) {
1130                         if (debug & DEBUG_L1OIP_MSG)
1131                                 printk(KERN_DEBUG "%s: got silence, not sending"
1132                                         ", but counting\n", __func__);
1133                         hc->chan[bch->slot].tx_counter += l;
1134                         skb_trim(skb, 0);
1135                         queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1136                         return 0;
1137                 }
1138
1139                 /* send frame */
1140                 p = skb->data;
1141                 l = skb->len;
1142                 while (l) {
1143                         ll = (l < L1OIP_MAX_PERFRAME)?l:L1OIP_MAX_PERFRAME;
1144                         l1oip_socket_send(hc, hc->codec, bch->slot, 0,
1145                                 hc->chan[bch->slot].tx_counter, p, ll);
1146                         hc->chan[bch->slot].tx_counter += ll;
1147                         p += ll;
1148                         l -= ll;
1149                 }
1150                 skb_trim(skb, 0);
1151                 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1152                 return 0;
1153         case PH_ACTIVATE_REQ:
1154                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
1155                         printk(KERN_DEBUG "%s: PH_ACTIVATE channel %d (1..%d)\n"
1156                                 , __func__, bch->slot, hc->b_num+1);
1157                 hc->chan[bch->slot].codecstate = 0;
1158                 test_and_set_bit(FLG_ACTIVE, &bch->Flags);
1159                 skb_trim(skb, 0);
1160                 queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
1161                 return 0;
1162         case PH_DEACTIVATE_REQ:
1163                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
1164                         printk(KERN_DEBUG "%s: PH_DEACTIVATE channel %d "
1165                                 "(1..%d)\n", __func__, bch->slot,
1166                                 hc->b_num+1);
1167                 test_and_clear_bit(FLG_ACTIVE, &bch->Flags);
1168                 skb_trim(skb, 0);
1169                 queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
1170                 return 0;
1171         }
1172         if (!ret)
1173                 dev_kfree_skb(skb);
1174         return ret;
1175 }
1176
1177 static int
1178 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
1179 {
1180         int                     ret = 0;
1181         struct dsp_features     *features =
1182                 (struct dsp_features *)(*((u_long *)&cq->p1));
1183
1184         switch (cq->op) {
1185         case MISDN_CTRL_GETOP:
1186                 cq->op = MISDN_CTRL_HW_FEATURES_OP;
1187                 break;
1188         case MISDN_CTRL_HW_FEATURES: /* fill features structure */
1189                 if (debug & DEBUG_L1OIP_MSG)
1190                         printk(KERN_DEBUG "%s: HW_FEATURE request\n",
1191                             __func__);
1192                 /* create confirm */
1193                 features->unclocked = 1;
1194                 features->unordered = 1;
1195                 break;
1196         default:
1197                 printk(KERN_WARNING "%s: unknown Op %x\n",
1198                     __func__, cq->op);
1199                 ret = -EINVAL;
1200                 break;
1201         }
1202         return ret;
1203 }
1204
1205 static int
1206 l1oip_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1207 {
1208         struct bchannel *bch = container_of(ch, struct bchannel, ch);
1209         int             err = -EINVAL;
1210
1211         if (bch->debug & DEBUG_HW)
1212                 printk(KERN_DEBUG "%s: cmd:%x %p\n",
1213                     __func__, cmd, arg);
1214         switch (cmd) {
1215         case CLOSE_CHANNEL:
1216                 test_and_clear_bit(FLG_OPEN, &bch->Flags);
1217                 test_and_clear_bit(FLG_ACTIVE, &bch->Flags);
1218                 ch->protocol = ISDN_P_NONE;
1219                 ch->peer = NULL;
1220                 module_put(THIS_MODULE);
1221                 err = 0;
1222                 break;
1223         case CONTROL_CHANNEL:
1224                 err = channel_bctrl(bch, arg);
1225                 break;
1226         default:
1227                 printk(KERN_WARNING "%s: unknown prim(%x)\n",
1228                         __func__, cmd);
1229         }
1230         return err;
1231 }
1232
1233
1234 /*
1235  * cleanup module and stack
1236  */
1237 static void
1238 release_card(struct l1oip *hc)
1239 {
1240         int     ch;
1241
1242         if (timer_pending(&hc->keep_tl))
1243                 del_timer(&hc->keep_tl);
1244
1245         if (timer_pending(&hc->timeout_tl))
1246                 del_timer(&hc->timeout_tl);
1247
1248         if (hc->socket_thread)
1249                 l1oip_socket_close(hc);
1250
1251         if (hc->registered && hc->chan[hc->d_idx].dch)
1252                 mISDN_unregister_device(&hc->chan[hc->d_idx].dch->dev);
1253         for (ch = 0; ch < 128; ch++) {
1254                 if (hc->chan[ch].dch) {
1255                         mISDN_freedchannel(hc->chan[ch].dch);
1256                         kfree(hc->chan[ch].dch);
1257                 }
1258                 if (hc->chan[ch].bch) {
1259                         mISDN_freebchannel(hc->chan[ch].bch);
1260                         kfree(hc->chan[ch].bch);
1261 #ifdef REORDER_DEBUG
1262                         if (hc->chan[ch].disorder_skb)
1263                                 dev_kfree_skb(hc->chan[ch].disorder_skb);
1264 #endif
1265                 }
1266         }
1267
1268         spin_lock(&l1oip_lock);
1269         list_del(&hc->list);
1270         spin_unlock(&l1oip_lock);
1271
1272         kfree(hc);
1273 }
1274
1275 static void
1276 l1oip_cleanup(void)
1277 {
1278         struct l1oip *hc, *next;
1279
1280         list_for_each_entry_safe(hc, next, &l1oip_ilist, list)
1281                 release_card(hc);
1282
1283         l1oip_4bit_free();
1284 }
1285
1286
1287 /*
1288  * module and stack init
1289  */
1290 static int
1291 init_card(struct l1oip *hc, int pri, int bundle)
1292 {
1293         struct dchannel *dch;
1294         struct bchannel *bch;
1295         int             ret;
1296         int             i, ch;
1297
1298         spin_lock_init(&hc->socket_lock);
1299         hc->idx = l1oip_cnt;
1300         hc->pri = pri;
1301         hc->d_idx = pri?16:3;
1302         hc->b_num = pri?30:2;
1303         hc->bundle = bundle;
1304         if (hc->pri)
1305                 sprintf(hc->name, "l1oip-e1.%d", l1oip_cnt + 1);
1306         else
1307                 sprintf(hc->name, "l1oip-s0.%d", l1oip_cnt + 1);
1308
1309         switch (codec[l1oip_cnt]) {
1310         case 0: /* as is */
1311         case 1: /* alaw */
1312         case 2: /* ulaw */
1313         case 3: /* 4bit */
1314                 break;
1315         default:
1316                 printk(KERN_ERR "Codec(%d) not supported.\n",
1317                         codec[l1oip_cnt]);
1318                 return -EINVAL;
1319         }
1320         hc->codec = codec[l1oip_cnt];
1321         if (debug & DEBUG_L1OIP_INIT)
1322                 printk(KERN_DEBUG "%s: using codec %d\n",
1323                         __func__, hc->codec);
1324
1325         if (id[l1oip_cnt] == 0) {
1326                 printk(KERN_WARNING "Warning: No 'id' value given or "
1327                         "0, this is highly unsecure. Please use 32 "
1328                         "bit randmom number 0x...\n");
1329         }
1330         hc->id = id[l1oip_cnt];
1331         if (debug & DEBUG_L1OIP_INIT)
1332                 printk(KERN_DEBUG "%s: using id 0x%x\n", __func__, hc->id);
1333
1334         hc->ondemand = ondemand[l1oip_cnt];
1335         if (hc->ondemand && !hc->id) {
1336                 printk(KERN_ERR "%s: ondemand option only allowed in "
1337                         "conjunction with non 0 ID\n", __func__);
1338                 return -EINVAL;
1339         }
1340
1341         if (limit[l1oip_cnt])
1342                 hc->b_num = limit[l1oip_cnt];
1343         if (!pri && hc->b_num > 2) {
1344                 printk(KERN_ERR "Maximum limit for BRI interface is 2 "
1345                         "channels.\n");
1346                 return -EINVAL;
1347         }
1348         if (pri && hc->b_num > 126) {
1349                 printk(KERN_ERR "Maximum limit for PRI interface is 126 "
1350                         "channels.\n");
1351                 return -EINVAL;
1352         }
1353         if (pri && hc->b_num > 30) {
1354                 printk(KERN_WARNING "Maximum limit for BRI interface is 30 "
1355                         "channels.\n");
1356                 printk(KERN_WARNING "Your selection of %d channels must be "
1357                         "supported by application.\n", hc->limit);
1358         }
1359
1360         hc->remoteip = ip[l1oip_cnt<<2] << 24
1361                      | ip[(l1oip_cnt<<2)+1] << 16
1362                      | ip[(l1oip_cnt<<2)+2] << 8
1363                      | ip[(l1oip_cnt<<2)+3];
1364         hc->localport = port[l1oip_cnt]?:(L1OIP_DEFAULTPORT+l1oip_cnt);
1365         if (remoteport[l1oip_cnt])
1366                 hc->remoteport = remoteport[l1oip_cnt];
1367         else
1368                 hc->remoteport = hc->localport;
1369         if (debug & DEBUG_L1OIP_INIT)
1370                 printk(KERN_DEBUG "%s: using local port %d remote ip "
1371                         "%d.%d.%d.%d port %d ondemand %d\n", __func__,
1372                         hc->localport, hc->remoteip >> 24,
1373                         (hc->remoteip >> 16) & 0xff,
1374                         (hc->remoteip >> 8) & 0xff, hc->remoteip & 0xff,
1375                         hc->remoteport, hc->ondemand);
1376
1377         dch = kzalloc(sizeof(struct dchannel), GFP_KERNEL);
1378         if (!dch)
1379                 return -ENOMEM;
1380         dch->debug = debug;
1381         mISDN_initdchannel(dch, MAX_DFRAME_LEN_L1, NULL);
1382         dch->hw = hc;
1383         if (pri)
1384                 dch->dev.Dprotocols = (1 << ISDN_P_TE_E1) | (1 << ISDN_P_NT_E1);
1385         else
1386                 dch->dev.Dprotocols = (1 << ISDN_P_TE_S0) | (1 << ISDN_P_NT_S0);
1387         dch->dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
1388             (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
1389         dch->dev.D.send = handle_dmsg;
1390         dch->dev.D.ctrl = l1oip_dctrl;
1391         dch->dev.nrbchan = hc->b_num;
1392         dch->slot = hc->d_idx;
1393         hc->chan[hc->d_idx].dch = dch;
1394         i = 1;
1395         for (ch = 0; ch < dch->dev.nrbchan; ch++) {
1396                 if (ch == 15)
1397                         i++;
1398                 bch = kzalloc(sizeof(struct bchannel), GFP_KERNEL);
1399                 if (!bch) {
1400                         printk(KERN_ERR "%s: no memory for bchannel\n",
1401                             __func__);
1402                         return -ENOMEM;
1403                 }
1404                 bch->nr = i + ch;
1405                 bch->slot = i + ch;
1406                 bch->debug = debug;
1407                 mISDN_initbchannel(bch, MAX_DATA_MEM);
1408                 bch->hw = hc;
1409                 bch->ch.send = handle_bmsg;
1410                 bch->ch.ctrl = l1oip_bctrl;
1411                 bch->ch.nr = i + ch;
1412                 list_add(&bch->ch.list, &dch->dev.bchannels);
1413                 hc->chan[i + ch].bch = bch;
1414                 set_channelmap(bch->nr, dch->dev.channelmap);
1415         }
1416         ret = mISDN_register_device(&dch->dev, hc->name);
1417         if (ret)
1418                 return ret;
1419         hc->registered = 1;
1420
1421         if (debug & DEBUG_L1OIP_INIT)
1422                 printk(KERN_DEBUG "%s: Setting up network card(%d)\n",
1423                         __func__, l1oip_cnt + 1);
1424         ret = l1oip_socket_open(hc);
1425         if (ret)
1426                 return ret;
1427
1428         hc->keep_tl.function = (void *)l1oip_keepalive;
1429         hc->keep_tl.data = (ulong)hc;
1430         init_timer(&hc->keep_tl);
1431         hc->keep_tl.expires = jiffies + 2*HZ; /* two seconds first time */
1432         add_timer(&hc->keep_tl);
1433
1434         hc->timeout_tl.function = (void *)l1oip_timeout;
1435         hc->timeout_tl.data = (ulong)hc;
1436         init_timer(&hc->timeout_tl);
1437         hc->timeout_on = 0; /* state that we have timer off */
1438
1439         return 0;
1440 }
1441
1442 static int __init
1443 l1oip_init(void)
1444 {
1445         int             pri, bundle;
1446         struct l1oip            *hc;
1447         int             ret;
1448
1449         printk(KERN_INFO "mISDN: Layer-1-over-IP driver Rev. %s\n",
1450                 l1oip_revision);
1451
1452         INIT_LIST_HEAD(&l1oip_ilist);
1453         spin_lock_init(&l1oip_lock);
1454
1455         if (l1oip_4bit_alloc(ulaw))
1456                 return -ENOMEM;
1457
1458         l1oip_cnt = 0;
1459         while (type[l1oip_cnt] && l1oip_cnt < MAX_CARDS) {
1460                 switch (type[l1oip_cnt] & 0xff) {
1461                 case 1:
1462                         pri = 0;
1463                         bundle = 0;
1464                         break;
1465                 case 2:
1466                         pri = 1;
1467                         bundle = 0;
1468                         break;
1469                 case 3:
1470                         pri = 0;
1471                         bundle = 1;
1472                         break;
1473                 case 4:
1474                         pri = 1;
1475                         bundle = 1;
1476                         break;
1477                 default:
1478                         printk(KERN_ERR "Card type(%d) not supported.\n",
1479                                 type[l1oip_cnt] & 0xff);
1480                         l1oip_cleanup();
1481                         return -EINVAL;
1482                 }
1483
1484                 if (debug & DEBUG_L1OIP_INIT)
1485                         printk(KERN_DEBUG "%s: interface %d is %s with %s.\n",
1486                                 __func__, l1oip_cnt, pri?"PRI":"BRI",
1487                                 bundle?"bundled IP packet for all B-channels"
1488                                  :"seperate IP packets for every B-channel");
1489
1490                 hc = kzalloc(sizeof(struct l1oip), GFP_ATOMIC);
1491                 if (!hc) {
1492                         printk(KERN_ERR "No kmem for L1-over-IP driver.\n");
1493                         l1oip_cleanup();
1494                         return -ENOMEM;
1495                 }
1496                 INIT_WORK(&hc->workq, (void *)l1oip_send_bh);
1497
1498                 spin_lock(&l1oip_lock);
1499                 list_add_tail(&hc->list, &l1oip_ilist);
1500                 spin_unlock(&l1oip_lock);
1501
1502                 ret = init_card(hc, pri, bundle);
1503                 if (ret) {
1504                         l1oip_cleanup();
1505                         return ret;
1506                 }
1507
1508                 l1oip_cnt++;
1509         }
1510         printk(KERN_INFO "%d virtual devices registered\n", l1oip_cnt);
1511         return 0;
1512 }
1513
1514 module_init(l1oip_init);
1515 module_exit(l1oip_cleanup);
1516