?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.16.11
[linux/fpc-iii.git] / drivers / isdn / mISDN / l1oip_core.c
blob21d50e4cc5e1db760f4cdaf726cc3c106551a839
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 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 ll = (l < L1OIP_MAX_PERFRAME) ? l : L1OIP_MAX_PERFRAME;
906 l1oip_socket_send(hc, 0, dch->slot, 0,
907 hc->chan[dch->slot].tx_counter++, p, ll);
908 p += ll;
909 l -= ll;
910 }
911 skb_trim(skb, 0);
912 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
913 return 0;
914 case PH_ACTIVATE_REQ:
915 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
916 printk(KERN_DEBUG "%s: PH_ACTIVATE channel %d (1..%d)\n"
917 , __func__, dch->slot, 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 case PH_DEACTIVATE_REQ:
925 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
926 printk(KERN_DEBUG "%s: PH_DEACTIVATE channel %d "
927 "(1..%d)\n", __func__, dch->slot,
928 hc->b_num + 1);
929 skb_trim(skb, 0);
930 if (test_bit(FLG_ACTIVE, &dch->Flags))
931 queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
932 else
933 queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
934 return 0;
935 }
936 if (!ret)
937 dev_kfree_skb(skb);
938 return ret;
939 }
940
941 static int
942 channel_dctrl(struct dchannel *dch, struct mISDN_ctrl_req *cq)
943 {
944 int ret = 0;
945 struct l1oip *hc = dch->hw;
946
947 switch (cq->op) {
948 case MISDN_CTRL_GETOP:
949 cq->op = MISDN_CTRL_SETPEER | MISDN_CTRL_UNSETPEER
950 | MISDN_CTRL_GETPEER;
951 break;
952 case MISDN_CTRL_SETPEER:
953 hc->remoteip = (u32)cq->p1;
954 hc->remoteport = cq->p2 & 0xffff;
955 hc->localport = cq->p2 >> 16;
956 if (!hc->remoteport)
957 hc->remoteport = hc->localport;
958 if (debug & DEBUG_L1OIP_SOCKET)
959 printk(KERN_DEBUG "%s: got new ip address from user "
960 "space.\n", __func__);
961 l1oip_socket_open(hc);
962 break;
963 case MISDN_CTRL_UNSETPEER:
964 if (debug & DEBUG_L1OIP_SOCKET)
965 printk(KERN_DEBUG "%s: removing ip address.\n",
966 __func__);
967 hc->remoteip = 0;
968 l1oip_socket_open(hc);
969 break;
970 case MISDN_CTRL_GETPEER:
971 if (debug & DEBUG_L1OIP_SOCKET)
972 printk(KERN_DEBUG "%s: getting ip address.\n",
973 __func__);
974 cq->p1 = hc->remoteip;
975 cq->p2 = hc->remoteport | (hc->localport << 16);
976 break;
977 default:
978 printk(KERN_WARNING "%s: unknown Op %x\n",
979 __func__, cq->op);
980 ret = -EINVAL;
981 break;
982 }
983 return ret;
984 }
985
986 static int
987 open_dchannel(struct l1oip *hc, struct dchannel *dch, struct channel_req *rq)
988 {
989 if (debug & DEBUG_HW_OPEN)
990 printk(KERN_DEBUG "%s: dev(%d) open from %p\n", __func__,
991 dch->dev.id, __builtin_return_address(0));
992 if (rq->protocol == ISDN_P_NONE)
993 return -EINVAL;
994 if ((dch->dev.D.protocol != ISDN_P_NONE) &&
995 (dch->dev.D.protocol != rq->protocol)) {
996 if (debug & DEBUG_HW_OPEN)
997 printk(KERN_WARNING "%s: change protocol %x to %x\n",
998 __func__, dch->dev.D.protocol, rq->protocol);
999 }
1000 if (dch->dev.D.protocol != rq->protocol)
1001 dch->dev.D.protocol = rq->protocol;
1002
1003 if (test_bit(FLG_ACTIVE, &dch->Flags)) {
1004 _queue_data(&dch->dev.D, PH_ACTIVATE_IND, MISDN_ID_ANY,
1005 0, NULL, GFP_KERNEL);
1006 }
1007 rq->ch = &dch->dev.D;
1008 if (!try_module_get(THIS_MODULE))
1009 printk(KERN_WARNING "%s:cannot get module\n", __func__);
1010 return 0;
1011 }
1012
1013 static int
1014 open_bchannel(struct l1oip *hc, struct dchannel *dch, struct channel_req *rq)
1015 {
1016 struct bchannel *bch;
1017 int ch;
1018
1019 if (!test_channelmap(rq->adr.channel, dch->dev.channelmap))
1020 return -EINVAL;
1021 if (rq->protocol == ISDN_P_NONE)
1022 return -EINVAL;
1023 ch = rq->adr.channel; /* BRI: 1=B1 2=B2 PRI: 1..15,17.. */
1024 bch = hc->chan[ch].bch;
1025 if (!bch) {
1026 printk(KERN_ERR "%s:internal error ch %d has no bch\n",
1027 __func__, ch);
1028 return -EINVAL;
1029 }
1030 if (test_and_set_bit(FLG_OPEN, &bch->Flags))
1031 return -EBUSY; /* b-channel can be only open once */
1032 bch->ch.protocol = rq->protocol;
1033 rq->ch = &bch->ch;
1034 if (!try_module_get(THIS_MODULE))
1035 printk(KERN_WARNING "%s:cannot get module\n", __func__);
1036 return 0;
1037 }
1038
1039 static int
1040 l1oip_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1041 {
1042 struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D);
1043 struct dchannel *dch = container_of(dev, struct dchannel, dev);
1044 struct l1oip *hc = dch->hw;
1045 struct channel_req *rq;
1046 int err = 0;
1047
1048 if (dch->debug & DEBUG_HW)
1049 printk(KERN_DEBUG "%s: cmd:%x %p\n",
1050 __func__, cmd, arg);
1051 switch (cmd) {
1052 case OPEN_CHANNEL:
1053 rq = arg;
1054 switch (rq->protocol) {
1055 case ISDN_P_TE_S0:
1056 case ISDN_P_NT_S0:
1057 if (hc->pri) {
1058 err = -EINVAL;
1059 break;
1060 }
1061 err = open_dchannel(hc, dch, rq);
1062 break;
1063 case ISDN_P_TE_E1:
1064 case ISDN_P_NT_E1:
1065 if (!hc->pri) {
1066 err = -EINVAL;
1067 break;
1068 }
1069 err = open_dchannel(hc, dch, rq);
1070 break;
1071 default:
1072 err = open_bchannel(hc, dch, rq);
1073 }
1074 break;
1075 case CLOSE_CHANNEL:
1076 if (debug & DEBUG_HW_OPEN)
1077 printk(KERN_DEBUG "%s: dev(%d) close from %p\n",
1078 __func__, dch->dev.id,
1079 __builtin_return_address(0));
1080 module_put(THIS_MODULE);
1081 break;
1082 case CONTROL_CHANNEL:
1083 err = channel_dctrl(dch, arg);
1084 break;
1085 default:
1086 if (dch->debug & DEBUG_HW)
1087 printk(KERN_DEBUG "%s: unknown command %x\n",
1088 __func__, cmd);
1089 err = -EINVAL;
1090 }
1091 return err;
1092 }
1093
1094 static int
1095 handle_bmsg(struct mISDNchannel *ch, struct sk_buff *skb)
1096 {
1097 struct bchannel *bch = container_of(ch, struct bchannel, ch);
1098 struct l1oip *hc = bch->hw;
1099 int ret = -EINVAL;
1100 struct mISDNhead *hh = mISDN_HEAD_P(skb);
1101 int l, ll;
1102 unsigned char *p;
1103
1104 switch (hh->prim) {
1105 case PH_DATA_REQ:
1106 if (skb->len <= 0) {
1107 printk(KERN_WARNING "%s: skb too small\n",
1108 __func__);
1109 break;
1110 }
1111 if (skb->len > MAX_DFRAME_LEN_L1 || skb->len > L1OIP_MAX_LEN) {
1112 printk(KERN_WARNING "%s: skb too large\n",
1113 __func__);
1114 break;
1115 }
1116 /* check for AIS / ulaw-silence */
1117 l = skb->len;
1118 if (!memchr_inv(skb->data, 0xff, l)) {
1119 if (debug & DEBUG_L1OIP_MSG)
1120 printk(KERN_DEBUG "%s: got AIS, 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 /* check for silence */
1128 l = skb->len;
1129 if (!memchr_inv(skb->data, 0x2a, l)) {
1130 if (debug & DEBUG_L1OIP_MSG)
1131 printk(KERN_DEBUG "%s: got silence, not sending"
1132 ", but counting\n", __func__);
1133 hc->chan[bch->slot].tx_counter += l;
1134 skb_trim(skb, 0);
1135 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1136 return 0;
1137 }
1138
1139 /* send frame */
1140 p = skb->data;
1141 l = skb->len;
1142 while (l) {
1143 ll = (l < L1OIP_MAX_PERFRAME) ? l : L1OIP_MAX_PERFRAME;
1144 l1oip_socket_send(hc, hc->codec, bch->slot, 0,
1145 hc->chan[bch->slot].tx_counter, p, ll);
1146 hc->chan[bch->slot].tx_counter += ll;
1147 p += ll;
1148 l -= ll;
1149 }
1150 skb_trim(skb, 0);
1151 queue_ch_frame(ch, PH_DATA_CNF, hh->id, skb);
1152 return 0;
1153 case PH_ACTIVATE_REQ:
1154 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
1155 printk(KERN_DEBUG "%s: PH_ACTIVATE channel %d (1..%d)\n"
1156 , __func__, bch->slot, hc->b_num + 1);
1157 hc->chan[bch->slot].codecstate = 0;
1158 test_and_set_bit(FLG_ACTIVE, &bch->Flags);
1159 skb_trim(skb, 0);
1160 queue_ch_frame(ch, PH_ACTIVATE_IND, hh->id, skb);
1161 return 0;
1162 case PH_DEACTIVATE_REQ:
1163 if (debug & (DEBUG_L1OIP_MSG | DEBUG_L1OIP_SOCKET))
1164 printk(KERN_DEBUG "%s: PH_DEACTIVATE channel %d "
1165 "(1..%d)\n", __func__, bch->slot,
1166 hc->b_num + 1);
1167 test_and_clear_bit(FLG_ACTIVE, &bch->Flags);
1168 skb_trim(skb, 0);
1169 queue_ch_frame(ch, PH_DEACTIVATE_IND, hh->id, skb);
1170 return 0;
1171 }
1172 if (!ret)
1173 dev_kfree_skb(skb);
1174 return ret;
1175 }
1176
1177 static int
1178 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
1179 {
1180 int ret = 0;
1181 struct dsp_features *features =
1182 (struct dsp_features *)(*((u_long *)&cq->p1));
1183
1184 switch (cq->op) {
1185 case MISDN_CTRL_GETOP:
1186 cq->op = MISDN_CTRL_HW_FEATURES_OP;
1187 break;
1188 case MISDN_CTRL_HW_FEATURES: /* fill features structure */
1189 if (debug & DEBUG_L1OIP_MSG)
1190 printk(KERN_DEBUG "%s: HW_FEATURE request\n",
1191 __func__);
1192 /* create confirm */
1193 features->unclocked = 1;
1194 features->unordered = 1;
1195 break;
1196 default:
1197 printk(KERN_WARNING "%s: unknown Op %x\n",
1198 __func__, cq->op);
1199 ret = -EINVAL;
1200 break;
1201 }
1202 return ret;
1203 }
1204
1205 static int
1206 l1oip_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1207 {
1208 struct bchannel *bch = container_of(ch, struct bchannel, ch);
1209 int err = -EINVAL;
1210
1211 if (bch->debug & DEBUG_HW)
1212 printk(KERN_DEBUG "%s: cmd:%x %p\n",
1213 __func__, cmd, arg);
1214 switch (cmd) {
1215 case CLOSE_CHANNEL:
1216 test_and_clear_bit(FLG_OPEN, &bch->Flags);
1217 test_and_clear_bit(FLG_ACTIVE, &bch->Flags);
1218 ch->protocol = ISDN_P_NONE;
1219 ch->peer = NULL;
1220 module_put(THIS_MODULE);
1221 err = 0;
1222 break;
1223 case CONTROL_CHANNEL:
1224 err = channel_bctrl(bch, arg);
1225 break;
1226 default:
1227 printk(KERN_WARNING "%s: unknown prim(%x)\n",
1228 __func__, cmd);
1229 }
1230 return err;
1231 }
1232
1233
1234 /*
1235 * cleanup module and stack
1236 */
1237 static void
1238 release_card(struct l1oip *hc)
1239 {
1240 int ch;
1241
1242 if (timer_pending(&hc->keep_tl))
1243 del_timer(&hc->keep_tl);
1244
1245 if (timer_pending(&hc->timeout_tl))
1246 del_timer(&hc->timeout_tl);
1247
1248 cancel_work_sync(&hc->workq);
1249
1250 if (hc->socket_thread)
1251 l1oip_socket_close(hc);
1252
1253 if (hc->registered && hc->chan[hc->d_idx].dch)
1254 mISDN_unregister_device(&hc->chan[hc->d_idx].dch->dev);
1255 for (ch = 0; ch < 128; ch++) {
1256 if (hc->chan[ch].dch) {
1257 mISDN_freedchannel(hc->chan[ch].dch);
1258 kfree(hc->chan[ch].dch);
1259 }
1260 if (hc->chan[ch].bch) {
1261 mISDN_freebchannel(hc->chan[ch].bch);
1262 kfree(hc->chan[ch].bch);
1263 #ifdef REORDER_DEBUG
1264 if (hc->chan[ch].disorder_skb)
1265 dev_kfree_skb(hc->chan[ch].disorder_skb);
1266 #endif
1267 }
1268 }
1269
1270 spin_lock(&l1oip_lock);
1271 list_del(&hc->list);
1272 spin_unlock(&l1oip_lock);
1273
1274 kfree(hc);
1275 }
1276
1277 static void
1278 l1oip_cleanup(void)
1279 {
1280 struct l1oip *hc, *next;
1281
1282 list_for_each_entry_safe(hc, next, &l1oip_ilist, list)
1283 release_card(hc);
1284
1285 l1oip_4bit_free();
1286 }
1287
1288
1289 /*
1290 * module and stack init
1291 */
1292 static int
1293 init_card(struct l1oip *hc, int pri, int bundle)
1294 {
1295 struct dchannel *dch;
1296 struct bchannel *bch;
1297 int ret;
1298 int i, ch;
1299
1300 spin_lock_init(&hc->socket_lock);
1301 hc->idx = l1oip_cnt;
1302 hc->pri = pri;
1303 hc->d_idx = pri ? 16 : 3;
1304 hc->b_num = pri ? 30 : 2;
1305 hc->bundle = bundle;
1306 if (hc->pri)
1307 sprintf(hc->name, "l1oip-e1.%d", l1oip_cnt + 1);
1308 else
1309 sprintf(hc->name, "l1oip-s0.%d", l1oip_cnt + 1);
1310
1311 switch (codec[l1oip_cnt]) {
1312 case 0: /* as is */
1313 case 1: /* alaw */
1314 case 2: /* ulaw */
1315 case 3: /* 4bit */
1316 break;
1317 default:
1318 printk(KERN_ERR "Codec(%d) not supported.\n",
1319 codec[l1oip_cnt]);
1320 return -EINVAL;
1321 }
1322 hc->codec = codec[l1oip_cnt];
1323 if (debug & DEBUG_L1OIP_INIT)
1324 printk(KERN_DEBUG "%s: using codec %d\n",
1325 __func__, hc->codec);
1326
1327 if (id[l1oip_cnt] == 0) {
1328 printk(KERN_WARNING "Warning: No 'id' value given or "
1329 "0, this is highly unsecure. Please use 32 "
1330 "bit random number 0x...\n");
1331 }
1332 hc->id = id[l1oip_cnt];
1333 if (debug & DEBUG_L1OIP_INIT)
1334 printk(KERN_DEBUG "%s: using id 0x%x\n", __func__, hc->id);
1335
1336 hc->ondemand = ondemand[l1oip_cnt];
1337 if (hc->ondemand && !hc->id) {
1338 printk(KERN_ERR "%s: ondemand option only allowed in "
1339 "conjunction with non 0 ID\n", __func__);
1340 return -EINVAL;
1341 }
1342
1343 if (limit[l1oip_cnt])
1344 hc->b_num = limit[l1oip_cnt];
1345 if (!pri && hc->b_num > 2) {
1346 printk(KERN_ERR "Maximum limit for BRI interface is 2 "
1347 "channels.\n");
1348 return -EINVAL;
1349 }
1350 if (pri && hc->b_num > 126) {
1351 printk(KERN_ERR "Maximum limit for PRI interface is 126 "
1352 "channels.\n");
1353 return -EINVAL;
1354 }
1355 if (pri && hc->b_num > 30) {
1356 printk(KERN_WARNING "Maximum limit for BRI interface is 30 "
1357 "channels.\n");
1358 printk(KERN_WARNING "Your selection of %d channels must be "
1359 "supported by application.\n", hc->limit);
1360 }
1361
1362 hc->remoteip = ip[l1oip_cnt << 2] << 24
1363 | ip[(l1oip_cnt << 2) + 1] << 16
1364 | ip[(l1oip_cnt << 2) + 2] << 8
1365 | ip[(l1oip_cnt << 2) + 3];
1366 hc->localport = port[l1oip_cnt]?:(L1OIP_DEFAULTPORT + l1oip_cnt);
1367 if (remoteport[l1oip_cnt])
1368 hc->remoteport = remoteport[l1oip_cnt];
1369 else
1370 hc->remoteport = hc->localport;
1371 if (debug & DEBUG_L1OIP_INIT)
1372 printk(KERN_DEBUG "%s: using local port %d remote ip "
1373 "%d.%d.%d.%d port %d ondemand %d\n", __func__,
1374 hc->localport, hc->remoteip >> 24,
1375 (hc->remoteip >> 16) & 0xff,
1376 (hc->remoteip >> 8) & 0xff, hc->remoteip & 0xff,
1377 hc->remoteport, hc->ondemand);
1378
1379 dch = kzalloc(sizeof(struct dchannel), GFP_KERNEL);
1380 if (!dch)
1381 return -ENOMEM;
1382 dch->debug = debug;
1383 mISDN_initdchannel(dch, MAX_DFRAME_LEN_L1, NULL);
1384 dch->hw = hc;
1385 if (pri)
1386 dch->dev.Dprotocols = (1 << ISDN_P_TE_E1) | (1 << ISDN_P_NT_E1);
1387 else
1388 dch->dev.Dprotocols = (1 << ISDN_P_TE_S0) | (1 << ISDN_P_NT_S0);
1389 dch->dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
1390 (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
1391 dch->dev.D.send = handle_dmsg;
1392 dch->dev.D.ctrl = l1oip_dctrl;
1393 dch->dev.nrbchan = hc->b_num;
1394 dch->slot = hc->d_idx;
1395 hc->chan[hc->d_idx].dch = dch;
1396 i = 1;
1397 for (ch = 0; ch < dch->dev.nrbchan; ch++) {
1398 if (ch == 15)
1399 i++;
1400 bch = kzalloc(sizeof(struct bchannel), GFP_KERNEL);
1401 if (!bch) {
1402 printk(KERN_ERR "%s: no memory for bchannel\n",
1403 __func__);
1404 return -ENOMEM;
1405 }
1406 bch->nr = i + ch;
1407 bch->slot = i + ch;
1408 bch->debug = debug;
1409 mISDN_initbchannel(bch, MAX_DATA_MEM, 0);
1410 bch->hw = hc;
1411 bch->ch.send = handle_bmsg;
1412 bch->ch.ctrl = l1oip_bctrl;
1413 bch->ch.nr = i + ch;
1414 list_add(&bch->ch.list, &dch->dev.bchannels);
1415 hc->chan[i + ch].bch = bch;
1416 set_channelmap(bch->nr, dch->dev.channelmap);
1417 }
1418 /* TODO: create a parent device for this driver */
1419 ret = mISDN_register_device(&dch->dev, NULL, hc->name);
1420 if (ret)
1421 return ret;
1422 hc->registered = 1;
1423
1424 if (debug & DEBUG_L1OIP_INIT)
1425 printk(KERN_DEBUG "%s: Setting up network card(%d)\n",
1426 __func__, l1oip_cnt + 1);
1427 ret = l1oip_socket_open(hc);
1428 if (ret)
1429 return ret;
1430
1431 timer_setup(&hc->keep_tl, l1oip_keepalive, 0);
1432 hc->keep_tl.expires = jiffies + 2 * HZ; /* two seconds first time */
1433 add_timer(&hc->keep_tl);
1434
1435 timer_setup(&hc->timeout_tl, l1oip_timeout, 0);
1436 hc->timeout_on = 0; /* state that we have timer off */
1437
1438 return 0;
1439 }
1440
1441 static int __init
1442 l1oip_init(void)
1443 {
1444 int pri, bundle;
1445 struct l1oip *hc;
1446 int ret;
1447
1448 printk(KERN_INFO "mISDN: Layer-1-over-IP driver Rev. %s\n",
1449 l1oip_revision);
1450
1451 INIT_LIST_HEAD(&l1oip_ilist);
1452 spin_lock_init(&l1oip_lock);
1453
1454 if (l1oip_4bit_alloc(ulaw))
1455 return -ENOMEM;
1456
1457 l1oip_cnt = 0;
1458 while (l1oip_cnt < MAX_CARDS && type[l1oip_cnt]) {
1459 switch (type[l1oip_cnt] & 0xff) {
1460 case 1:
1461 pri = 0;
1462 bundle = 0;
1463 break;
1464 case 2:
1465 pri = 1;
1466 bundle = 0;
1467 break;
1468 case 3:
1469 pri = 0;
1470 bundle = 1;
1471 break;
1472 case 4:
1473 pri = 1;
1474 bundle = 1;
1475 break;
1476 default:
1477 printk(KERN_ERR "Card type(%d) not supported.\n",
1478 type[l1oip_cnt] & 0xff);
1479 l1oip_cleanup();
1480 return -EINVAL;
1481 }
1482
1483 if (debug & DEBUG_L1OIP_INIT)
1484 printk(KERN_DEBUG "%s: interface %d is %s with %s.\n",
1485 __func__, l1oip_cnt, pri ? "PRI" : "BRI",
1486 bundle ? "bundled IP packet for all B-channels" :
1487 "separate IP packets for every B-channel");
1488
1489 hc = kzalloc(sizeof(struct l1oip), GFP_ATOMIC);
1490 if (!hc) {
1491 printk(KERN_ERR "No kmem for L1-over-IP driver.\n");
1492 l1oip_cleanup();
1493 return -ENOMEM;
1494 }
1495 INIT_WORK(&hc->workq, (void *)l1oip_send_bh);
1496
1497 spin_lock(&l1oip_lock);
1498 list_add_tail(&hc->list, &l1oip_ilist);
1499 spin_unlock(&l1oip_lock);
1500
1501 ret = init_card(hc, pri, bundle);
1502 if (ret) {
1503 l1oip_cleanup();
1504 return ret;
1505 }
1506
1507 l1oip_cnt++;
1508 }
1509 printk(KERN_INFO "%d virtual devices registered\n", l1oip_cnt);
1510 return 0;
1511 }
1512
1513 module_init(l1oip_init);
1514 module_exit(l1oip_cleanup);
Linux with added FPC-III support