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