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