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