drivers/isdn/mISDN/l1oip_core.c

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