drivers/isdn/mISDN/l1oip_core.c

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