drivers/isdn/mISDN/l1oip_core.c

   1 /*
   2
   3  * l1oip.c  low level driver for tunneling layer 1 over IP
   4  *
   5  * NOTE: It is not compatible with TDMoIP nor "ISDN over IP".
   6  *
   7  * Author       Andreas Eversberg (jolly@eversberg.eu)
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2, or (at your option)
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  */
  24
  25 /* module parameters:
  26  * type:
  27  Value 1        = BRI
  28  Value 2        = PRI
  29  Value 3 = BRI (multi channel frame, not supported yet)
  30  Value 4 = PRI (multi channel frame, not supported yet)
  31  A multi channel frame reduces overhead to a single frame for all
  32  b-channels, but increases delay.
  33  (NOTE: Multi channel frames are not implemented yet.)
  34
  35  * codec:
  36  Value 0 = transparent (default)
  37  Value 1 = transfer ALAW
  38  Value 2 = transfer ULAW
  39  Value 3 = transfer generic 4 bit compression.
  40
  41  * ulaw:
  42  0 = we use a-Law (default)
  43  1 = we use u-Law
  44
  45  * limit:
  46  limitation of B-channels to control bandwidth (1...126)
  47  BRI: 1 or 2
  48  PRI: 1-30, 31-126 (126, because dchannel ist not counted here)
  49  Also limited ressources are used for stack, resulting in less channels.
  50  It is possible to have more channels than 30 in PRI mode, this must
  51  be supported by the application.
  52
  53  * ip:
  54  byte representation of remote ip address (127.0.0.1 -> 127,0,0,1)
  55  If not given or four 0, no remote address is set.
  56  For multiple interfaces, concat ip addresses. (127,0,0,1,127,0,0,1)
  57
  58  * port:
  59  port number (local interface)
  60  If not given or 0, port 931 is used for fist instance, 932 for next...
  61  For multiple interfaces, different ports must be given.
  62
  63  * remoteport:
  64  port number (remote interface)
  65  If not given or 0, remote port equals local port
  66  For multiple interfaces on equal sites, different ports must be given.
  67
  68  * ondemand:
  69  0 = fixed (always transmit packets, even when remote side timed out)
  70  1 = on demand (only transmit packets, when remote side is detected)
  71  the default is 0
  72  NOTE: ID must also be set for on demand.
  73
  74  * id:
  75  optional value to identify frames. This value must be equal on both
  76  peers and should be random. If omitted or 0, no ID is transmitted.
  77
  78  * debug:
  79  NOTE: only one debug value must be given for all cards
  80  enable debugging (see l1oip.h for debug options)
  81
  82
  83  Special mISDN controls:
  84
  85  op = MISDN_CTRL_SETPEER*
  86  p1 = bytes 0-3 : remote IP address in network order (left element first)
  87  p2 = bytes 1-2 : remote port in network order (high byte first)
  88  optional:
  89  p2 = bytes 3-4 : local port in network order (high byte first)
  90
  91  op = MISDN_CTRL_UNSETPEER*
  92
  93  * Use l1oipctrl for comfortable setting or removing ip address.
  94  (Layer 1 Over IP CTRL)
  95
  96
  97  L1oIP-Protocol
  98  --------------
  99
 100  Frame Header:
 101
 102  7 6 5 4 3 2 1 0
 103  +---------------+
 104  |Ver|T|I|Coding |
 105  +---------------+
 106  |  ID byte 3 *  |
 107  +---------------+
 108  |  ID byte 2 *  |
 109  +---------------+
 110  |  ID byte 1 *  |
 111  +---------------+
 112  |  ID byte 0 *  |
 113  +---------------+
 114  |M|   Channel   |
 115  +---------------+
 116  |    Length *   |
 117  +---------------+
 118  | Time Base MSB |
 119  +---------------+
 120  | Time Base LSB |
 121  +---------------+
 122  | Data....     |
 123
 124  ...
 125
 126  |               |
 127  +---------------+
 128  |M|   Channel   |
 129  +---------------+
 130  |    Length *   |
 131  +---------------+
 132  | Time Base MSB |
 133  +---------------+
 134  | Time Base LSB |
 135  +---------------+
 136  | Data....     |
 137
 138  ...
 139
 140
 141  * Only included in some cases.
 142
 143  - Ver = Version
 144  If version is missmatch, the frame must be ignored.
 145
 146  - T = Type of interface
 147  Must be 0 for S0 or 1 for E1.
 148
 149  - I = Id present
 150  If bit is set, four ID bytes are included in frame.
 151
 152  - ID = Connection ID
 153  Additional ID to prevent Denial of Service attacs. Also it prevents hijacking
 154  connections with dynamic IP. The ID should be random and must not be 0.
 155
 156  - Coding = Type of codec
 157  Must be 0 for no transcoding. Also for D-channel and other HDLC frames.
 158  1 and 2 are reserved for explicitly use of a-LAW or u-LAW codec.
 159  3 is used for generic table compressor.
 160
 161  - M = More channels to come. If this flag is 1, the following byte contains
 162  the length of the channel data. After the data block, the next channel will
 163  be defined. The flag for the last channel block (or if only one channel is
 164  transmitted), must be 0 and no length is given.
 165
 166  - Channel = Channel number
 167  0 reserved
 168  1-3 channel data for S0 (3 is D-channel)
 169  1-31 channel data for E1 (16 is D-channel)
 170  32-127 channel data for extended E1 (16 is D-channel)
 171
 172  - The length is used if the M-flag is 1. It is used to find the next channel
 173  inside frame.
 174  NOTE: A value of 0 equals 256 bytes of data.
 175  -> For larger data blocks, a single frame must be used.
 176  -> For larger streams, a single frame or multiple blocks with same channel ID
 177  must be used.
 178
 179  - Time Base = Timestamp of first sample in frame
 180  The "Time Base" is used to rearange packets and to detect packet loss.
 181  The 16 bits are sent in network order (MSB first) and count 1/8000 th of a
 182  second. This causes a wrap around each 8,192 seconds. There is no requirement
 183  for the initial "Time Base", but 0 should be used for the first packet.
 184  In case of HDLC data, this timestamp counts the packet or byte number.
 185
 186
 187  Two Timers:
 188
 189  After initialisation, a timer of 15 seconds is started. Whenever a packet is
 190  transmitted, the timer is reset to 15 seconds again. If the timer expires, an
 191  empty packet is transmitted. This keep the connection alive.
 192
 193  When a valid packet is received, a timer 65 seconds is started. The interface
 194  become ACTIVE. If the timer expires, the interface becomes INACTIVE.
 195
 196
 197  Dynamic IP handling:
 198
 199  To allow dynamic IP, the ID must be non 0. In this case, any packet with the
 200  correct port number and ID will be accepted. If the remote side changes its IP
 201  the new IP is used for all transmitted packets until it changes again.
 202
 203
 204  On Demand:
 205
 206  If the ondemand parameter is given, the remote IP is set to 0 on timeout.
 207  This will stop keepalive traffic to remote. If the remote is online again,
 208  traffic will continue to the remote address. This is useful for road warriors.
 209  This feature only works with ID set, otherwhise it is highly unsecure.
 210
 211
 212  Socket and Thread
 213  -----------------
 214
 215  The complete socket opening and closing is done by a thread.
 216  When the thread opened a socket, the hc->socket descriptor is set. Whenever a
 217  packet shall be sent to the socket, the hc->socket must be checked wheter not
 218  NULL. To prevent change in socket descriptor, the hc->socket_lock must be used.
 219  To change the socket, a recall of l1oip_socket_open() will safely kill the
 220  socket process and create a new one.
 221
 222 */
 223
 224 #define L1OIP_VERSION   0       /* 0...3 */
 225
 226 #include <linux/module.h>
 227 #include <linux/delay.h>
 228 #include <linux/mISDNif.h>
 229 #include <linux/mISDNhw.h>
 230 #include <linux/mISDNdsp.h>
 231 #include <linux/init.h>
 232 #include <linux/in.h>
 233 #include <linux/inet.h>
 234 #include <linux/workqueue.h>
 235 #include <linux/kthread.h>
 236 #include <linux/slab.h>
 237 #include <linux/sched/signal.h>
 238
 239 #include <net/sock.h>
 240 #include "core.h"
 241 #include "l1oip.h"
 242
 243 static const char *l1oip_revision = "2.00";
 244
 245 static int l1oip_cnt;
 246 static spinlock_t l1oip_lock;
 247 static struct list_head l1oip_ilist;
 248
 249 #define MAX_CARDS       16
 250 static u_int type[MAX_CARDS];
 251 static u_int codec[MAX_CARDS];
 252 static u_int ip[MAX_CARDS * 4];
 253 static u_int port[MAX_CARDS];
 254 static u_int remoteport[MAX_CARDS];
 255 static u_int ondemand[MAX_CARDS];
 256 static u_int limit[MAX_CARDS];
 257 static u_int id[MAX_CARDS];
 258 static int debug;
 259 static int ulaw;
 260
 261 MODULE_AUTHOR("Andreas Eversberg");
 262 MODULE_LICENSE("GPL");
 263 module_param_array(type, uint, NULL, S_IRUGO | S_IWUSR);
 264 module_param_array(codec, uint, NULL, S_IRUGO | S_IWUSR);
 265 module_param_array(ip, uint, NULL, S_IRUGO | S_IWUSR);
 266 module_param_array(port, uint, NULL, S_IRUGO | S_IWUSR);
 267 module_param_array(remoteport, uint, NULL, S_IRUGO | S_IWUSR);
 268 module_param_array(ondemand, uint, NULL, S_IRUGO | S_IWUSR);
 269 module_param_array(limit, uint, NULL, S_IRUGO | S_IWUSR);
 270 module_param_array(id, uint, NULL, S_IRUGO | S_IWUSR);
 271 module_param(ulaw, uint, S_IRUGO | S_IWUSR);
 272 module_param(debug, uint, S_IRUGO | S_IWUSR);
 273
 274 /*
 275  * send a frame via socket, if open and restart timer
 276  */
 277 static int
 278 l1oip_socket_send(struct l1oip *hc, u8 localcodec, u8 channel, u32 chanmask,
 279                   u16 timebase, u8 *buf, int len)
 280 {
 281         u8 *p;
 282         u8 frame[MAX_DFRAME_LEN_L1 + 32];
 283         struct socket *socket = NULL;
 284
 285         if (debug & DEBUG_L1OIP_MSG)
 286                 printk(KERN_DEBUG "%s: sending data to socket (len = %d)\n",
 287                        __func__, len);
 288
 289         p = frame;
 290
 291         /* restart timer */
 292         if (time_before(hc->keep_tl.expires, jiffies + 5 * HZ))
 293                 mod_timer(&hc->keep_tl, jiffies + L1OIP_KEEPALIVE * HZ);
 294         else
 295                 hc->keep_tl.expires = jiffies + L1OIP_KEEPALIVE * HZ;
 296
 297         if (debug & DEBUG_L1OIP_MSG)
 298                 printk(KERN_DEBUG "%s: resetting timer\n", __func__);
 299
 300         /* drop if we have no remote ip or port */
 301         if (!hc->sin_remote.sin_addr.s_addr || !hc->sin_remote.sin_port) {
 302                 if (debug & DEBUG_L1OIP_MSG)
 303                         printk(KERN_DEBUG "%s: dropping frame, because remote "
 304                                "IP is not set.\n", __func__);
 305                 return len;
 306         }
 307
 308         /* assemble frame */
 309         *p++ = (L1OIP_VERSION << 6) /* version and coding */
 310                 | (hc->pri ? 0x20 : 0x00) /* type */
 311                 | (hc->id ? 0x10 : 0x00) /* id */
 312                 | localcodec;
 313         if (hc->id) {
 314                 *p++ = hc->id >> 24; /* id */
 315                 *p++ = hc->id >> 16;
 316                 *p++ = hc->id >> 8;
 317                 *p++ = hc->id;
 318         }
 319         *p++ =  0x00 + channel; /* m-flag, channel */
 320         *p++ = timebase >> 8; /* time base */
 321         *p++ = timebase;
 322
 323         if (buf && len) { /* add data to frame */
 324                 if (localcodec == 1 && ulaw)
 325                         l1oip_ulaw_to_alaw(buf, len, p);
 326                 else if (localcodec == 2 && !ulaw)
 327                         l1oip_alaw_to_ulaw(buf, len, p);
 328                 else if (localcodec == 3)
 329                         len = l1oip_law_to_4bit(buf, len, p,
 330                                                 &hc->chan[channel].codecstate);
 331                 else
 332                         memcpy(p, buf, len);
 333         }
 334         len += p - frame;
 335
 336         /* check for socket in safe condition */
 337         spin_lock(&hc->socket_lock);
 338         if (!hc->socket) {
 339                 spin_unlock(&hc->socket_lock);
 340                 return 0;
 341         }
 342         /* seize socket */
 343         socket = hc->socket;
 344         hc->socket = NULL;
 345         spin_unlock(&hc->socket_lock);
 346         /* send packet */
 347         if (debug & DEBUG_L1OIP_MSG)
 348                 printk(KERN_DEBUG "%s: sending packet to socket (len "
 349                        "= %d)\n", __func__, len);
 350         hc->sendiov.iov_base = frame;
 351         hc->sendiov.iov_len  = len;
 352         len = kernel_sendmsg(socket, &hc->sendmsg, &hc->sendiov, 1, len);
 353         /* give socket back */
 354         hc->socket = socket; /* no locking required */
 355
 356         return len;
 357 }
 358
 359
 360 /*
 361  * receive channel data from socket
 362  */
 363 static void
 364 l1oip_socket_recv(struct l1oip *hc, u8 remotecodec, u8 channel, u16 timebase,
 365                   u8 *buf, int len)
 366 {
 367         struct sk_buff *nskb;
 368         struct bchannel *bch;
 369         struct dchannel *dch;
 370         u8 *p;
 371         u32 rx_counter;
 372
 373         if (len == 0) {
 374                 if (debug & DEBUG_L1OIP_MSG)
 375                         printk(KERN_DEBUG "%s: received empty keepalive data, "
 376                                "ignoring\n", __func__);
 377                 return;
 378         }
 379
 380         if (debug & DEBUG_L1OIP_MSG)
 381                 printk(KERN_DEBUG "%s: received data, sending to mISDN (%d)\n",
 382                        __func__, len);
 383
 384         if (channel < 1 || channel > 127) {
 385                 printk(KERN_WARNING "%s: packet error - channel %d out of "
 386                        "range\n", __func__, channel);
 387                 return;
 388         }
 389         dch = hc->chan[channel].dch;
 390         bch = hc->chan[channel].bch;
 391         if (!dch && !bch) {
 392                 printk(KERN_WARNING "%s: packet error - channel %d not in "
 393                        "stack\n", __func__, channel);
 394                 return;
 395         }
 396
 397         /* prepare message */
 398         nskb = mI_alloc_skb((remotecodec == 3) ? (len << 1) : len, GFP_ATOMIC);
 399         if (!nskb) {
 400                 printk(KERN_ERR "%s: No mem for skb.\n", __func__);
 401                 return;
 402         }
 403         p = skb_put(nskb, (remotecodec == 3) ? (len << 1) : len);
 404
 405         if (remotecodec == 1 && ulaw)
 406                 l1oip_alaw_to_ulaw(buf, len, p);
 407         else if (remotecodec == 2 && !ulaw)
 408                 l1oip_ulaw_to_alaw(buf, len, p);
 409         else if (remotecodec == 3)
 410                 len = l1oip_4bit_to_law(buf, len, p);
 411         else
 412                 memcpy(p, buf, len);
 413
 414         /* send message up */
 415         if (dch && len >= 2) {
 416                 dch->rx_skb = nskb;
 417                 recv_Dchannel(dch);
 418         }
 419         if (bch) {
 420                 /* expand 16 bit sequence number to 32 bit sequence number */
 421                 rx_counter = hc->chan[channel].rx_counter;
 422                 if (((s16)(timebase - rx_counter)) >= 0) {
 423                         /* time has changed forward */
 424                         if (timebase >= (rx_counter & 0xffff))
 425                                 rx_counter =
 426                                         (rx_counter & 0xffff0000) | timebase;
 427                         else
 428                                 rx_counter = ((rx_counter & 0xffff0000) + 0x10000)
 429                                         | timebase;
 430                 } else {
 431                         /* time has changed backwards */
 432                         if (timebase < (rx_counter & 0xffff))
 433                                 rx_counter =
 434                                         (rx_counter & 0xffff0000) | timebase;
 435                         else
 436                                 rx_counter = ((rx_counter & 0xffff0000) - 0x10000)
 437                                         | timebase;
 438                 }
 439                 hc->chan[channel].rx_counter = rx_counter;
 440
 441 #ifdef REORDER_DEBUG
 442                 if (hc->chan[channel].disorder_flag) {
 443                         swap(hc->chan[channel].disorder_skb, nskb);
 444                         swap(hc->chan[channel].disorder_cnt, rx_counter);
 445                 }
 446                 hc->chan[channel].disorder_flag ^= 1;
 447                 if (nskb)
 448 #endif
 449                         queue_ch_frame(&bch->ch, PH_DATA_IND, rx_counter, nskb);
 450         }
 451 }
 452
 453
 454 /*
 455  * parse frame and extract channel data
 456  */
 457 static void
 458 l1oip_socket_parse(struct l1oip *hc, struct sockaddr_in *sin, u8 *buf, int len)
 459 {
 460         u32                     packet_id;
 461         u8                      channel;
 462         u8                      remotecodec;
 463         u16                     timebase;
 464         int                     m, mlen;
 465         int                     len_start = len; /* initial frame length */
 466         struct dchannel         *dch = hc->chan[hc->d_idx].dch;
 467
 468         if (debug & DEBUG_L1OIP_MSG)
 469                 printk(KERN_DEBUG "%s: received frame, parsing... (%d)\n",
 470                        __func__, len);
 471
 472         /* check length */
 473         if (len < 1 + 1 + 2) {
 474                 printk(KERN_WARNING "%s: packet error - length %d below "
 475                        "4 bytes\n", __func__, len);
 476                 return;
 477         }
 478
 479         /* check version */
 480         if (((*buf) >> 6) != L1OIP_VERSION) {
 481                 printk(KERN_WARNING "%s: packet error - unknown version %d\n",
 482                        __func__, buf[0]>>6);
 483                 return;
 484         }
 485
 486         /* check type */
 487         if (((*buf) & 0x20) && !hc->pri) {
 488                 printk(KERN_WARNING "%s: packet error - received E1 packet "
 489                        "on S0 interface\n", __func__);
 490                 return;
 491         }
 492         if (!((*buf) & 0x20) && hc->pri) {
 493                 printk(KERN_WARNING "%s: packet error - received S0 packet "
 494                        "on E1 interface\n", __func__);
 495                 return;
 496         }
 497
 498         /* get id flag */
 499         packet_id = (*buf >> 4) & 1;
 500
 501         /* check coding */
 502         remotecodec = (*buf) & 0x0f;
 503         if (remotecodec > 3) {
 504                 printk(KERN_WARNING "%s: packet error - remotecodec %d "
 505                        "unsupported\n", __func__, remotecodec);
 506                 return;
 507         }
 508         buf++;
 509         len--;
 510
 511         /* check packet_id */
 512         if (packet_id) {
 513                 if (!hc->id) {
 514                         printk(KERN_WARNING "%s: packet error - packet has id "
 515                                "0x%x, but we have not\n", __func__, packet_id);
 516                         return;
 517                 }
 518                 if (len < 4) {
 519                         printk(KERN_WARNING "%s: packet error - packet too "
 520                                "short for ID value\n", __func__);
 521                         return;
 522                 }
 523                 packet_id = (*buf++) << 24;
 524                 packet_id += (*buf++) << 16;
 525                 packet_id += (*buf++) << 8;
 526                 packet_id += (*buf++);
 527                 len -= 4;
 528
 529                 if (packet_id != hc->id) {
 530                         printk(KERN_WARNING "%s: packet error - ID mismatch, "
 531                                "got 0x%x, we 0x%x\n",
 532                                __func__, packet_id, hc->id);
 533                         return;
 534                 }
 535         } else {
 536                 if (hc->id) {
 537                         printk(KERN_WARNING "%s: packet error - packet has no "
 538                                "ID, but we have\n", __func__);
 539                         return;
 540                 }
 541         }
 542
 543 multiframe:
 544         if (len < 1) {
 545                 printk(KERN_WARNING "%s: packet error - packet too short, "
 546                        "channel expected at position %d.\n",
 547                        __func__, len-len_start + 1);
 548                 return;
 549         }
 550
 551         /* get channel and multiframe flag */
 552         channel = *buf & 0x7f;
 553         m = *buf >> 7;
 554         buf++;
 555         len--;
 556
 557         /* check length on multiframe */
 558         if (m) {
 559                 if (len < 1) {
 560                         printk(KERN_WARNING "%s: packet error - packet too "
 561                                "short, length expected at position %d.\n",
 562                                __func__, len_start - len - 1);
 563                         return;
 564                 }
 565
 566                 mlen = *buf++;
 567                 len--;
 568                 if (mlen == 0)
 569                         mlen = 256;
 570                 if (len < mlen + 3) {
 571                         printk(KERN_WARNING "%s: packet error - length %d at "
 572                                "position %d exceeds total length %d.\n",
 573                                __func__, mlen, len_start-len - 1, len_start);
 574                         return;
 575                 }
 576                 if (len == mlen + 3) {
 577                         printk(KERN_WARNING "%s: packet error - length %d at "
 578                                "position %d will not allow additional "
 579                                "packet.\n",
 580                                __func__, mlen, len_start-len + 1);
 581                         return;
 582                 }
 583         } else
 584                 mlen = len - 2; /* single frame, subtract timebase */
 585
 586         if (len < 2) {
 587                 printk(KERN_WARNING "%s: packet error - packet too short, time "
 588                        "base expected at position %d.\n",
 589                        __func__, len-len_start + 1);
 590                 return;
 591         }
 592
 593         /* get time base */
 594         timebase = (*buf++) << 8;
 595         timebase |= (*buf++);
 596         len -= 2;
 597
 598         /* if inactive, we send up a PH_ACTIVATE and activate */
 599         if (!test_bit(FLG_ACTIVE, &dch->Flags)) {
 600                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 601                         printk(KERN_DEBUG "%s: interface become active due to "
 602                                "received packet\n", __func__);
 603                 test_and_set_bit(FLG_ACTIVE, &dch->Flags);
 604                 _queue_data(&dch->dev.D, PH_ACTIVATE_IND, MISDN_ID_ANY, 0,
 605                             NULL, GFP_ATOMIC);
 606         }
 607
 608         /* distribute packet */
 609         l1oip_socket_recv(hc, remotecodec, channel, timebase, buf, mlen);
 610         buf += mlen;
 611         len -= mlen;
 612
 613         /* multiframe */
 614         if (m)
 615                 goto multiframe;
 616
 617         /* restart timer */
 618         if (time_before(hc->timeout_tl.expires, jiffies + 5 * HZ) || !hc->timeout_on) {
 619                 hc->timeout_on = 1;
 620                 mod_timer(&hc->timeout_tl, jiffies + L1OIP_TIMEOUT * HZ);
 621         } else /* only adjust timer */
 622                 hc->timeout_tl.expires = jiffies + L1OIP_TIMEOUT * HZ;
 623
 624         /* if ip or source port changes */
 625         if ((hc->sin_remote.sin_addr.s_addr != sin->sin_addr.s_addr)
 626             || (hc->sin_remote.sin_port != sin->sin_port)) {
 627                 if (debug & DEBUG_L1OIP_SOCKET)
 628                         printk(KERN_DEBUG "%s: remote address changes from "
 629                                "0x%08x to 0x%08x (port %d to %d)\n", __func__,
 630                                ntohl(hc->sin_remote.sin_addr.s_addr),
 631                                ntohl(sin->sin_addr.s_addr),
 632                                ntohs(hc->sin_remote.sin_port),
 633                                ntohs(sin->sin_port));
 634                 hc->sin_remote.sin_addr.s_addr = sin->sin_addr.s_addr;
 635                 hc->sin_remote.sin_port = sin->sin_port;
 636         }
 637 }
 638
 639
 640 /*
 641  * socket stuff
 642  */
 643 static int
 644 l1oip_socket_thread(void *data)
 645 {
 646         struct l1oip *hc = (struct l1oip *)data;
 647         int ret = 0;
 648         struct sockaddr_in sin_rx;
 649         struct kvec iov;
 650         struct msghdr msg = {.msg_name = &sin_rx,
 651                              .msg_namelen = sizeof(sin_rx)};
 652         unsigned char *recvbuf;
 653         size_t recvbuf_size = 1500;
 654         int recvlen;
 655         struct socket *socket = NULL;
 656         DECLARE_COMPLETION_ONSTACK(wait);
 657
 658         /* allocate buffer memory */
 659         recvbuf = kmalloc(recvbuf_size, GFP_KERNEL);
 660         if (!recvbuf) {
 661                 printk(KERN_ERR "%s: Failed to alloc recvbuf.\n", __func__);
 662                 ret = -ENOMEM;
 663                 goto fail;
 664         }
 665
 666         iov.iov_base = recvbuf;
 667         iov.iov_len = recvbuf_size;
 668
 669         /* make daemon */
 670         allow_signal(SIGTERM);
 671
 672         /* create socket */
 673         if (sock_create(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &socket)) {
 674                 printk(KERN_ERR "%s: Failed to create socket.\n", __func__);
 675                 ret = -EIO;
 676                 goto fail;
 677         }
 678
 679         /* set incoming address */
 680         hc->sin_local.sin_family = AF_INET;
 681         hc->sin_local.sin_addr.s_addr = INADDR_ANY;
 682         hc->sin_local.sin_port = htons((unsigned short)hc->localport);
 683
 684         /* set outgoing address */
 685         hc->sin_remote.sin_family = AF_INET;
 686         hc->sin_remote.sin_addr.s_addr = htonl(hc->remoteip);
 687         hc->sin_remote.sin_port = htons((unsigned short)hc->remoteport);
 688
 689         /* bind to incoming port */
 690         if (socket->ops->bind(socket, (struct sockaddr *)&hc->sin_local,
 691                               sizeof(hc->sin_local))) {
 692                 printk(KERN_ERR "%s: Failed to bind socket to port %d.\n",
 693                        __func__, hc->localport);
 694                 ret = -EINVAL;
 695                 goto fail;
 696         }
 697
 698         /* check sk */
 699         if (socket->sk == NULL) {
 700                 printk(KERN_ERR "%s: socket->sk == NULL\n", __func__);
 701                 ret = -EIO;
 702                 goto fail;
 703         }
 704
 705         /* build send message */
 706         hc->sendmsg.msg_name = &hc->sin_remote;
 707         hc->sendmsg.msg_namelen = sizeof(hc->sin_remote);
 708         hc->sendmsg.msg_control = NULL;
 709         hc->sendmsg.msg_controllen = 0;
 710
 711         /* give away socket */
 712         spin_lock(&hc->socket_lock);
 713         hc->socket = socket;
 714         spin_unlock(&hc->socket_lock);
 715
 716         /* read loop */
 717         if (debug & DEBUG_L1OIP_SOCKET)
 718                 printk(KERN_DEBUG "%s: socket created and open\n",
 719                        __func__);
 720         while (!signal_pending(current)) {
 721                 iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &iov, 1,
 722                                 recvbuf_size);
 723                 recvlen = sock_recvmsg(socket, &msg, 0);
 724                 if (recvlen > 0) {
 725                         l1oip_socket_parse(hc, &sin_rx, recvbuf, recvlen);
 726                 } else {
 727                         if (debug & DEBUG_L1OIP_SOCKET)
 728                                 printk(KERN_WARNING
 729                                        "%s: broken pipe on socket\n", __func__);
 730                 }
 731         }
 732
 733         /* get socket back, check first if in use, maybe by send function */
 734         spin_lock(&hc->socket_lock);
 735         /* if hc->socket is NULL, it is in use until it is given back */
 736         while (!hc->socket) {
 737                 spin_unlock(&hc->socket_lock);
 738                 schedule_timeout(HZ / 10);
 739                 spin_lock(&hc->socket_lock);
 740         }
 741         hc->socket = NULL;
 742         spin_unlock(&hc->socket_lock);
 743
 744         if (debug & DEBUG_L1OIP_SOCKET)
 745                 printk(KERN_DEBUG "%s: socket thread terminating\n",
 746                        __func__);
 747
 748 fail:
 749         /* free recvbuf */
 750         kfree(recvbuf);
 751
 752         /* close socket */
 753         if (socket)
 754                 sock_release(socket);
 755
 756         /* if we got killed, signal completion */
 757         complete(&hc->socket_complete);
 758         hc->socket_thread = NULL; /* show termination of thread */
 759
 760         if (debug & DEBUG_L1OIP_SOCKET)
 761                 printk(KERN_DEBUG "%s: socket thread terminated\n",
 762                        __func__);
 763         return ret;
 764 }
 765
 766 static void
 767 l1oip_socket_close(struct l1oip *hc)
 768 {
 769         struct dchannel *dch = hc->chan[hc->d_idx].dch;
 770
 771         /* kill thread */
 772         if (hc->socket_thread) {
 773                 if (debug & DEBUG_L1OIP_SOCKET)
 774                         printk(KERN_DEBUG "%s: socket thread exists, "
 775                                "killing...\n", __func__);
 776                 send_sig(SIGTERM, hc->socket_thread, 0);
 777                 wait_for_completion(&hc->socket_complete);
 778         }
 779
 780         /* if active, we send up a PH_DEACTIVATE and deactivate */
 781         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
 782                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 783                         printk(KERN_DEBUG "%s: interface become deactivated "
 784                                "due to timeout\n", __func__);
 785                 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
 786                 _queue_data(&dch->dev.D, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
 787                             NULL, GFP_ATOMIC);
 788         }
 789 }
 790
 791 static int
 792 l1oip_socket_open(struct l1oip *hc)
 793 {
 794         /* in case of reopen, we need to close first */
 795         l1oip_socket_close(hc);
 796
 797         init_completion(&hc->socket_complete);
 798
 799         /* create receive process */
 800         hc->socket_thread = kthread_run(l1oip_socket_thread, hc, "l1oip_%s",
 801                                         hc->name);
 802         if (IS_ERR(hc->socket_thread)) {
 803                 int err = PTR_ERR(hc->socket_thread);
 804                 printk(KERN_ERR "%s: Failed (%d) to create socket process.\n",
 805                        __func__, err);
 806                 hc->socket_thread = NULL;
 807                 sock_release(hc->socket);
 808                 return err;
 809         }
 810         if (debug & DEBUG_L1OIP_SOCKET)
 811                 printk(KERN_DEBUG "%s: socket thread created\n", __func__);
 812
 813         return 0;
 814 }
 815
 816
 817 static void
 818 l1oip_send_bh(struct work_struct *work)
 819 {
 820         struct l1oip *hc = container_of(work, struct l1oip, workq);
 821
 822         if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 823                 printk(KERN_DEBUG "%s: keepalive timer expired, sending empty "
 824                        "frame on dchannel\n", __func__);
 825
 826         /* send an empty l1oip frame at D-channel */
 827         l1oip_socket_send(hc, 0, hc->d_idx, 0, 0, NULL, 0);
 828 }
 829
 830
 831 /*
 832  * timer stuff
 833  */
 834 static void
 835 l1oip_keepalive(struct timer_list *t)
 836 {
 837         struct l1oip *hc = from_timer(hc, t, keep_tl);
 838
 839         schedule_work(&hc->workq);
 840 }
 841
 842 static void
 843 l1oip_timeout(struct timer_list *t)
 844 {
 845         struct l1oip                    *hc = from_timer(hc, t,
 846                                                                   timeout_tl);
 847         struct dchannel         *dch = hc->chan[hc->d_idx].dch;
 848
 849         if (debug & DEBUG_L1OIP_MSG)
 850                 printk(KERN_DEBUG "%s: timeout timer expired, turn layer one "
 851                        "down.\n", __func__);
 852
 853         hc->timeout_on = 0; /* state that timer must be initialized next time */
 854
 855         /* if timeout, we send up a PH_DEACTIVATE and deactivate */
 856         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
 857                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 858                         printk(KERN_DEBUG "%s: interface become deactivated "
 859                                "due to timeout\n", __func__);
 860                 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
 861                 _queue_data(&dch->dev.D, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
 862                             NULL, GFP_ATOMIC);
 863         }
 864
 865         /* if we have ondemand set, we remove ip address */
 866         if (hc->ondemand) {
 867                 if (debug & DEBUG_L1OIP_MSG)
 868                         printk(KERN_DEBUG "%s: on demand causes ip address to "
 869                                "be removed\n", __func__);
 870                 hc->sin_remote.sin_addr.s_addr = 0;
 871         }
 872 }
 873
 874
 875 /*
 876  * message handling
 877  */
 878 static int
 879 handle_dmsg(struct mISDNchannel *ch, struct sk_buff *skb)
 880 {
 881         struct mISDNdevice      *dev = container_of(ch, struct mISDNdevice, D);
 882         struct dchannel         *dch = container_of(dev, struct dchannel, dev);
 883         struct l1oip                    *hc = dch->hw;
 884         struct mISDNhead        *hh = mISDN_HEAD_P(skb);
 885         int                     ret = -EINVAL;
 886         int                     l, ll;
 887         unsigned char           *p;
 888
 889         switch (hh->prim) {
 890         case PH_DATA_REQ:
 891                 if (skb->len < 1) {
 892                         printk(KERN_WARNING "%s: skb too small\n",
 893                                __func__);
 894                         break;
 895                 }
 896                 if (skb->len > MAX_DFRAME_LEN_L1 || skb->len > L1OIP_MAX_LEN) {
 897                         printk(KERN_WARNING "%s: skb too large\n",
 898                                __func__);
 899                         break;
 900                 }
 901                 /* send frame */
 902                 p = skb->data;
 903                 l = skb->len;
 904                 while (l) {
 905                         /*
 906                          * This is technically bounded by L1OIP_MAX_PERFRAME but
 907                          * MAX_DFRAME_LEN_L1 < L1OIP_MAX_PERFRAME
 908                          */
 909                         ll = (l < MAX_DFRAME_LEN_L1) ? l : MAX_DFRAME_LEN_L1;
 910                         l1oip_socket_send(hc, 0, dch->slot, 0,
 911                                           hc->chan[dch->slot].tx_counter++, p, ll);
 912                         p += ll;
 913                         l -= ll;
 914                 }
 915                 skb_trim(skb, 0);
 916                 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
 917                 return 0;
 918         case PH_ACTIVATE_REQ:
 919                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 920                         printk(KERN_DEBUG "%s: PH_ACTIVATE channel %d (1..%d)\n"
 921                                , __func__, dch->slot, hc->b_num + 1);
 922                 skb_trim(skb, 0);
 923                 if (test_bit(FLG_ACTIVE, &dch->Flags))
 924                         queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
 925                 else
 926                         queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
 927                 return 0;
 928         case PH_DEACTIVATE_REQ:
 929                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
 930                         printk(KERN_DEBUG "%s: PH_DEACTIVATE channel %d "
 931                                "(1..%d)\n", __func__, dch->slot,
 932                                hc->b_num + 1);
 933                 skb_trim(skb, 0);
 934                 if (test_bit(FLG_ACTIVE, &dch->Flags))
 935                         queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
 936                 else
 937                         queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
 938                 return 0;
 939         }
 940         if (!ret)
 941                 dev_kfree_skb(skb);
 942         return ret;
 943 }
 944
 945 static int
 946 channel_dctrl(struct dchannel *dch, struct mISDN_ctrl_req *cq)
 947 {
 948         int     ret = 0;
 949         struct l1oip    *hc = dch->hw;
 950
 951         switch (cq->op) {
 952         case MISDN_CTRL_GETOP:
 953                 cq->op = MISDN_CTRL_SETPEER | MISDN_CTRL_UNSETPEER
 954                         | MISDN_CTRL_GETPEER;
 955                 break;
 956         case MISDN_CTRL_SETPEER:
 957                 hc->remoteip = (u32)cq->p1;
 958                 hc->remoteport = cq->p2 & 0xffff;
 959                 hc->localport = cq->p2 >> 16;
 960                 if (!hc->remoteport)
 961                         hc->remoteport = hc->localport;
 962                 if (debug & DEBUG_L1OIP_SOCKET)
 963                         printk(KERN_DEBUG "%s: got new ip address from user "
 964                                "space.\n", __func__);
 965                 l1oip_socket_open(hc);
 966                 break;
 967         case MISDN_CTRL_UNSETPEER:
 968                 if (debug & DEBUG_L1OIP_SOCKET)
 969                         printk(KERN_DEBUG "%s: removing ip address.\n",
 970                                __func__);
 971                 hc->remoteip = 0;
 972                 l1oip_socket_open(hc);
 973                 break;
 974         case MISDN_CTRL_GETPEER:
 975                 if (debug & DEBUG_L1OIP_SOCKET)
 976                         printk(KERN_DEBUG "%s: getting ip address.\n",
 977                                __func__);
 978                 cq->p1 = hc->remoteip;
 979                 cq->p2 = hc->remoteport | (hc->localport << 16);
 980                 break;
 981         default:
 982                 printk(KERN_WARNING "%s: unknown Op %x\n",
 983                        __func__, cq->op);
 984                 ret = -EINVAL;
 985                 break;
 986         }
 987         return ret;
 988 }
 989
 990 static int
 991 open_dchannel(struct l1oip *hc, struct dchannel *dch, struct channel_req *rq)
 992 {
 993         if (debug & DEBUG_HW_OPEN)
 994                 printk(KERN_DEBUG "%s: dev(%d) open from %p\n", __func__,
 995                        dch->dev.id, __builtin_return_address(0));
 996         if (rq->protocol == ISDN_P_NONE)
 997                 return -EINVAL;
 998         if ((dch->dev.D.protocol != ISDN_P_NONE) &&
 999             (dch->dev.D.protocol != rq->protocol)) {
1000                 if (debug & DEBUG_HW_OPEN)
1001                         printk(KERN_WARNING "%s: change protocol %x to %x\n",
1002                                __func__, dch->dev.D.protocol, rq->protocol);
1003         }
1004         if (dch->dev.D.protocol != rq->protocol)
1005                 dch->dev.D.protocol = rq->protocol;
1006
1007         if (test_bit(FLG_ACTIVE, &dch->Flags)) {
1008                 _queue_data(&dch->dev.D, PH_ACTIVATE_IND, MISDN_ID_ANY,
1009                             0, NULL, GFP_KERNEL);
1010         }
1011         rq->ch = &dch->dev.D;
1012         if (!try_module_get(THIS_MODULE))
1013                 printk(KERN_WARNING "%s:cannot get module\n", __func__);
1014         return 0;
1015 }
1016
1017 static int
1018 open_bchannel(struct l1oip *hc, struct dchannel *dch, struct channel_req *rq)
1019 {
1020         struct bchannel *bch;
1021         int             ch;
1022
1023         if (!test_channelmap(rq->adr.channel, dch->dev.channelmap))
1024                 return -EINVAL;
1025         if (rq->protocol == ISDN_P_NONE)
1026                 return -EINVAL;
1027         ch = rq->adr.channel; /* BRI: 1=B1 2=B2  PRI: 1..15,17.. */
1028         bch = hc->chan[ch].bch;
1029         if (!bch) {
1030                 printk(KERN_ERR "%s:internal error ch %d has no bch\n",
1031                        __func__, ch);
1032                 return -EINVAL;
1033         }
1034         if (test_and_set_bit(FLG_OPEN, &bch->Flags))
1035                 return -EBUSY; /* b-channel can be only open once */
1036         bch->ch.protocol = rq->protocol;
1037         rq->ch = &bch->ch;
1038         if (!try_module_get(THIS_MODULE))
1039                 printk(KERN_WARNING "%s:cannot get module\n", __func__);
1040         return 0;
1041 }
1042
1043 static int
1044 l1oip_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1045 {
1046         struct mISDNdevice      *dev = container_of(ch, struct mISDNdevice, D);
1047         struct dchannel         *dch = container_of(dev, struct dchannel, dev);
1048         struct l1oip                    *hc = dch->hw;
1049         struct channel_req      *rq;
1050         int                     err = 0;
1051
1052         if (dch->debug & DEBUG_HW)
1053                 printk(KERN_DEBUG "%s: cmd:%x %p\n",
1054                        __func__, cmd, arg);
1055         switch (cmd) {
1056         case OPEN_CHANNEL:
1057                 rq = arg;
1058                 switch (rq->protocol) {
1059                 case ISDN_P_TE_S0:
1060                 case ISDN_P_NT_S0:
1061                         if (hc->pri) {
1062                                 err = -EINVAL;
1063                                 break;
1064                         }
1065                         err = open_dchannel(hc, dch, rq);
1066                         break;
1067                 case ISDN_P_TE_E1:
1068                 case ISDN_P_NT_E1:
1069                         if (!hc->pri) {
1070                                 err = -EINVAL;
1071                                 break;
1072                         }
1073                         err = open_dchannel(hc, dch, rq);
1074                         break;
1075                 default:
1076                         err = open_bchannel(hc, dch, rq);
1077                 }
1078                 break;
1079         case CLOSE_CHANNEL:
1080                 if (debug & DEBUG_HW_OPEN)
1081                         printk(KERN_DEBUG "%s: dev(%d) close from %p\n",
1082                                __func__, dch->dev.id,
1083                                __builtin_return_address(0));
1084                 module_put(THIS_MODULE);
1085                 break;
1086         case CONTROL_CHANNEL:
1087                 err = channel_dctrl(dch, arg);
1088                 break;
1089         default:
1090                 if (dch->debug & DEBUG_HW)
1091                         printk(KERN_DEBUG "%s: unknown command %x\n",
1092                                __func__, cmd);
1093                 err = -EINVAL;
1094         }
1095         return err;
1096 }
1097
1098 static int
1099 handle_bmsg(struct mISDNchannel *ch, struct sk_buff *skb)
1100 {
1101         struct bchannel         *bch = container_of(ch, struct bchannel, ch);
1102         struct l1oip                    *hc = bch->hw;
1103         int                     ret = -EINVAL;
1104         struct mISDNhead        *hh = mISDN_HEAD_P(skb);
1105         int                     l, ll;
1106         unsigned char           *p;
1107
1108         switch (hh->prim) {
1109         case PH_DATA_REQ:
1110                 if (skb->len <= 0) {
1111                         printk(KERN_WARNING "%s: skb too small\n",
1112                                __func__);
1113                         break;
1114                 }
1115                 if (skb->len > MAX_DFRAME_LEN_L1 || skb->len > L1OIP_MAX_LEN) {
1116                         printk(KERN_WARNING "%s: skb too large\n",
1117                                __func__);
1118                         break;
1119                 }
1120                 /* check for AIS / ulaw-silence */
1121                 l = skb->len;
1122                 if (!memchr_inv(skb->data, 0xff, l)) {
1123                         if (debug & DEBUG_L1OIP_MSG)
1124                                 printk(KERN_DEBUG "%s: got AIS, not sending, "
1125                                        "but counting\n", __func__);
1126                         hc->chan[bch->slot].tx_counter += l;
1127                         skb_trim(skb, 0);
1128                         queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1129                         return 0;
1130                 }
1131                 /* check for silence */
1132                 l = skb->len;
1133                 if (!memchr_inv(skb->data, 0x2a, l)) {
1134                         if (debug & DEBUG_L1OIP_MSG)
1135                                 printk(KERN_DEBUG "%s: got silence, not sending"
1136                                        ", but counting\n", __func__);
1137                         hc->chan[bch->slot].tx_counter += l;
1138                         skb_trim(skb, 0);
1139                         queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1140                         return 0;
1141                 }
1142
1143                 /* send frame */
1144                 p = skb->data;
1145                 l = skb->len;
1146                 while (l) {
1147                         /*
1148                          * This is technically bounded by L1OIP_MAX_PERFRAME but
1149                          * MAX_DFRAME_LEN_L1 < L1OIP_MAX_PERFRAME
1150                          */
1151                         ll = (l < MAX_DFRAME_LEN_L1) ? l : MAX_DFRAME_LEN_L1;
1152                         l1oip_socket_send(hc, hc->codec, bch->slot, 0,
1153                                           hc->chan[bch->slot].tx_counter, p, ll);
1154                         hc->chan[bch->slot].tx_counter += ll;
1155                         p += ll;
1156                         l -= ll;
1157                 }
1158                 skb_trim(skb, 0);
1159                 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1160                 return 0;
1161         case PH_ACTIVATE_REQ:
1162                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
1163                         printk(KERN_DEBUG "%s: PH_ACTIVATE channel %d (1..%d)\n"
1164                                , __func__, bch->slot, hc->b_num + 1);
1165                 hc->chan[bch->slot].codecstate = 0;
1166                 test_and_set_bit(FLG_ACTIVE, &bch->Flags);
1167                 skb_trim(skb, 0);
1168                 queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
1169                 return 0;
1170         case PH_DEACTIVATE_REQ:
1171                 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
1172                         printk(KERN_DEBUG "%s: PH_DEACTIVATE channel %d "
1173                                "(1..%d)\n", __func__, bch->slot,
1174                                hc->b_num + 1);
1175                 test_and_clear_bit(FLG_ACTIVE, &bch->Flags);
1176                 skb_trim(skb, 0);
1177                 queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
1178                 return 0;
1179         }
1180         if (!ret)
1181                 dev_kfree_skb(skb);
1182         return ret;
1183 }
1184
1185 static int
1186 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
1187 {
1188         int                     ret = 0;
1189         struct dsp_features     *features =
1190                 (struct dsp_features *)(*((u_long *)&cq->p1));
1191
1192         switch (cq->op) {
1193         case MISDN_CTRL_GETOP:
1194                 cq->op = MISDN_CTRL_HW_FEATURES_OP;
1195                 break;
1196         case MISDN_CTRL_HW_FEATURES: /* fill features structure */
1197                 if (debug & DEBUG_L1OIP_MSG)
1198                         printk(KERN_DEBUG "%s: HW_FEATURE request\n",
1199                                __func__);
1200                 /* create confirm */
1201                 features->unclocked = 1;
1202                 features->unordered = 1;
1203                 break;
1204         default:
1205                 printk(KERN_WARNING "%s: unknown Op %x\n",
1206                        __func__, cq->op);
1207                 ret = -EINVAL;
1208                 break;
1209         }
1210         return ret;
1211 }
1212
1213 static int
1214 l1oip_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1215 {
1216         struct bchannel *bch = container_of(ch, struct bchannel, ch);
1217         int             err = -EINVAL;
1218
1219         if (bch->debug & DEBUG_HW)
1220                 printk(KERN_DEBUG "%s: cmd:%x %p\n",
1221                        __func__, cmd, arg);
1222         switch (cmd) {
1223         case CLOSE_CHANNEL:
1224                 test_and_clear_bit(FLG_OPEN, &bch->Flags);
1225                 test_and_clear_bit(FLG_ACTIVE, &bch->Flags);
1226                 ch->protocol = ISDN_P_NONE;
1227                 ch->peer = NULL;
1228                 module_put(THIS_MODULE);
1229                 err = 0;
1230                 break;
1231         case CONTROL_CHANNEL:
1232                 err = channel_bctrl(bch, arg);
1233                 break;
1234         default:
1235                 printk(KERN_WARNING "%s: unknown prim(%x)\n",
1236                        __func__, cmd);
1237         }
1238         return err;
1239 }
1240
1241
1242 /*
1243  * cleanup module and stack
1244  */
1245 static void
1246 release_card(struct l1oip *hc)
1247 {
1248         int     ch;
1249
1250         if (timer_pending(&hc->keep_tl))
1251                 del_timer(&hc->keep_tl);
1252
1253         if (timer_pending(&hc->timeout_tl))
1254                 del_timer(&hc->timeout_tl);
1255
1256         cancel_work_sync(&hc->workq);
1257
1258         if (hc->socket_thread)
1259                 l1oip_socket_close(hc);
1260
1261         if (hc->registered && hc->chan[hc->d_idx].dch)
1262                 mISDN_unregister_device(&hc->chan[hc->d_idx].dch->dev);
1263         for (ch = 0; ch < 128; ch++) {
1264                 if (hc->chan[ch].dch) {
1265                         mISDN_freedchannel(hc->chan[ch].dch);
1266                         kfree(hc->chan[ch].dch);
1267                 }
1268                 if (hc->chan[ch].bch) {
1269                         mISDN_freebchannel(hc->chan[ch].bch);
1270                         kfree(hc->chan[ch].bch);
1271 #ifdef REORDER_DEBUG
1272                         if (hc->chan[ch].disorder_skb)
1273                                 dev_kfree_skb(hc->chan[ch].disorder_skb);
1274 #endif
1275                 }
1276         }
1277
1278         spin_lock(&l1oip_lock);
1279         list_del(&hc->list);
1280         spin_unlock(&l1oip_lock);
1281
1282         kfree(hc);
1283 }
1284
1285 static void
1286 l1oip_cleanup(void)
1287 {
1288         struct l1oip *hc, *next;
1289
1290         list_for_each_entry_safe(hc, next, &l1oip_ilist, list)
1291                 release_card(hc);
1292
1293         l1oip_4bit_free();
1294 }
1295
1296
1297 /*
1298  * module and stack init
1299  */
1300 static int
1301 init_card(struct l1oip *hc, int pri, int bundle)
1302 {
1303         struct dchannel *dch;
1304         struct bchannel *bch;
1305         int             ret;
1306         int             i, ch;
1307
1308         spin_lock_init(&hc->socket_lock);
1309         hc->idx = l1oip_cnt;
1310         hc->pri = pri;
1311         hc->d_idx = pri ? 16 : 3;
1312         hc->b_num = pri ? 30 : 2;
1313         hc->bundle = bundle;
1314         if (hc->pri)
1315                 sprintf(hc->name, "l1oip-e1.%d", l1oip_cnt + 1);
1316         else
1317                 sprintf(hc->name, "l1oip-s0.%d", l1oip_cnt + 1);
1318
1319         switch (codec[l1oip_cnt]) {
1320         case 0: /* as is */
1321         case 1: /* alaw */
1322         case 2: /* ulaw */
1323         case 3: /* 4bit */
1324                 break;
1325         default:
1326                 printk(KERN_ERR "Codec(%d) not supported.\n",
1327                        codec[l1oip_cnt]);
1328                 return -EINVAL;
1329         }
1330         hc->codec = codec[l1oip_cnt];
1331         if (debug & DEBUG_L1OIP_INIT)
1332                 printk(KERN_DEBUG "%s: using codec %d\n",
1333                        __func__, hc->codec);
1334
1335         if (id[l1oip_cnt] == 0) {
1336                 printk(KERN_WARNING "Warning: No 'id' value given or "
1337                        "0, this is highly unsecure. Please use 32 "
1338                        "bit random number 0x...\n");
1339         }
1340         hc->id = id[l1oip_cnt];
1341         if (debug & DEBUG_L1OIP_INIT)
1342                 printk(KERN_DEBUG "%s: using id 0x%x\n", __func__, hc->id);
1343
1344         hc->ondemand = ondemand[l1oip_cnt];
1345         if (hc->ondemand && !hc->id) {
1346                 printk(KERN_ERR "%s: ondemand option only allowed in "
1347                        "conjunction with non 0 ID\n", __func__);
1348                 return -EINVAL;
1349         }
1350
1351         if (limit[l1oip_cnt])
1352                 hc->b_num = limit[l1oip_cnt];
1353         if (!pri && hc->b_num > 2) {
1354                 printk(KERN_ERR "Maximum limit for BRI interface is 2 "
1355                        "channels.\n");
1356                 return -EINVAL;
1357         }
1358         if (pri && hc->b_num > 126) {
1359                 printk(KERN_ERR "Maximum limit for PRI interface is 126 "
1360                        "channels.\n");
1361                 return -EINVAL;
1362         }
1363         if (pri && hc->b_num > 30) {
1364                 printk(KERN_WARNING "Maximum limit for BRI interface is 30 "
1365                        "channels.\n");
1366                 printk(KERN_WARNING "Your selection of %d channels must be "
1367                        "supported by application.\n", hc->limit);
1368         }
1369
1370         hc->remoteip = ip[l1oip_cnt << 2] << 24
1371                 | ip[(l1oip_cnt << 2) + 1] << 16
1372                 | ip[(l1oip_cnt << 2) + 2] << 8
1373                 | ip[(l1oip_cnt << 2) + 3];
1374         hc->localport = port[l1oip_cnt]?:(L1OIP_DEFAULTPORT + l1oip_cnt);
1375         if (remoteport[l1oip_cnt])
1376                 hc->remoteport = remoteport[l1oip_cnt];
1377         else
1378                 hc->remoteport = hc->localport;
1379         if (debug & DEBUG_L1OIP_INIT)
1380                 printk(KERN_DEBUG "%s: using local port %d remote ip "
1381                        "%d.%d.%d.%d port %d ondemand %d\n", __func__,
1382                        hc->localport, hc->remoteip >> 24,
1383                        (hc->remoteip >> 16) & 0xff,
1384                        (hc->remoteip >> 8) & 0xff, hc->remoteip & 0xff,
1385                        hc->remoteport, hc->ondemand);
1386
1387         dch = kzalloc(sizeof(struct dchannel), GFP_KERNEL);
1388         if (!dch)
1389                 return -ENOMEM;
1390         dch->debug = debug;
1391         mISDN_initdchannel(dch, MAX_DFRAME_LEN_L1, NULL);
1392         dch->hw = hc;
1393         if (pri)
1394                 dch->dev.Dprotocols = (1 << ISDN_P_TE_E1) | (1 << ISDN_P_NT_E1);
1395         else
1396                 dch->dev.Dprotocols = (1 << ISDN_P_TE_S0) | (1 << ISDN_P_NT_S0);
1397         dch->dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
1398                 (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
1399         dch->dev.D.send = handle_dmsg;
1400         dch->dev.D.ctrl = l1oip_dctrl;
1401         dch->dev.nrbchan = hc->b_num;
1402         dch->slot = hc->d_idx;
1403         hc->chan[hc->d_idx].dch = dch;
1404         i = 1;
1405         for (ch = 0; ch < dch->dev.nrbchan; ch++) {
1406                 if (ch == 15)
1407                         i++;
1408                 bch = kzalloc(sizeof(struct bchannel), GFP_KERNEL);
1409                 if (!bch) {
1410                         printk(KERN_ERR "%s: no memory for bchannel\n",
1411                                __func__);
1412                         return -ENOMEM;
1413                 }
1414                 bch->nr = i + ch;
1415                 bch->slot = i + ch;
1416                 bch->debug = debug;
1417                 mISDN_initbchannel(bch, MAX_DATA_MEM, 0);
1418                 bch->hw = hc;
1419                 bch->ch.send = handle_bmsg;
1420                 bch->ch.ctrl = l1oip_bctrl;
1421                 bch->ch.nr = i + ch;
1422                 list_add(&bch->ch.list, &dch->dev.bchannels);
1423                 hc->chan[i + ch].bch = bch;
1424                 set_channelmap(bch->nr, dch->dev.channelmap);
1425         }
1426         /* TODO: create a parent device for this driver */
1427         ret = mISDN_register_device(&dch->dev, NULL, hc->name);
1428         if (ret)
1429                 return ret;
1430         hc->registered = 1;
1431
1432         if (debug & DEBUG_L1OIP_INIT)
1433                 printk(KERN_DEBUG "%s: Setting up network card(%d)\n",
1434                        __func__, l1oip_cnt + 1);
1435         ret = l1oip_socket_open(hc);
1436         if (ret)
1437                 return ret;
1438
1439         timer_setup(&hc->keep_tl, l1oip_keepalive, 0);
1440         hc->keep_tl.expires = jiffies + 2 * HZ; /* two seconds first time */
1441         add_timer(&hc->keep_tl);
1442
1443         timer_setup(&hc->timeout_tl, l1oip_timeout, 0);
1444         hc->timeout_on = 0; /* state that we have timer off */
1445
1446         return 0;
1447 }
1448
1449 static int __init
1450 l1oip_init(void)
1451 {
1452         int             pri, bundle;
1453         struct l1oip            *hc;
1454         int             ret;
1455
1456         printk(KERN_INFO "mISDN: Layer-1-over-IP driver Rev. %s\n",
1457                l1oip_revision);
1458
1459         INIT_LIST_HEAD(&l1oip_ilist);
1460         spin_lock_init(&l1oip_lock);
1461
1462         if (l1oip_4bit_alloc(ulaw))
1463                 return -ENOMEM;
1464
1465         l1oip_cnt = 0;
1466         while (l1oip_cnt < MAX_CARDS && type[l1oip_cnt]) {
1467                 switch (type[l1oip_cnt] & 0xff) {
1468                 case 1:
1469                         pri = 0;
1470                         bundle = 0;
1471                         break;
1472                 case 2:
1473                         pri = 1;
1474                         bundle = 0;
1475                         break;
1476                 case 3:
1477                         pri = 0;
1478                         bundle = 1;
1479                         break;
1480                 case 4:
1481                         pri = 1;
1482                         bundle = 1;
1483                         break;
1484                 default:
1485                         printk(KERN_ERR "Card type(%d) not supported.\n",
1486                                type[l1oip_cnt] & 0xff);
1487                         l1oip_cleanup();
1488                         return -EINVAL;
1489                 }
1490
1491                 if (debug & DEBUG_L1OIP_INIT)
1492                         printk(KERN_DEBUG "%s: interface %d is %s with %s.\n",
1493                                __func__, l1oip_cnt, pri ? "PRI" : "BRI",
1494                                bundle ? "bundled IP packet for all B-channels" :
1495                                "separate IP packets for every B-channel");
1496
1497                 hc = kzalloc(sizeof(struct l1oip), GFP_ATOMIC);
1498                 if (!hc) {
1499                         printk(KERN_ERR "No kmem for L1-over-IP driver.\n");
1500                         l1oip_cleanup();
1501                         return -ENOMEM;
1502                 }
1503                 INIT_WORK(&hc->workq, (void *)l1oip_send_bh);
1504
1505                 spin_lock(&l1oip_lock);
1506                 list_add_tail(&hc->list, &l1oip_ilist);
1507                 spin_unlock(&l1oip_lock);
1508
1509                 ret = init_card(hc, pri, bundle);
1510                 if (ret) {
1511                         l1oip_cleanup();
1512                         return ret;
1513                 }
1514
1515                 l1oip_cnt++;
1516         }
1517         printk(KERN_INFO "%d virtual devices registered\n", l1oip_cnt);
1518         return 0;
1519 }
1520
1521 module_init(l1oip_init);
1522 module_exit(l1oip_cleanup);