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