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                     packet_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         packet_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 packet_id */
 524         if (packet_id) {
 525                 if (!hc->id) {
 526                         printk(KERN_WARNING "%s: packet error - packet has id "
 527                                 "0x%x, but we have not\n", __func__, packet_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                 packet_id = (*buf++) << 24;
 536                 packet_id += (*buf++) << 16;
 537                 packet_id += (*buf++) << 8;
 538                 packet_id += (*buf++);
 539                 len -= 4;
 540
 541                 if (packet_id != hc->id) {
 542                         printk(KERN_WARNING "%s: packet error - ID mismatch, "
 543                                 "got 0x%x, we 0x%x\n",
 544                                 __func__, packet_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         struct dchannel *dch = hc->chan[hc->d_idx].dch;
 781
 782         /* kill thread */
 783         if (hc->socket_thread) {
 784                 if (debug & DEBUG_L1OIP_SOCKET)
 785                         printk(KERN_DEBUG "%s: socket thread exists, "
 786                                 "killing...\n", __func__);
 787                 send_sig(SIGTERM, hc->socket_thread, 0);
 788                 wait_for_completion(&hc->socket_complete);
 789         }
 790
 791         /* if active, we send up a PH_DEACTIVATE and deactivate */
 792         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
 793                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
 794                         printk(KERN_DEBUG "%s: interface become deactivated "
 795                                 "due to timeout\n", __func__);
 796                 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
 797                 _queue_data(&dch->dev.D, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
 798                         NULL, GFP_ATOMIC);
 799         }
 800 }
 801
 802 static int
 803 l1oip_socket_open(struct l1oip *hc)
 804 {
 805         /* in case of reopen, we need to close first */
 806         l1oip_socket_close(hc);
 807
 808         init_completion(&hc->socket_complete);
 809
 810         /* create receive process */
 811         hc->socket_thread = kthread_run(l1oip_socket_thread, hc, "l1oip_%s",
 812                 hc->name);
 813         if (IS_ERR(hc->socket_thread)) {
 814                 int err = PTR_ERR(hc->socket_thread);
 815                 printk(KERN_ERR "%s: Failed (%d) to create socket process.\n",
 816                         __func__, err);
 817                 hc->socket_thread = NULL;
 818                 sock_release(hc->socket);
 819                 return err;
 820         }
 821         if (debug & DEBUG_L1OIP_SOCKET)
 822                 printk(KERN_DEBUG "%s: socket thread created\n", __func__);
 823
 824         return 0;
 825 }
 826
 827
 828 static void
 829 l1oip_send_bh(struct work_struct *work)
 830 {
 831         struct l1oip *hc = container_of(work, struct l1oip, workq);
 832
 833         if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
 834                 printk(KERN_DEBUG "%s: keepalive timer expired, sending empty "
 835                         "frame on dchannel\n", __func__);
 836
 837         /* send an empty l1oip frame at D-channel */
 838         l1oip_socket_send(hc, 0, hc->d_idx, 0, 0, NULL, 0);
 839 }
 840
 841
 842 /*
 843  * timer stuff
 844  */
 845 static void
 846 l1oip_keepalive(void *data)
 847 {
 848         struct l1oip *hc = (struct l1oip *)data;
 849
 850         schedule_work(&hc->workq);
 851 }
 852
 853 static void
 854 l1oip_timeout(void *data)
 855 {
 856         struct l1oip                    *hc = (struct l1oip *)data;
 857         struct dchannel         *dch = hc->chan[hc->d_idx].dch;
 858
 859         if (debug & DEBUG_L1OIP_MSG)
 860                 printk(KERN_DEBUG "%s: timeout timer expired, turn layer one "
 861                         "down.\n", __func__);
 862
 863         hc->timeout_on = 0; /* state that timer must be initialized next time */
 864
 865         /* if timeout, we send up a PH_DEACTIVATE and deactivate */
 866         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
 867                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
 868                         printk(KERN_DEBUG "%s: interface become deactivated "
 869                                 "due to timeout\n", __func__);
 870                 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
 871                 _queue_data(&dch->dev.D, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
 872                         NULL, GFP_ATOMIC);
 873         }
 874
 875         /* if we have ondemand set, we remove ip address */
 876         if (hc->ondemand) {
 877                 if (debug & DEBUG_L1OIP_MSG)
 878                         printk(KERN_DEBUG "%s: on demand causes ip address to "
 879                                 "be removed\n", __func__);
 880                 hc->sin_remote.sin_addr.s_addr = 0;
 881         }
 882 }
 883
 884
 885 /*
 886  * message handling
 887  */
 888 static int
 889 handle_dmsg(struct mISDNchannel *ch, struct sk_buff *skb)
 890 {
 891         struct mISDNdevice      *dev = container_of(ch, struct mISDNdevice, D);
 892         struct dchannel         *dch = container_of(dev, struct dchannel, dev);
 893         struct l1oip                    *hc = dch->hw;
 894         struct mISDNhead        *hh = mISDN_HEAD_P(skb);
 895         int                     ret = -EINVAL;
 896         int                     l, ll;
 897         unsigned char           *p;
 898
 899         switch (hh->prim) {
 900         case PH_DATA_REQ:
 901                 if (skb->len < 1) {
 902                         printk(KERN_WARNING "%s: skb too small\n",
 903                                 __func__);
 904                         break;
 905                 }
 906                 if (skb->len > MAX_DFRAME_LEN_L1 || skb->len > L1OIP_MAX_LEN) {
 907                         printk(KERN_WARNING "%s: skb too large\n",
 908                                 __func__);
 909                         break;
 910                 }
 911                 /* send frame */
 912                 p = skb->data;
 913                 l = skb->len;
 914                 while (l) {
 915                         ll = (l < L1OIP_MAX_PERFRAME)?l:L1OIP_MAX_PERFRAME;
 916                         l1oip_socket_send(hc, 0, dch->slot, 0,
 917                                 hc->chan[dch->slot].tx_counter++, p, ll);
 918                         p += ll;
 919                         l -= ll;
 920                 }
 921                 skb_trim(skb, 0);
 922                 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
 923                 return 0;
 924         case PH_ACTIVATE_REQ:
 925                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
 926                         printk(KERN_DEBUG "%s: PH_ACTIVATE channel %d (1..%d)\n"
 927                                 , __func__, dch->slot, hc->b_num+1);
 928                 skb_trim(skb, 0);
 929                 if (test_bit(FLG_ACTIVE, &dch->Flags))
 930                         queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
 931                 else
 932                         queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
 933                 return 0;
 934         case PH_DEACTIVATE_REQ:
 935                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
 936                         printk(KERN_DEBUG "%s: PH_DEACTIVATE channel %d "
 937                                 "(1..%d)\n", __func__, dch->slot,
 938                                 hc->b_num+1);
 939                 skb_trim(skb, 0);
 940                 if (test_bit(FLG_ACTIVE, &dch->Flags))
 941                         queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
 942                 else
 943                         queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
 944                 return 0;
 945         }
 946         if (!ret)
 947                 dev_kfree_skb(skb);
 948         return ret;
 949 }
 950
 951 static int
 952 channel_dctrl(struct dchannel *dch, struct mISDN_ctrl_req *cq)
 953 {
 954         int     ret = 0;
 955         struct l1oip    *hc = dch->hw;
 956
 957         switch (cq->op) {
 958         case MISDN_CTRL_GETOP:
 959                 cq->op = MISDN_CTRL_SETPEER | MISDN_CTRL_UNSETPEER
 960                         | MISDN_CTRL_GETPEER;
 961                 break;
 962         case MISDN_CTRL_SETPEER:
 963                 hc->remoteip = (u32)cq->p1;
 964                 hc->remoteport = cq->p2 & 0xffff;
 965                 hc->localport = cq->p2 >> 16;
 966                 if (!hc->remoteport)
 967                         hc->remoteport = hc->localport;
 968                 if (debug & DEBUG_L1OIP_SOCKET)
 969                         printk(KERN_DEBUG "%s: got new ip address from user "
 970                                 "space.\n", __func__);
 971                         l1oip_socket_open(hc);
 972                 break;
 973         case MISDN_CTRL_UNSETPEER:
 974                 if (debug & DEBUG_L1OIP_SOCKET)
 975                         printk(KERN_DEBUG "%s: removing ip address.\n",
 976                                 __func__);
 977                 hc->remoteip = 0;
 978                 l1oip_socket_open(hc);
 979                 break;
 980         case MISDN_CTRL_GETPEER:
 981                 if (debug & DEBUG_L1OIP_SOCKET)
 982                         printk(KERN_DEBUG "%s: getting ip address.\n",
 983                                 __func__);
 984                 cq->p1 = hc->remoteip;
 985                 cq->p2 = hc->remoteport | (hc->localport << 16);
 986                 break;
 987         default:
 988                 printk(KERN_WARNING "%s: unknown Op %x\n",
 989                     __func__, cq->op);
 990                 ret = -EINVAL;
 991                 break;
 992         }
 993         return ret;
 994 }
 995
 996 static int
 997 open_dchannel(struct l1oip *hc, struct dchannel *dch, struct channel_req *rq)
 998 {
 999         if (debug & DEBUG_HW_OPEN)
1000                 printk(KERN_DEBUG "%s: dev(%d) open from %p\n", __func__,
1001                     dch->dev.id, __builtin_return_address(0));
1002         if (rq->protocol == ISDN_P_NONE)
1003                 return -EINVAL;
1004         if ((dch->dev.D.protocol != ISDN_P_NONE) &&
1005             (dch->dev.D.protocol != rq->protocol)) {
1006                 if (debug & DEBUG_HW_OPEN)
1007                         printk(KERN_WARNING "%s: change protocol %x to %x\n",
1008                         __func__, dch->dev.D.protocol, rq->protocol);
1009         }
1010         if (dch->dev.D.protocol != rq->protocol)
1011                 dch->dev.D.protocol = rq->protocol;
1012
1013         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
1014                 _queue_data(&dch->dev.D, PH_ACTIVATE_IND, MISDN_ID_ANY,
1015                     0, NULL, GFP_KERNEL);
1016         }
1017         rq->ch = &dch->dev.D;
1018         if (!try_module_get(THIS_MODULE))
1019                 printk(KERN_WARNING "%s:cannot get module\n", __func__);
1020         return 0;
1021 }
1022
1023 static int
1024 open_bchannel(struct l1oip *hc, struct dchannel *dch, struct channel_req *rq)
1025 {
1026         struct bchannel *bch;
1027         int             ch;
1028
1029         if (!test_channelmap(rq->adr.channel, dch->dev.channelmap))
1030                 return -EINVAL;
1031         if (rq->protocol == ISDN_P_NONE)
1032                 return -EINVAL;
1033         ch = rq->adr.channel; /* BRI: 1=B1 2=B2  PRI: 1..15,17.. */
1034         bch = hc->chan[ch].bch;
1035         if (!bch) {
1036                 printk(KERN_ERR "%s:internal error ch %d has no bch\n",
1037                     __func__, ch);
1038                 return -EINVAL;
1039         }
1040         if (test_and_set_bit(FLG_OPEN, &bch->Flags))
1041                 return -EBUSY; /* b-channel can be only open once */
1042         bch->ch.protocol = rq->protocol;
1043         rq->ch = &bch->ch;
1044         if (!try_module_get(THIS_MODULE))
1045                 printk(KERN_WARNING "%s:cannot get module\n", __func__);
1046         return 0;
1047 }
1048
1049 static int
1050 l1oip_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1051 {
1052         struct mISDNdevice      *dev = container_of(ch, struct mISDNdevice, D);
1053         struct dchannel         *dch = container_of(dev, struct dchannel, dev);
1054         struct l1oip                    *hc = dch->hw;
1055         struct channel_req      *rq;
1056         int                     err = 0;
1057
1058         if (dch->debug & DEBUG_HW)
1059                 printk(KERN_DEBUG "%s: cmd:%x %p\n",
1060                     __func__, cmd, arg);
1061         switch (cmd) {
1062         case OPEN_CHANNEL:
1063                 rq = arg;
1064                 switch (rq->protocol) {
1065                 case ISDN_P_TE_S0:
1066                 case ISDN_P_NT_S0:
1067                         if (hc->pri) {
1068                                 err = -EINVAL;
1069                                 break;
1070                         }
1071                         err = open_dchannel(hc, dch, rq);
1072                         break;
1073                 case ISDN_P_TE_E1:
1074                 case ISDN_P_NT_E1:
1075                         if (!hc->pri) {
1076                                 err = -EINVAL;
1077                                 break;
1078                         }
1079                         err = open_dchannel(hc, dch, rq);
1080                         break;
1081                 default:
1082                         err = open_bchannel(hc, dch, rq);
1083                 }
1084                 break;
1085         case CLOSE_CHANNEL:
1086                 if (debug & DEBUG_HW_OPEN)
1087                         printk(KERN_DEBUG "%s: dev(%d) close from %p\n",
1088                             __func__, dch->dev.id,
1089                             __builtin_return_address(0));
1090                 module_put(THIS_MODULE);
1091                 break;
1092         case CONTROL_CHANNEL:
1093                 err = channel_dctrl(dch, arg);
1094                 break;
1095         default:
1096                 if (dch->debug & DEBUG_HW)
1097                         printk(KERN_DEBUG "%s: unknown command %x\n",
1098                             __func__, cmd);
1099                 err = -EINVAL;
1100         }
1101         return err;
1102 }
1103
1104 static int
1105 handle_bmsg(struct mISDNchannel *ch, struct sk_buff *skb)
1106 {
1107         struct bchannel         *bch = container_of(ch, struct bchannel, ch);
1108         struct l1oip                    *hc = bch->hw;
1109         int                     ret = -EINVAL;
1110         struct mISDNhead        *hh = mISDN_HEAD_P(skb);
1111         int                     l, ll, i;
1112         unsigned char           *p;
1113
1114         switch (hh->prim) {
1115         case PH_DATA_REQ:
1116                 if (skb->len <= 0) {
1117                         printk(KERN_WARNING "%s: skb too small\n",
1118                                 __func__);
1119                         break;
1120                 }
1121                 if (skb->len > MAX_DFRAME_LEN_L1 || skb->len > L1OIP_MAX_LEN) {
1122                         printk(KERN_WARNING "%s: skb too large\n",
1123                                 __func__);
1124                         break;
1125                 }
1126                 /* check for AIS / ulaw-silence */
1127                 p = skb->data;
1128                 l = skb->len;
1129                 for (i = 0; i < l; i++) {
1130                         if (*p++ != 0xff)
1131                                 break;
1132                 }
1133                 if (i == l) {
1134                         if (debug & DEBUG_L1OIP_MSG)
1135                                 printk(KERN_DEBUG "%s: got AIS, not sending, "
1136                                         "but counting\n", __func__);
1137                         hc->chan[bch->slot].tx_counter += l;
1138                         skb_trim(skb, 0);
1139                         queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1140                         return 0;
1141                 }
1142                 /* check for silence */
1143                 p = skb->data;
1144                 l = skb->len;
1145                 for (i = 0; i < l; i++) {
1146                         if (*p++ != 0x2a)
1147                                 break;
1148                 }
1149                 if (i == l) {
1150                         if (debug & DEBUG_L1OIP_MSG)
1151                                 printk(KERN_DEBUG "%s: got silence, not sending"
1152                                         ", but counting\n", __func__);
1153                         hc->chan[bch->slot].tx_counter += l;
1154                         skb_trim(skb, 0);
1155                         queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1156                         return 0;
1157                 }
1158
1159                 /* send frame */
1160                 p = skb->data;
1161                 l = skb->len;
1162                 while (l) {
1163                         ll = (l < L1OIP_MAX_PERFRAME)?l:L1OIP_MAX_PERFRAME;
1164                         l1oip_socket_send(hc, hc->codec, bch->slot, 0,
1165                                 hc->chan[bch->slot].tx_counter, p, ll);
1166                         hc->chan[bch->slot].tx_counter += ll;
1167                         p += ll;
1168                         l -= ll;
1169                 }
1170                 skb_trim(skb, 0);
1171                 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1172                 return 0;
1173         case PH_ACTIVATE_REQ:
1174                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
1175                         printk(KERN_DEBUG "%s: PH_ACTIVATE channel %d (1..%d)\n"
1176                                 , __func__, bch->slot, hc->b_num+1);
1177                 hc->chan[bch->slot].codecstate = 0;
1178                 test_and_set_bit(FLG_ACTIVE, &bch->Flags);
1179                 skb_trim(skb, 0);
1180                 queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
1181                 return 0;
1182         case PH_DEACTIVATE_REQ:
1183                 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
1184                         printk(KERN_DEBUG "%s: PH_DEACTIVATE channel %d "
1185                                 "(1..%d)\n", __func__, bch->slot,
1186                                 hc->b_num+1);
1187                 test_and_clear_bit(FLG_ACTIVE, &bch->Flags);
1188                 skb_trim(skb, 0);
1189                 queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
1190                 return 0;
1191         }
1192         if (!ret)
1193                 dev_kfree_skb(skb);
1194         return ret;
1195 }
1196
1197 static int
1198 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
1199 {
1200         int                     ret = 0;
1201         struct dsp_features     *features =
1202                 (struct dsp_features *)(*((u_long *)&cq->p1));
1203
1204         switch (cq->op) {
1205         case MISDN_CTRL_GETOP:
1206                 cq->op = MISDN_CTRL_HW_FEATURES_OP;
1207                 break;
1208         case MISDN_CTRL_HW_FEATURES: /* fill features structure */
1209                 if (debug & DEBUG_L1OIP_MSG)
1210                         printk(KERN_DEBUG "%s: HW_FEATURE request\n",
1211                             __func__);
1212                 /* create confirm */
1213                 features->unclocked = 1;
1214                 features->unordered = 1;
1215                 break;
1216         default:
1217                 printk(KERN_WARNING "%s: unknown Op %x\n",
1218                     __func__, cq->op);
1219                 ret = -EINVAL;
1220                 break;
1221         }
1222         return ret;
1223 }
1224
1225 static int
1226 l1oip_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1227 {
1228         struct bchannel *bch = container_of(ch, struct bchannel, ch);
1229         int             err = -EINVAL;
1230
1231         if (bch->debug & DEBUG_HW)
1232                 printk(KERN_DEBUG "%s: cmd:%x %p\n",
1233                     __func__, cmd, arg);
1234         switch (cmd) {
1235         case CLOSE_CHANNEL:
1236                 test_and_clear_bit(FLG_OPEN, &bch->Flags);
1237                 test_and_clear_bit(FLG_ACTIVE, &bch->Flags);
1238                 ch->protocol = ISDN_P_NONE;
1239                 ch->peer = NULL;
1240                 module_put(THIS_MODULE);
1241                 err = 0;
1242                 break;
1243         case CONTROL_CHANNEL:
1244                 err = channel_bctrl(bch, arg);
1245                 break;
1246         default:
1247                 printk(KERN_WARNING "%s: unknown prim(%x)\n",
1248                         __func__, cmd);
1249         }
1250         return err;
1251 }
1252
1253
1254 /*
1255  * cleanup module and stack
1256  */
1257 static void
1258 release_card(struct l1oip *hc)
1259 {
1260         int     ch;
1261
1262         if (timer_pending(&hc->keep_tl))
1263                 del_timer(&hc->keep_tl);
1264
1265         if (timer_pending(&hc->timeout_tl))
1266                 del_timer(&hc->timeout_tl);
1267
1268         if (hc->socket_thread)
1269                 l1oip_socket_close(hc);
1270
1271         if (hc->registered && hc->chan[hc->d_idx].dch)
1272                 mISDN_unregister_device(&hc->chan[hc->d_idx].dch->dev);
1273         for (ch = 0; ch < 128; ch++) {
1274                 if (hc->chan[ch].dch) {
1275                         mISDN_freedchannel(hc->chan[ch].dch);
1276                         kfree(hc->chan[ch].dch);
1277                 }
1278                 if (hc->chan[ch].bch) {
1279                         mISDN_freebchannel(hc->chan[ch].bch);
1280                         kfree(hc->chan[ch].bch);
1281 #ifdef REORDER_DEBUG
1282                         if (hc->chan[ch].disorder_skb)
1283                                 dev_kfree_skb(hc->chan[ch].disorder_skb);
1284 #endif
1285                 }
1286         }
1287
1288         spin_lock(&l1oip_lock);
1289         list_del(&hc->list);
1290         spin_unlock(&l1oip_lock);
1291
1292         kfree(hc);
1293 }
1294
1295 static void
1296 l1oip_cleanup(void)
1297 {
1298         struct l1oip *hc, *next;
1299
1300         list_for_each_entry_safe(hc, next, &l1oip_ilist, list)
1301                 release_card(hc);
1302
1303         l1oip_4bit_free();
1304 }
1305
1306
1307 /*
1308  * module and stack init
1309  */
1310 static int
1311 init_card(struct l1oip *hc, int pri, int bundle)
1312 {
1313         struct dchannel *dch;
1314         struct bchannel *bch;
1315         int             ret;
1316         int             i, ch;
1317
1318         spin_lock_init(&hc->socket_lock);
1319         hc->idx = l1oip_cnt;
1320         hc->pri = pri;
1321         hc->d_idx = pri?16:3;
1322         hc->b_num = pri?30:2;
1323         hc->bundle = bundle;
1324         if (hc->pri)
1325                 sprintf(hc->name, "l1oip-e1.%d", l1oip_cnt + 1);
1326         else
1327                 sprintf(hc->name, "l1oip-s0.%d", l1oip_cnt + 1);
1328
1329         switch (codec[l1oip_cnt]) {
1330         case 0: /* as is */
1331         case 1: /* alaw */
1332         case 2: /* ulaw */
1333         case 3: /* 4bit */
1334                 break;
1335         default:
1336                 printk(KERN_ERR "Codec(%d) not supported.\n",
1337                         codec[l1oip_cnt]);
1338                 return -EINVAL;
1339         }
1340         hc->codec = codec[l1oip_cnt];
1341         if (debug & DEBUG_L1OIP_INIT)
1342                 printk(KERN_DEBUG "%s: using codec %d\n",
1343                         __func__, hc->codec);
1344
1345         if (id[l1oip_cnt] == 0) {
1346                 printk(KERN_WARNING "Warning: No 'id' value given or "
1347                         "0, this is highly unsecure. Please use 32 "
1348                         "bit randmom number 0x...\n");
1349         }
1350         hc->id = id[l1oip_cnt];
1351         if (debug & DEBUG_L1OIP_INIT)
1352                 printk(KERN_DEBUG "%s: using id 0x%x\n", __func__, hc->id);
1353
1354         hc->ondemand = ondemand[l1oip_cnt];
1355         if (hc->ondemand && !hc->id) {
1356                 printk(KERN_ERR "%s: ondemand option only allowed in "
1357                         "conjunction with non 0 ID\n", __func__);
1358                 return -EINVAL;
1359         }
1360
1361         if (limit[l1oip_cnt])
1362                 hc->b_num = limit[l1oip_cnt];
1363         if (!pri && hc->b_num > 2) {
1364                 printk(KERN_ERR "Maximum limit for BRI interface is 2 "
1365                         "channels.\n");
1366                 return -EINVAL;
1367         }
1368         if (pri && hc->b_num > 126) {
1369                 printk(KERN_ERR "Maximum limit for PRI interface is 126 "
1370                         "channels.\n");
1371                 return -EINVAL;
1372         }
1373         if (pri && hc->b_num > 30) {
1374                 printk(KERN_WARNING "Maximum limit for BRI interface is 30 "
1375                         "channels.\n");
1376                 printk(KERN_WARNING "Your selection of %d channels must be "
1377                         "supported by application.\n", hc->limit);
1378         }
1379
1380         hc->remoteip = ip[l1oip_cnt<<2] << 24
1381                      | ip[(l1oip_cnt<<2)+1] << 16
1382                      | ip[(l1oip_cnt<<2)+2] << 8
1383                      | ip[(l1oip_cnt<<2)+3];
1384         hc->localport = port[l1oip_cnt]?:(L1OIP_DEFAULTPORT+l1oip_cnt);
1385         if (remoteport[l1oip_cnt])
1386                 hc->remoteport = remoteport[l1oip_cnt];
1387         else
1388                 hc->remoteport = hc->localport;
1389         if (debug & DEBUG_L1OIP_INIT)
1390                 printk(KERN_DEBUG "%s: using local port %d remote ip "
1391                         "%d.%d.%d.%d port %d ondemand %d\n", __func__,
1392                         hc->localport, hc->remoteip >> 24,
1393                         (hc->remoteip >> 16) & 0xff,
1394                         (hc->remoteip >> 8) & 0xff, hc->remoteip & 0xff,
1395                         hc->remoteport, hc->ondemand);
1396
1397         dch = kzalloc(sizeof(struct dchannel), GFP_KERNEL);
1398         if (!dch)
1399                 return -ENOMEM;
1400         dch->debug = debug;
1401         mISDN_initdchannel(dch, MAX_DFRAME_LEN_L1, NULL);
1402         dch->hw = hc;
1403         if (pri)
1404                 dch->dev.Dprotocols = (1 << ISDN_P_TE_E1) | (1 << ISDN_P_NT_E1);
1405         else
1406                 dch->dev.Dprotocols = (1 << ISDN_P_TE_S0) | (1 << ISDN_P_NT_S0);
1407         dch->dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
1408             (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
1409         dch->dev.D.send = handle_dmsg;
1410         dch->dev.D.ctrl = l1oip_dctrl;
1411         dch->dev.nrbchan = hc->b_num;
1412         dch->slot = hc->d_idx;
1413         hc->chan[hc->d_idx].dch = dch;
1414         i = 1;
1415         for (ch = 0; ch < dch->dev.nrbchan; ch++) {
1416                 if (ch == 15)
1417                         i++;
1418                 bch = kzalloc(sizeof(struct bchannel), GFP_KERNEL);
1419                 if (!bch) {
1420                         printk(KERN_ERR "%s: no memory for bchannel\n",
1421                             __func__);
1422                         return -ENOMEM;
1423                 }
1424                 bch->nr = i + ch;
1425                 bch->slot = i + ch;
1426                 bch->debug = debug;
1427                 mISDN_initbchannel(bch, MAX_DATA_MEM);
1428                 bch->hw = hc;
1429                 bch->ch.send = handle_bmsg;
1430                 bch->ch.ctrl = l1oip_bctrl;
1431                 bch->ch.nr = i + ch;
1432                 list_add(&bch->ch.list, &dch->dev.bchannels);
1433                 hc->chan[i + ch].bch = bch;
1434                 set_channelmap(bch->nr, dch->dev.channelmap);
1435         }
1436         /* TODO: create a parent device for this driver */
1437         ret = mISDN_register_device(&dch->dev, NULL, hc->name);
1438         if (ret)
1439                 return ret;
1440         hc->registered = 1;
1441
1442         if (debug & DEBUG_L1OIP_INIT)
1443                 printk(KERN_DEBUG "%s: Setting up network card(%d)\n",
1444                         __func__, l1oip_cnt + 1);
1445         ret = l1oip_socket_open(hc);
1446         if (ret)
1447                 return ret;
1448
1449         hc->keep_tl.function = (void *)l1oip_keepalive;
1450         hc->keep_tl.data = (ulong)hc;
1451         init_timer(&hc->keep_tl);
1452         hc->keep_tl.expires = jiffies + 2*HZ; /* two seconds first time */
1453         add_timer(&hc->keep_tl);
1454
1455         hc->timeout_tl.function = (void *)l1oip_timeout;
1456         hc->timeout_tl.data = (ulong)hc;
1457         init_timer(&hc->timeout_tl);
1458         hc->timeout_on = 0; /* state that we have timer off */
1459
1460         return 0;
1461 }
1462
1463 static int __init
1464 l1oip_init(void)
1465 {
1466         int             pri, bundle;
1467         struct l1oip            *hc;
1468         int             ret;
1469
1470         printk(KERN_INFO "mISDN: Layer-1-over-IP driver Rev. %s\n",
1471                 l1oip_revision);
1472
1473         INIT_LIST_HEAD(&l1oip_ilist);
1474         spin_lock_init(&l1oip_lock);
1475
1476         if (l1oip_4bit_alloc(ulaw))
1477                 return -ENOMEM;
1478
1479         l1oip_cnt = 0;
1480         while (type[l1oip_cnt] && l1oip_cnt < MAX_CARDS) {
1481                 switch (type[l1oip_cnt] & 0xff) {
1482                 case 1:
1483                         pri = 0;
1484                         bundle = 0;
1485                         break;
1486                 case 2:
1487                         pri = 1;
1488                         bundle = 0;
1489                         break;
1490                 case 3:
1491                         pri = 0;
1492                         bundle = 1;
1493                         break;
1494                 case 4:
1495                         pri = 1;
1496                         bundle = 1;
1497                         break;
1498                 default:
1499                         printk(KERN_ERR "Card type(%d) not supported.\n",
1500                                 type[l1oip_cnt] & 0xff);
1501                         l1oip_cleanup();
1502                         return -EINVAL;
1503                 }
1504
1505                 if (debug & DEBUG_L1OIP_INIT)
1506                         printk(KERN_DEBUG "%s: interface %d is %s with %s.\n",
1507                                 __func__, l1oip_cnt, pri?"PRI":"BRI",
1508                                 bundle?"bundled IP packet for all B-channels"
1509                                  :"seperate IP packets for every B-channel");
1510
1511                 hc = kzalloc(sizeof(struct l1oip), GFP_ATOMIC);
1512                 if (!hc) {
1513                         printk(KERN_ERR "No kmem for L1-over-IP driver.\n");
1514                         l1oip_cleanup();
1515                         return -ENOMEM;
1516                 }
1517                 INIT_WORK(&hc->workq, (void *)l1oip_send_bh);
1518
1519                 spin_lock(&l1oip_lock);
1520                 list_add_tail(&hc->list, &l1oip_ilist);
1521                 spin_unlock(&l1oip_lock);
1522
1523                 ret = init_card(hc, pri, bundle);
1524                 if (ret) {
1525                         l1oip_cleanup();
1526                         return ret;
1527                 }
1528
1529                 l1oip_cnt++;
1530         }
1531         printk(KERN_INFO "%d virtual devices registered\n", l1oip_cnt);
1532         return 0;
1533 }
1534
1535 module_init(l1oip_init);
1536 module_exit(l1oip_cleanup);
1537