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