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