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