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