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