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