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 around 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 useful 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 <linux/slab.h>
 237 #include <net/sock.h>
 238 #include "core.h"
 239 #include "l1oip.h"
 240
 241 static const char *l1oip_revision = "2.00";
 242
 243 static int l1oip_cnt;
 244 static spinlock_t l1oip_lock;
 245 static struct list_head l1oip_ilist;
 246
 247 #define MAX_CARDS       16
 248 static u_int type[MAX_CARDS];
 249 static u_int codec[MAX_CARDS];
 250 static u_int ip[MAX_CARDS * 4];
 251 static u_int port[MAX_CARDS];
 252 static u_int remoteport[MAX_CARDS];
 253 static u_int ondemand[MAX_CARDS];
 254 static u_int limit[MAX_CARDS];
 255 static u_int id[MAX_CARDS];
 256 static int debug;
 257 static int ulaw;
 258
 259 MODULE_AUTHOR("Andreas Eversberg");
 260 MODULE_LICENSE("GPL");
 261 module_param_array(type, uint, NULL, S_IRUGO | S_IWUSR);
 262 module_param_array(codec, uint, NULL, S_IRUGO | S_IWUSR);
 263 module_param_array(ip, uint, NULL, S_IRUGO | S_IWUSR);
 264 module_param_array(port, uint, NULL, S_IRUGO | S_IWUSR);
 265 module_param_array(remoteport, uint, NULL, S_IRUGO | S_IWUSR);
 266 module_param_array(ondemand, uint, NULL, S_IRUGO | S_IWUSR);
 267 module_param_array(limit, uint, NULL, S_IRUGO | S_IWUSR);
 268 module_param_array(id, uint, NULL, S_IRUGO | S_IWUSR);
 269 module_param(ulaw, uint, S_IRUGO | S_IWUSR);
 270 module_param(debug, uint, S_IRUGO | S_IWUSR);
 271
 272 /*
 273  * send a frame via socket, if open and restart timer
 274  */
 275 static int
 276 l1oip_socket_send(struct l1oip *hc, u8 localcodec, u8 channel, u32 chanmask,
 277                   u16 timebase, u8 *buf, int len)
 278 {
 279         u8 *p;
 280         int multi = 0;
 281         u8 frame[len + 32];
 282         struct socket *socket = NULL;
 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         len = kernel_sendmsg(socket, &hc->sendmsg, &hc->sendiov, 1, len);
 356         /* give socket back */
 357         hc->socket = socket; /* no locking required */
 358
 359         return len;
 360 }
 361
 362
 363 /*
 364  * receive channel data from socket
 365  */
 366 static void
 367 l1oip_socket_recv(struct l1oip *hc, u8 remotecodec, u8 channel, u16 timebase,
 368                   u8 *buf, int len)
 369 {
 370         struct sk_buff *nskb;
 371         struct bchannel *bch;
 372         struct dchannel *dch;
 373         u8 *p;
 374         u32 rx_counter;
 375
 376         if (len == 0) {
 377                 if (debug & DEBUG_L1OIP_MSG)
 378                         printk(KERN_DEBUG "%s: received empty keepalive data, "
 379                                "ignoring\n", __func__);
 380                 return;
 381         }
 382
 383         if (debug & DEBUG_L1OIP_MSG)
 384                 printk(KERN_DEBUG "%s: received data, sending to mISDN (%d)\n",
 385                        __func__, len);
 386
 387         if (channel < 1 || channel > 127) {
 388                 printk(KERN_WARNING "%s: packet error - channel %d out of "
 389                        "range\n", __func__, channel);
 390                 return;
 391         }
 392         dch = hc->chan[channel].dch;
 393         bch = hc->chan[channel].bch;
 394         if (!dch && !bch) {
 395                 printk(KERN_WARNING "%s: packet error - channel %d not in "
 396                        "stack\n", __func__, channel);
 397                 return;
 398         }
 399
 400         /* prepare message */
 401         nskb = mI_alloc_skb((remotecodec == 3) ? (len << 1) : len, GFP_ATOMIC);
 402         if (!nskb) {
 403                 printk(KERN_ERR "%s: No mem for skb.\n", __func__);
 404                 return;
 405         }
 406         p = skb_put(nskb, (remotecodec == 3) ? (len << 1) : len);
 407
 408         if (remotecodec == 1 && ulaw)
 409                 l1oip_alaw_to_ulaw(buf, len, p);
 410         else if (remotecodec == 2 && !ulaw)
 411                 l1oip_ulaw_to_alaw(buf, len, p);
 412         else if (remotecodec == 3)
 413                 len = l1oip_4bit_to_law(buf, len, p);
 414         else
 415                 memcpy(p, buf, len);
 416
 417         /* send message up */
 418         if (dch && len >= 2) {
 419                 dch->rx_skb = nskb;
 420                 recv_Dchannel(dch);
 421         }
 422         if (bch) {
 423                 /* expand 16 bit sequence number to 32 bit sequence number */
 424                 rx_counter = hc->chan[channel].rx_counter;
 425                 if (((s16)(timebase - rx_counter)) >= 0) {
 426                         /* time has changed forward */
 427                         if (timebase >= (rx_counter & 0xffff))
 428                                 rx_counter =
 429                                         (rx_counter & 0xffff0000) | timebase;
 430                         else
 431                                 rx_counter = ((rx_counter & 0xffff0000) + 0x10000)
 432                                         | timebase;
 433                 } else {
 434                         /* time has changed backwards */
 435                         if (timebase < (rx_counter & 0xffff))
 436                                 rx_counter =
 437                                         (rx_counter & 0xffff0000) | timebase;
 438                         else
 439                                 rx_counter = ((rx_counter & 0xffff0000) - 0x10000)
 440                                         | timebase;
 441                 }
 442                 hc->chan[channel].rx_counter = rx_counter;
 443
 444 #ifdef REORDER_DEBUG
 445                 if (hc->chan[channel].disorder_flag) {
 446                         struct sk_buff *skb;
 447                         int cnt;
 448                         skb = hc->chan[channel].disorder_skb;
 449                         hc->chan[channel].disorder_skb = nskb;
 450                         nskb = skb;
 451                         cnt = hc->chan[channel].disorder_cnt;
 452                         hc->chan[channel].disorder_cnt = rx_counter;
 453                         rx_counter = cnt;
 454                 }
 455                 hc->chan[channel].disorder_flag ^= 1;
 456                 if (nskb)
 457 #endif
 458                         queue_ch_frame(&bch->ch, PH_DATA_IND, rx_counter, nskb);
 459         }
 460 }
 461
 462
 463 /*
 464  * parse frame and extract channel data
 465  */
 466 static void
 467 l1oip_socket_parse(struct l1oip *hc, struct sockaddr_in *sin, u8 *buf, int len)
 468 {
 469         u32                     packet_id;
 470         u8                      channel;
 471         u8                      remotecodec;
 472         u16                     timebase;
 473         int                     m, mlen;
 474         int                     len_start = len; /* initial frame length */
 475         struct dchannel         *dch = hc->chan[hc->d_idx].dch;
 476
 477         if (debug & DEBUG_L1OIP_MSG)
 478                 printk(KERN_DEBUG "%s: received frame, parsing... (%d)\n",
 479                        __func__, len);
 480
 481         /* check length */
 482         if (len < 1 + 1 + 2) {
 483                 printk(KERN_WARNING "%s: packet error - length %d below "
 484                        "4 bytes\n", __func__, len);
 485                 return;
 486         }
 487
 488         /* check version */
 489         if (((*buf) >> 6) != L1OIP_VERSION) {
 490                 printk(KERN_WARNING "%s: packet error - unknown version %d\n",
 491                        __func__, buf[0]>>6);
 492                 return;
 493         }
 494
 495         /* check type */
 496         if (((*buf) & 0x20) && !hc->pri) {
 497                 printk(KERN_WARNING "%s: packet error - received E1 packet "
 498                        "on S0 interface\n", __func__);
 499                 return;
 500         }
 501         if (!((*buf) & 0x20) && hc->pri) {
 502                 printk(KERN_WARNING "%s: packet error - received S0 packet "
 503                        "on E1 interface\n", __func__);
 504                 return;
 505         }
 506
 507         /* get id flag */
 508         packet_id = (*buf >> 4) & 1;
 509
 510         /* check coding */
 511         remotecodec = (*buf) & 0x0f;
 512         if (remotecodec > 3) {
 513                 printk(KERN_WARNING "%s: packet error - remotecodec %d "
 514                        "unsupported\n", __func__, remotecodec);
 515                 return;
 516         }
 517         buf++;
 518         len--;
 519
 520         /* check packet_id */
 521         if (packet_id) {
 522                 if (!hc->id) {
 523                         printk(KERN_WARNING "%s: packet error - packet has id "
 524                                "0x%x, but we have not\n", __func__, packet_id);
 525                         return;
 526                 }
 527                 if (len < 4) {
 528                         printk(KERN_WARNING "%s: packet error - packet too "
 529                                "short for ID value\n", __func__);
 530                         return;
 531                 }
 532                 packet_id = (*buf++) << 24;
 533                 packet_id += (*buf++) << 16;
 534                 packet_id += (*buf++) << 8;
 535                 packet_id += (*buf++);
 536                 len -= 4;
 537
 538                 if (packet_id != hc->id) {
 539                         printk(KERN_WARNING "%s: packet error - ID mismatch, "
 540                                "got 0x%x, we 0x%x\n",
 541                                __func__, packet_id, hc->id);
 542                         return;
 543                 }
 544         } else {
 545                 if (hc->id) {
 546                         printk(KERN_WARNING "%s: packet error - packet has no "
 547                                "ID, but we have\n", __func__);
 548                         return;
 549                 }
 550         }
 551
 552 multiframe:
 553         if (len < 1) {
 554                 printk(KERN_WARNING "%s: packet error - packet too short, "
 555                        "channel expected at position %d.\n",
 556                        __func__, len-len_start + 1);
 557                 return;
 558         }
 559
 560         /* get channel and multiframe flag */
 561         channel = *buf & 0x7f;
 562         m = *buf >> 7;
 563         buf++;
 564         len--;
 565
 566         /* check length on multiframe */
 567         if (m) {
 568                 if (len < 1) {
 569                         printk(KERN_WARNING "%s: packet error - packet too "
 570                                "short, length expected at position %d.\n",
 571                                __func__, len_start - len - 1);
 572                         return;
 573                 }
 574
 575                 mlen = *buf++;
 576                 len--;
 577                 if (mlen == 0)
 578                         mlen = 256;
 579                 if (len < mlen + 3) {
 580                         printk(KERN_WARNING "%s: packet error - length %d at "
 581                                "position %d exceeds total length %d.\n",
 582                                __func__, mlen, len_start-len - 1, len_start);
 583                         return;
 584                 }
 585                 if (len == mlen + 3) {
 586                         printk(KERN_WARNING "%s: packet error - length %d at "
 587                                "position %d will not allow additional "
 588                                "packet.\n",
 589                                __func__, mlen, len_start-len + 1);
 590                         return;
 591                 }
 592         } else
 593                 mlen = len - 2; /* single frame, subtract timebase */
 594
 595         if (len < 2) {
 596                 printk(KERN_WARNING "%s: packet error - packet too short, time "
 597                        "base expected at position %d.\n",
 598                        __func__, len-len_start + 1);
 599                 return;
 600         }
 601
 602         /* get time base */
 603         timebase = (*buf++) << 8;
 604         timebase |= (*buf++);
 605         len -= 2;
 606
 607         /* if inactive, we send up a PH_ACTIVATE and activate */
 608         if (!test_bit(FLG_ACTIVE, &dch->Flags)) {
 609                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 610                         printk(KERN_DEBUG "%s: interface become active due to "
 611                                "received packet\n", __func__);
 612                 test_and_set_bit(FLG_ACTIVE, &dch->Flags);
 613                 _queue_data(&dch->dev.D, PH_ACTIVATE_IND, MISDN_ID_ANY, 0,
 614                             NULL, GFP_ATOMIC);
 615         }
 616
 617         /* distribute packet */
 618         l1oip_socket_recv(hc, remotecodec, channel, timebase, buf, mlen);
 619         buf += mlen;
 620         len -= mlen;
 621
 622         /* multiframe */
 623         if (m)
 624                 goto multiframe;
 625
 626         /* restart timer */
 627         if ((int)(hc->timeout_tl.expires-jiffies) < 5 * HZ || !hc->timeout_on) {
 628                 hc->timeout_on = 1;
 629                 del_timer(&hc->timeout_tl);
 630                 hc->timeout_tl.expires = jiffies + L1OIP_TIMEOUT * HZ;
 631                 add_timer(&hc->timeout_tl);
 632         } else /* only adjust timer */
 633                 hc->timeout_tl.expires = jiffies + L1OIP_TIMEOUT * HZ;
 634
 635         /* if ip or source port changes */
 636         if ((hc->sin_remote.sin_addr.s_addr != sin->sin_addr.s_addr)
 637             || (hc->sin_remote.sin_port != sin->sin_port)) {
 638                 if (debug & DEBUG_L1OIP_SOCKET)
 639                         printk(KERN_DEBUG "%s: remote address changes from "
 640                                "0x%08x to 0x%08x (port %d to %d)\n", __func__,
 641                                ntohl(hc->sin_remote.sin_addr.s_addr),
 642                                ntohl(sin->sin_addr.s_addr),
 643                                ntohs(hc->sin_remote.sin_port),
 644                                ntohs(sin->sin_port));
 645                 hc->sin_remote.sin_addr.s_addr = sin->sin_addr.s_addr;
 646                 hc->sin_remote.sin_port = sin->sin_port;
 647         }
 648 }
 649
 650
 651 /*
 652  * socket stuff
 653  */
 654 static int
 655 l1oip_socket_thread(void *data)
 656 {
 657         struct l1oip *hc = (struct l1oip *)data;
 658         int ret = 0;
 659         struct msghdr msg;
 660         struct sockaddr_in sin_rx;
 661         unsigned char *recvbuf;
 662         size_t recvbuf_size = 1500;
 663         int recvlen;
 664         struct socket *socket = NULL;
 665         DECLARE_COMPLETION_ONSTACK(wait);
 666
 667         /* allocate buffer memory */
 668         recvbuf = kmalloc(recvbuf_size, GFP_KERNEL);
 669         if (!recvbuf) {
 670                 printk(KERN_ERR "%s: Failed to alloc recvbuf.\n", __func__);
 671                 ret = -ENOMEM;
 672                 goto fail;
 673         }
 674
 675         /* make daemon */
 676         allow_signal(SIGTERM);
 677
 678         /* create socket */
 679         if (sock_create(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &socket)) {
 680                 printk(KERN_ERR "%s: Failed to create socket.\n", __func__);
 681                 ret = -EIO;
 682                 goto fail;
 683         }
 684
 685         /* set incoming address */
 686         hc->sin_local.sin_family = AF_INET;
 687         hc->sin_local.sin_addr.s_addr = INADDR_ANY;
 688         hc->sin_local.sin_port = htons((unsigned short)hc->localport);
 689
 690         /* set outgoing address */
 691         hc->sin_remote.sin_family = AF_INET;
 692         hc->sin_remote.sin_addr.s_addr = htonl(hc->remoteip);
 693         hc->sin_remote.sin_port = htons((unsigned short)hc->remoteport);
 694
 695         /* bind to incoming port */
 696         if (socket->ops->bind(socket, (struct sockaddr *)&hc->sin_local,
 697                               sizeof(hc->sin_local))) {
 698                 printk(KERN_ERR "%s: Failed to bind socket to port %d.\n",
 699                        __func__, hc->localport);
 700                 ret = -EINVAL;
 701                 goto fail;
 702         }
 703
 704         /* check sk */
 705         if (socket->sk == NULL) {
 706                 printk(KERN_ERR "%s: socket->sk == NULL\n", __func__);
 707                 ret = -EIO;
 708                 goto fail;
 709         }
 710
 711         /* build receive message */
 712         msg.msg_name = &sin_rx;
 713         msg.msg_namelen = sizeof(sin_rx);
 714         msg.msg_control = NULL;
 715         msg.msg_controllen = 0;
 716
 717         /* build send message */
 718         hc->sendmsg.msg_name = &hc->sin_remote;
 719         hc->sendmsg.msg_namelen = sizeof(hc->sin_remote);
 720         hc->sendmsg.msg_control = NULL;
 721         hc->sendmsg.msg_controllen = 0;
 722
 723         /* give away socket */
 724         spin_lock(&hc->socket_lock);
 725         hc->socket = socket;
 726         spin_unlock(&hc->socket_lock);
 727
 728         /* read loop */
 729         if (debug & DEBUG_L1OIP_SOCKET)
 730                 printk(KERN_DEBUG "%s: socket created and open\n",
 731                        __func__);
 732         while (!signal_pending(current)) {
 733                 struct kvec iov = {
 734                         .iov_base = recvbuf,
 735                         .iov_len = recvbuf_size,
 736                 };
 737                 recvlen = kernel_recvmsg(socket, &msg, &iov, 1,
 738                                          recvbuf_size, 0);
 739                 if (recvlen > 0) {
 740                         l1oip_socket_parse(hc, &sin_rx, recvbuf, recvlen);
 741                 } else {
 742                         if (debug & DEBUG_L1OIP_SOCKET)
 743                                 printk(KERN_WARNING
 744                                        "%s: broken pipe on socket\n", __func__);
 745                 }
 746         }
 747
 748         /* get socket back, check first if in use, maybe by send function */
 749         spin_lock(&hc->socket_lock);
 750         /* if hc->socket is NULL, it is in use until it is given back */
 751         while (!hc->socket) {
 752                 spin_unlock(&hc->socket_lock);
 753                 schedule_timeout(HZ / 10);
 754                 spin_lock(&hc->socket_lock);
 755         }
 756         hc->socket = NULL;
 757         spin_unlock(&hc->socket_lock);
 758
 759         if (debug & DEBUG_L1OIP_SOCKET)
 760                 printk(KERN_DEBUG "%s: socket thread terminating\n",
 761                        __func__);
 762
 763 fail:
 764         /* free recvbuf */
 765         kfree(recvbuf);
 766
 767         /* close socket */
 768         if (socket)
 769                 sock_release(socket);
 770
 771         /* if we got killed, signal completion */
 772         complete(&hc->socket_complete);
 773         hc->socket_thread = NULL; /* show termination of thread */
 774
 775         if (debug & DEBUG_L1OIP_SOCKET)
 776                 printk(KERN_DEBUG "%s: socket thread terminated\n",
 777                        __func__);
 778         return ret;
 779 }
 780
 781 static void
 782 l1oip_socket_close(struct l1oip *hc)
 783 {
 784         struct dchannel *dch = hc->chan[hc->d_idx].dch;
 785
 786         /* kill thread */
 787         if (hc->socket_thread) {
 788                 if (debug & DEBUG_L1OIP_SOCKET)
 789                         printk(KERN_DEBUG "%s: socket thread exists, "
 790                                "killing...\n", __func__);
 791                 send_sig(SIGTERM, hc->socket_thread, 0);
 792                 wait_for_completion(&hc->socket_complete);
 793         }
 794
 795         /* if active, we send up a PH_DEACTIVATE and deactivate */
 796         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
 797                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 798                         printk(KERN_DEBUG "%s: interface become deactivated "
 799                                "due to timeout\n", __func__);
 800                 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
 801                 _queue_data(&dch->dev.D, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
 802                             NULL, GFP_ATOMIC);
 803         }
 804 }
 805
 806 static int
 807 l1oip_socket_open(struct l1oip *hc)
 808 {
 809         /* in case of reopen, we need to close first */
 810         l1oip_socket_close(hc);
 811
 812         init_completion(&hc->socket_complete);
 813
 814         /* create receive process */
 815         hc->socket_thread = kthread_run(l1oip_socket_thread, hc, "l1oip_%s",
 816                                         hc->name);
 817         if (IS_ERR(hc->socket_thread)) {
 818                 int err = PTR_ERR(hc->socket_thread);
 819                 printk(KERN_ERR "%s: Failed (%d) to create socket process.\n",
 820                        __func__, err);
 821                 hc->socket_thread = NULL;
 822                 sock_release(hc->socket);
 823                 return err;
 824         }
 825         if (debug & DEBUG_L1OIP_SOCKET)
 826                 printk(KERN_DEBUG "%s: socket thread created\n", __func__);
 827
 828         return 0;
 829 }
 830
 831
 832 static void
 833 l1oip_send_bh(struct work_struct *work)
 834 {
 835         struct l1oip *hc = container_of(work, struct l1oip, workq);
 836
 837         if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 838                 printk(KERN_DEBUG "%s: keepalive timer expired, sending empty "
 839                        "frame on dchannel\n", __func__);
 840
 841         /* send an empty l1oip frame at D-channel */
 842         l1oip_socket_send(hc, 0, hc->d_idx, 0, 0, NULL, 0);
 843 }
 844
 845
 846 /*
 847  * timer stuff
 848  */
 849 static void
 850 l1oip_keepalive(void *data)
 851 {
 852         struct l1oip *hc = (struct l1oip *)data;
 853
 854         schedule_work(&hc->workq);
 855 }
 856
 857 static void
 858 l1oip_timeout(void *data)
 859 {
 860         struct l1oip                    *hc = (struct l1oip *)data;
 861         struct dchannel         *dch = hc->chan[hc->d_idx].dch;
 862
 863         if (debug & DEBUG_L1OIP_MSG)
 864                 printk(KERN_DEBUG "%s: timeout timer expired, turn layer one "
 865                        "down.\n", __func__);
 866
 867         hc->timeout_on = 0; /* state that timer must be initialized next time */
 868
 869         /* if timeout, we send up a PH_DEACTIVATE and deactivate */
 870         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
 871                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 872                         printk(KERN_DEBUG "%s: interface become deactivated "
 873                                "due to timeout\n", __func__);
 874                 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
 875                 _queue_data(&dch->dev.D, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
 876                             NULL, GFP_ATOMIC);
 877         }
 878
 879         /* if we have ondemand set, we remove ip address */
 880         if (hc->ondemand) {
 881                 if (debug & DEBUG_L1OIP_MSG)
 882                         printk(KERN_DEBUG "%s: on demand causes ip address to "
 883                                "be removed\n", __func__);
 884                 hc->sin_remote.sin_addr.s_addr = 0;
 885         }
 886 }
 887
 888
 889 /*
 890  * message handling
 891  */
 892 static int
 893 handle_dmsg(struct mISDNchannel *ch, struct sk_buff *skb)
 894 {
 895         struct mISDNdevice      *dev = container_of(ch, struct mISDNdevice, D);
 896         struct dchannel         *dch = container_of(dev, struct dchannel, dev);
 897         struct l1oip                    *hc = dch->hw;
 898         struct mISDNhead        *hh = mISDN_HEAD_P(skb);
 899         int                     ret = -EINVAL;
 900         int                     l, ll;
 901         unsigned char           *p;
 902
 903         switch (hh->prim) {
 904         case PH_DATA_REQ:
 905                 if (skb->len < 1) {
 906                         printk(KERN_WARNING "%s: skb too small\n",
 907                                __func__);
 908                         break;
 909                 }
 910                 if (skb->len > MAX_DFRAME_LEN_L1 || skb->len > L1OIP_MAX_LEN) {
 911                         printk(KERN_WARNING "%s: skb too large\n",
 912                                __func__);
 913                         break;
 914                 }
 915                 /* send frame */
 916                 p = skb->data;
 917                 l = skb->len;
 918                 while (l) {
 919                         ll = (l < L1OIP_MAX_PERFRAME) ? l : L1OIP_MAX_PERFRAME;
 920                         l1oip_socket_send(hc, 0, dch->slot, 0,
 921                                           hc->chan[dch->slot].tx_counter++, p, ll);
 922                         p += ll;
 923                         l -= ll;
 924                 }
 925                 skb_trim(skb, 0);
 926                 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
 927                 return 0;
 928         case PH_ACTIVATE_REQ:
 929                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 930                         printk(KERN_DEBUG "%s: PH_ACTIVATE channel %d (1..%d)\n"
 931                                , __func__, dch->slot, hc->b_num + 1);
 932                 skb_trim(skb, 0);
 933                 if (test_bit(FLG_ACTIVE, &dch->Flags))
 934                         queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
 935                 else
 936                         queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
 937                 return 0;
 938         case PH_DEACTIVATE_REQ:
 939                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 940                         printk(KERN_DEBUG "%s: PH_DEACTIVATE channel %d "
 941                                "(1..%d)\n", __func__, dch->slot,
 942                                hc->b_num + 1);
 943                 skb_trim(skb, 0);
 944                 if (test_bit(FLG_ACTIVE, &dch->Flags))
 945                         queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
 946                 else
 947                         queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
 948                 return 0;
 949         }
 950         if (!ret)
 951                 dev_kfree_skb(skb);
 952         return ret;
 953 }
 954
 955 static int
 956 channel_dctrl(struct dchannel *dch, struct mISDN_ctrl_req *cq)
 957 {
 958         int     ret = 0;
 959         struct l1oip    *hc = dch->hw;
 960
 961         switch (cq->op) {
 962         case MISDN_CTRL_GETOP:
 963                 cq->op = MISDN_CTRL_SETPEER | MISDN_CTRL_UNSETPEER
 964                         | MISDN_CTRL_GETPEER;
 965                 break;
 966         case MISDN_CTRL_SETPEER:
 967                 hc->remoteip = (u32)cq->p1;
 968                 hc->remoteport = cq->p2 & 0xffff;
 969                 hc->localport = cq->p2 >> 16;
 970                 if (!hc->remoteport)
 971                         hc->remoteport = hc->localport;
 972                 if (debug & DEBUG_L1OIP_SOCKET)
 973                         printk(KERN_DEBUG "%s: got new ip address from user "
 974                                "space.\n", __func__);
 975                 l1oip_socket_open(hc);
 976                 break;
 977         case MISDN_CTRL_UNSETPEER:
 978                 if (debug & DEBUG_L1OIP_SOCKET)
 979                         printk(KERN_DEBUG "%s: removing ip address.\n",
 980                                __func__);
 981                 hc->remoteip = 0;
 982                 l1oip_socket_open(hc);
 983                 break;
 984         case MISDN_CTRL_GETPEER:
 985                 if (debug & DEBUG_L1OIP_SOCKET)
 986                         printk(KERN_DEBUG "%s: getting ip address.\n",
 987                                __func__);
 988                 cq->p1 = hc->remoteip;
 989                 cq->p2 = hc->remoteport | (hc->localport << 16);
 990                 break;
 991         default:
 992                 printk(KERN_WARNING "%s: unknown Op %x\n",
 993                        __func__, cq->op);
 994                 ret = -EINVAL;
 995                 break;
 996         }
 997         return ret;
 998 }
 999
1000 static int
1001 open_dchannel(struct l1oip *hc, struct dchannel *dch, struct channel_req *rq)
1002 {
1003         if (debug & DEBUG_HW_OPEN)
1004                 printk(KERN_DEBUG "%s: dev(%d) open from %p\n", __func__,
1005                        dch->dev.id, __builtin_return_address(0));
1006         if (rq->protocol == ISDN_P_NONE)
1007                 return -EINVAL;
1008         if ((dch->dev.D.protocol != ISDN_P_NONE) &&
1009             (dch->dev.D.protocol != rq->protocol)) {
1010                 if (debug & DEBUG_HW_OPEN)
1011                         printk(KERN_WARNING "%s: change protocol %x to %x\n",
1012                                __func__, dch->dev.D.protocol, rq->protocol);
1013         }
1014         if (dch->dev.D.protocol != rq->protocol)
1015                 dch->dev.D.protocol = rq->protocol;
1016
1017         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
1018                 _queue_data(&dch->dev.D, PH_ACTIVATE_IND, MISDN_ID_ANY,
1019                             0, NULL, GFP_KERNEL);
1020         }
1021         rq->ch = &dch->dev.D;
1022         if (!try_module_get(THIS_MODULE))
1023                 printk(KERN_WARNING "%s:cannot get module\n", __func__);
1024         return 0;
1025 }
1026
1027 static int
1028 open_bchannel(struct l1oip *hc, struct dchannel *dch, struct channel_req *rq)
1029 {
1030         struct bchannel *bch;
1031         int             ch;
1032
1033         if (!test_channelmap(rq->adr.channel, dch->dev.channelmap))
1034                 return -EINVAL;
1035         if (rq->protocol == ISDN_P_NONE)
1036                 return -EINVAL;
1037         ch = rq->adr.channel; /* BRI: 1=B1 2=B2  PRI: 1..15,17.. */
1038         bch = hc->chan[ch].bch;
1039         if (!bch) {
1040                 printk(KERN_ERR "%s:internal error ch %d has no bch\n",
1041                        __func__, ch);
1042                 return -EINVAL;
1043         }
1044         if (test_and_set_bit(FLG_OPEN, &bch->Flags))
1045                 return -EBUSY; /* b-channel can be only open once */
1046         bch->ch.protocol = rq->protocol;
1047         rq->ch = &bch->ch;
1048         if (!try_module_get(THIS_MODULE))
1049                 printk(KERN_WARNING "%s:cannot get module\n", __func__);
1050         return 0;
1051 }
1052
1053 static int
1054 l1oip_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1055 {
1056         struct mISDNdevice      *dev = container_of(ch, struct mISDNdevice, D);
1057         struct dchannel         *dch = container_of(dev, struct dchannel, dev);
1058         struct l1oip                    *hc = dch->hw;
1059         struct channel_req      *rq;
1060         int                     err = 0;
1061
1062         if (dch->debug & DEBUG_HW)
1063                 printk(KERN_DEBUG "%s: cmd:%x %p\n",
1064                        __func__, cmd, arg);
1065         switch (cmd) {
1066         case OPEN_CHANNEL:
1067                 rq = arg;
1068                 switch (rq->protocol) {
1069                 case ISDN_P_TE_S0:
1070                 case ISDN_P_NT_S0:
1071                         if (hc->pri) {
1072                                 err = -EINVAL;
1073                                 break;
1074                         }
1075                         err = open_dchannel(hc, dch, rq);
1076                         break;
1077                 case ISDN_P_TE_E1:
1078                 case ISDN_P_NT_E1:
1079                         if (!hc->pri) {
1080                                 err = -EINVAL;
1081                                 break;
1082                         }
1083                         err = open_dchannel(hc, dch, rq);
1084                         break;
1085                 default:
1086                         err = open_bchannel(hc, dch, rq);
1087                 }
1088                 break;
1089         case CLOSE_CHANNEL:
1090                 if (debug & DEBUG_HW_OPEN)
1091                         printk(KERN_DEBUG "%s: dev(%d) close from %p\n",
1092                                __func__, dch->dev.id,
1093                                __builtin_return_address(0));
1094                 module_put(THIS_MODULE);
1095                 break;
1096         case CONTROL_CHANNEL:
1097                 err = channel_dctrl(dch, arg);
1098                 break;
1099         default:
1100                 if (dch->debug & DEBUG_HW)
1101                         printk(KERN_DEBUG "%s: unknown command %x\n",
1102                                __func__, cmd);
1103                 err = -EINVAL;
1104         }
1105         return err;
1106 }
1107
1108 static int
1109 handle_bmsg(struct mISDNchannel *ch, struct sk_buff *skb)
1110 {
1111         struct bchannel         *bch = container_of(ch, struct bchannel, ch);
1112         struct l1oip                    *hc = bch->hw;
1113         int                     ret = -EINVAL;
1114         struct mISDNhead        *hh = mISDN_HEAD_P(skb);
1115         int                     l, ll;
1116         unsigned char           *p;
1117
1118         switch (hh->prim) {
1119         case PH_DATA_REQ:
1120                 if (skb->len <= 0) {
1121                         printk(KERN_WARNING "%s: skb too small\n",
1122                                __func__);
1123                         break;
1124                 }
1125                 if (skb->len > MAX_DFRAME_LEN_L1 || skb->len > L1OIP_MAX_LEN) {
1126                         printk(KERN_WARNING "%s: skb too large\n",
1127                                __func__);
1128                         break;
1129                 }
1130                 /* check for AIS / ulaw-silence */
1131                 l = skb->len;
1132                 if (!memchr_inv(skb->data, 0xff, l)) {
1133                         if (debug & DEBUG_L1OIP_MSG)
1134                                 printk(KERN_DEBUG "%s: got AIS, not sending, "
1135                                        "but counting\n", __func__);
1136                         hc->chan[bch->slot].tx_counter += l;
1137                         skb_trim(skb, 0);
1138                         queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1139                         return 0;
1140                 }
1141                 /* check for silence */
1142                 l = skb->len;
1143                 if (!memchr_inv(skb->data, 0x2a, l)) {
1144                         if (debug & DEBUG_L1OIP_MSG)
1145                                 printk(KERN_DEBUG "%s: got silence, not sending"
1146                                        ", but counting\n", __func__);
1147                         hc->chan[bch->slot].tx_counter += l;
1148                         skb_trim(skb, 0);
1149                         queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1150                         return 0;
1151                 }
1152
1153                 /* send frame */
1154                 p = skb->data;
1155                 l = skb->len;
1156                 while (l) {
1157                         ll = (l < L1OIP_MAX_PERFRAME) ? l : L1OIP_MAX_PERFRAME;
1158                         l1oip_socket_send(hc, hc->codec, bch->slot, 0,
1159                                           hc->chan[bch->slot].tx_counter, p, ll);
1160                         hc->chan[bch->slot].tx_counter += ll;
1161                         p += ll;
1162                         l -= ll;
1163                 }
1164                 skb_trim(skb, 0);
1165                 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1166                 return 0;
1167         case PH_ACTIVATE_REQ:
1168                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
1169                         printk(KERN_DEBUG "%s: PH_ACTIVATE channel %d (1..%d)\n"
1170                                , __func__, bch->slot, hc->b_num + 1);
1171                 hc->chan[bch->slot].codecstate = 0;
1172                 test_and_set_bit(FLG_ACTIVE, &bch->Flags);
1173                 skb_trim(skb, 0);
1174                 queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
1175                 return 0;
1176         case PH_DEACTIVATE_REQ:
1177                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
1178                         printk(KERN_DEBUG "%s: PH_DEACTIVATE channel %d "
1179                                "(1..%d)\n", __func__, bch->slot,
1180                                hc->b_num + 1);
1181                 test_and_clear_bit(FLG_ACTIVE, &bch->Flags);
1182                 skb_trim(skb, 0);
1183                 queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
1184                 return 0;
1185         }
1186         if (!ret)
1187                 dev_kfree_skb(skb);
1188         return ret;
1189 }
1190
1191 static int
1192 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
1193 {
1194         int                     ret = 0;
1195         struct dsp_features     *features =
1196                 (struct dsp_features *)(*((u_long *)&cq->p1));
1197
1198         switch (cq->op) {
1199         case MISDN_CTRL_GETOP:
1200                 cq->op = MISDN_CTRL_HW_FEATURES_OP;
1201                 break;
1202         case MISDN_CTRL_HW_FEATURES: /* fill features structure */
1203                 if (debug & DEBUG_L1OIP_MSG)
1204                         printk(KERN_DEBUG "%s: HW_FEATURE request\n",
1205                                __func__);
1206                 /* create confirm */
1207                 features->unclocked = 1;
1208                 features->unordered = 1;
1209                 break;
1210         default:
1211                 printk(KERN_WARNING "%s: unknown Op %x\n",
1212                        __func__, cq->op);
1213                 ret = -EINVAL;
1214                 break;
1215         }
1216         return ret;
1217 }
1218
1219 static int
1220 l1oip_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1221 {
1222         struct bchannel *bch = container_of(ch, struct bchannel, ch);
1223         int             err = -EINVAL;
1224
1225         if (bch->debug & DEBUG_HW)
1226                 printk(KERN_DEBUG "%s: cmd:%x %p\n",
1227                        __func__, cmd, arg);
1228         switch (cmd) {
1229         case CLOSE_CHANNEL:
1230                 test_and_clear_bit(FLG_OPEN, &bch->Flags);
1231                 test_and_clear_bit(FLG_ACTIVE, &bch->Flags);
1232                 ch->protocol = ISDN_P_NONE;
1233                 ch->peer = NULL;
1234                 module_put(THIS_MODULE);
1235                 err = 0;
1236                 break;
1237         case CONTROL_CHANNEL:
1238                 err = channel_bctrl(bch, arg);
1239                 break;
1240         default:
1241                 printk(KERN_WARNING "%s: unknown prim(%x)\n",
1242                        __func__, cmd);
1243         }
1244         return err;
1245 }
1246
1247
1248 /*
1249  * cleanup module and stack
1250  */
1251 static void
1252 release_card(struct l1oip *hc)
1253 {
1254         int     ch;
1255
1256         if (timer_pending(&hc->keep_tl))
1257                 del_timer(&hc->keep_tl);
1258
1259         if (timer_pending(&hc->timeout_tl))
1260                 del_timer(&hc->timeout_tl);
1261
1262         cancel_work_sync(&hc->workq);
1263
1264         if (hc->socket_thread)
1265                 l1oip_socket_close(hc);
1266
1267         if (hc->registered && hc->chan[hc->d_idx].dch)
1268                 mISDN_unregister_device(&hc->chan[hc->d_idx].dch->dev);
1269         for (ch = 0; ch < 128; ch++) {
1270                 if (hc->chan[ch].dch) {
1271                         mISDN_freedchannel(hc->chan[ch].dch);
1272                         kfree(hc->chan[ch].dch);
1273                 }
1274                 if (hc->chan[ch].bch) {
1275                         mISDN_freebchannel(hc->chan[ch].bch);
1276                         kfree(hc->chan[ch].bch);
1277 #ifdef REORDER_DEBUG
1278                         if (hc->chan[ch].disorder_skb)
1279                                 dev_kfree_skb(hc->chan[ch].disorder_skb);
1280 #endif
1281                 }
1282         }
1283
1284         spin_lock(&l1oip_lock);
1285         list_del(&hc->list);
1286         spin_unlock(&l1oip_lock);
1287
1288         kfree(hc);
1289 }
1290
1291 static void
1292 l1oip_cleanup(void)
1293 {
1294         struct l1oip *hc, *next;
1295
1296         list_for_each_entry_safe(hc, next, &l1oip_ilist, list)
1297                 release_card(hc);
1298
1299         l1oip_4bit_free();
1300 }
1301
1302
1303 /*
1304  * module and stack init
1305  */
1306 static int
1307 init_card(struct l1oip *hc, int pri, int bundle)
1308 {
1309         struct dchannel *dch;
1310         struct bchannel *bch;
1311         int             ret;
1312         int             i, ch;
1313
1314         spin_lock_init(&hc->socket_lock);
1315         hc->idx = l1oip_cnt;
1316         hc->pri = pri;
1317         hc->d_idx = pri ? 16 : 3;
1318         hc->b_num = pri ? 30 : 2;
1319         hc->bundle = bundle;
1320         if (hc->pri)
1321                 sprintf(hc->name, "l1oip-e1.%d", l1oip_cnt + 1);
1322         else
1323                 sprintf(hc->name, "l1oip-s0.%d", l1oip_cnt + 1);
1324
1325         switch (codec[l1oip_cnt]) {
1326         case 0: /* as is */
1327         case 1: /* alaw */
1328         case 2: /* ulaw */
1329         case 3: /* 4bit */
1330                 break;
1331         default:
1332                 printk(KERN_ERR "Codec(%d) not supported.\n",
1333                        codec[l1oip_cnt]);
1334                 return -EINVAL;
1335         }
1336         hc->codec = codec[l1oip_cnt];
1337         if (debug & DEBUG_L1OIP_INIT)
1338                 printk(KERN_DEBUG "%s: using codec %d\n",
1339                        __func__, hc->codec);
1340
1341         if (id[l1oip_cnt] == 0) {
1342                 printk(KERN_WARNING "Warning: No 'id' value given or "
1343                        "0, this is highly unsecure. Please use 32 "
1344                        "bit randmom number 0x...\n");
1345         }
1346         hc->id = id[l1oip_cnt];
1347         if (debug & DEBUG_L1OIP_INIT)
1348                 printk(KERN_DEBUG "%s: using id 0x%x\n", __func__, hc->id);
1349
1350         hc->ondemand = ondemand[l1oip_cnt];
1351         if (hc->ondemand && !hc->id) {
1352                 printk(KERN_ERR "%s: ondemand option only allowed in "
1353                        "conjunction with non 0 ID\n", __func__);
1354                 return -EINVAL;
1355         }
1356
1357         if (limit[l1oip_cnt])
1358                 hc->b_num = limit[l1oip_cnt];
1359         if (!pri && hc->b_num > 2) {
1360                 printk(KERN_ERR "Maximum limit for BRI interface is 2 "
1361                        "channels.\n");
1362                 return -EINVAL;
1363         }
1364         if (pri && hc->b_num > 126) {
1365                 printk(KERN_ERR "Maximum limit for PRI interface is 126 "
1366                        "channels.\n");
1367                 return -EINVAL;
1368         }
1369         if (pri && hc->b_num > 30) {
1370                 printk(KERN_WARNING "Maximum limit for BRI interface is 30 "
1371                        "channels.\n");
1372                 printk(KERN_WARNING "Your selection of %d channels must be "
1373                        "supported by application.\n", hc->limit);
1374         }
1375
1376         hc->remoteip = ip[l1oip_cnt << 2] << 24
1377                 | ip[(l1oip_cnt << 2) + 1] << 16
1378                 | ip[(l1oip_cnt << 2) + 2] << 8
1379                 | ip[(l1oip_cnt << 2) + 3];
1380         hc->localport = port[l1oip_cnt]?:(L1OIP_DEFAULTPORT + l1oip_cnt);
1381         if (remoteport[l1oip_cnt])
1382                 hc->remoteport = remoteport[l1oip_cnt];
1383         else
1384                 hc->remoteport = hc->localport;
1385         if (debug & DEBUG_L1OIP_INIT)
1386                 printk(KERN_DEBUG "%s: using local port %d remote ip "
1387                        "%d.%d.%d.%d port %d ondemand %d\n", __func__,
1388                        hc->localport, hc->remoteip >> 24,
1389                        (hc->remoteip >> 16) & 0xff,
1390                        (hc->remoteip >> 8) & 0xff, hc->remoteip & 0xff,
1391                        hc->remoteport, hc->ondemand);
1392
1393         dch = kzalloc(sizeof(struct dchannel), GFP_KERNEL);
1394         if (!dch)
1395                 return -ENOMEM;
1396         dch->debug = debug;
1397         mISDN_initdchannel(dch, MAX_DFRAME_LEN_L1, NULL);
1398         dch->hw = hc;
1399         if (pri)
1400                 dch->dev.Dprotocols = (1 << ISDN_P_TE_E1) | (1 << ISDN_P_NT_E1);
1401         else
1402                 dch->dev.Dprotocols = (1 << ISDN_P_TE_S0) | (1 << ISDN_P_NT_S0);
1403         dch->dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
1404                 (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
1405         dch->dev.D.send = handle_dmsg;
1406         dch->dev.D.ctrl = l1oip_dctrl;
1407         dch->dev.nrbchan = hc->b_num;
1408         dch->slot = hc->d_idx;
1409         hc->chan[hc->d_idx].dch = dch;
1410         i = 1;
1411         for (ch = 0; ch < dch->dev.nrbchan; ch++) {
1412                 if (ch == 15)
1413                         i++;
1414                 bch = kzalloc(sizeof(struct bchannel), GFP_KERNEL);
1415                 if (!bch) {
1416                         printk(KERN_ERR "%s: no memory for bchannel\n",
1417                                __func__);
1418                         return -ENOMEM;
1419                 }
1420                 bch->nr = i + ch;
1421                 bch->slot = i + ch;
1422                 bch->debug = debug;
1423                 mISDN_initbchannel(bch, MAX_DATA_MEM, 0);
1424                 bch->hw = hc;
1425                 bch->ch.send = handle_bmsg;
1426                 bch->ch.ctrl = l1oip_bctrl;
1427                 bch->ch.nr = i + ch;
1428                 list_add(&bch->ch.list, &dch->dev.bchannels);
1429                 hc->chan[i + ch].bch = bch;
1430                 set_channelmap(bch->nr, dch->dev.channelmap);
1431         }
1432         /* TODO: create a parent device for this driver */
1433         ret = mISDN_register_device(&dch->dev, NULL, hc->name);
1434         if (ret)
1435                 return ret;
1436         hc->registered = 1;
1437
1438         if (debug & DEBUG_L1OIP_INIT)
1439                 printk(KERN_DEBUG "%s: Setting up network card(%d)\n",
1440                        __func__, l1oip_cnt + 1);
1441         ret = l1oip_socket_open(hc);
1442         if (ret)
1443                 return ret;
1444
1445         hc->keep_tl.function = (void *)l1oip_keepalive;
1446         hc->keep_tl.data = (ulong)hc;
1447         init_timer(&hc->keep_tl);
1448         hc->keep_tl.expires = jiffies + 2 * HZ; /* two seconds first time */
1449         add_timer(&hc->keep_tl);
1450
1451         hc->timeout_tl.function = (void *)l1oip_timeout;
1452         hc->timeout_tl.data = (ulong)hc;
1453         init_timer(&hc->timeout_tl);
1454         hc->timeout_on = 0; /* state that we have timer off */
1455
1456         return 0;
1457 }
1458
1459 static int __init
1460 l1oip_init(void)
1461 {
1462         int             pri, bundle;
1463         struct l1oip            *hc;
1464         int             ret;
1465
1466         printk(KERN_INFO "mISDN: Layer-1-over-IP driver Rev. %s\n",
1467                l1oip_revision);
1468
1469         INIT_LIST_HEAD(&l1oip_ilist);
1470         spin_lock_init(&l1oip_lock);
1471
1472         if (l1oip_4bit_alloc(ulaw))
1473                 return -ENOMEM;
1474
1475         l1oip_cnt = 0;
1476         while (l1oip_cnt < MAX_CARDS && type[l1oip_cnt]) {
1477                 switch (type[l1oip_cnt] & 0xff) {
1478                 case 1:
1479                         pri = 0;
1480                         bundle = 0;
1481                         break;
1482                 case 2:
1483                         pri = 1;
1484                         bundle = 0;
1485                         break;
1486                 case 3:
1487                         pri = 0;
1488                         bundle = 1;
1489                         break;
1490                 case 4:
1491                         pri = 1;
1492                         bundle = 1;
1493                         break;
1494                 default:
1495                         printk(KERN_ERR "Card type(%d) not supported.\n",
1496                                type[l1oip_cnt] & 0xff);
1497                         l1oip_cleanup();
1498                         return -EINVAL;
1499                 }
1500
1501                 if (debug & DEBUG_L1OIP_INIT)
1502                         printk(KERN_DEBUG "%s: interface %d is %s with %s.\n",
1503                                __func__, l1oip_cnt, pri ? "PRI" : "BRI",
1504                                bundle ? "bundled IP packet for all B-channels" :
1505                                "separate IP packets for every B-channel");
1506
1507                 hc = kzalloc(sizeof(struct l1oip), GFP_ATOMIC);
1508                 if (!hc) {
1509                         printk(KERN_ERR "No kmem for L1-over-IP driver.\n");
1510                         l1oip_cleanup();
1511                         return -ENOMEM;
1512                 }
1513                 INIT_WORK(&hc->workq, (void *)l1oip_send_bh);
1514
1515                 spin_lock(&l1oip_lock);
1516                 list_add_tail(&hc->list, &l1oip_ilist);
1517                 spin_unlock(&l1oip_lock);
1518
1519                 ret = init_card(hc, pri, bundle);
1520                 if (ret) {
1521                         l1oip_cleanup();
1522                         return ret;
1523                 }
1524
1525                 l1oip_cnt++;
1526         }
1527         printk(KERN_INFO "%d virtual devices registered\n", l1oip_cnt);
1528         return 0;
1529 }
1530
1531 module_init(l1oip_init);
1532 module_exit(l1oip_cleanup);