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