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