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