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
241static const char *l1oip_revision = "2.00";
242
243static int l1oip_cnt;
244static spinlock_t l1oip_lock;
245static struct list_head l1oip_ilist;
246
247#define MAX_CARDS	16
248static u_int type[MAX_CARDS];
249static u_int codec[MAX_CARDS];
250static u_int ip[MAX_CARDS * 4];
251static u_int port[MAX_CARDS];
252static u_int remoteport[MAX_CARDS];
253static u_int ondemand[MAX_CARDS];
254static u_int limit[MAX_CARDS];
255static u_int id[MAX_CARDS];
256static int debug;
257static int ulaw;
258
259MODULE_AUTHOR("Andreas Eversberg");
260MODULE_LICENSE("GPL");
261module_param_array(type, uint, NULL, S_IRUGO | S_IWUSR);
262module_param_array(codec, uint, NULL, S_IRUGO | S_IWUSR);
263module_param_array(ip, uint, NULL, S_IRUGO | S_IWUSR);
264module_param_array(port, uint, NULL, S_IRUGO | S_IWUSR);
265module_param_array(remoteport, uint, NULL, S_IRUGO | S_IWUSR);
266module_param_array(ondemand, uint, NULL, S_IRUGO | S_IWUSR);
267module_param_array(limit, uint, NULL, S_IRUGO | S_IWUSR);
268module_param_array(id, uint, NULL, S_IRUGO | S_IWUSR);
269module_param(ulaw, uint, S_IRUGO | S_IWUSR);
270module_param(debug, uint, S_IRUGO | S_IWUSR);
271
272/*
273 * send a frame via socket, if open and restart timer
274 */
275static int
276l1oip_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 */
361static void
362l1oip_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 */
461static void
462l1oip_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
547multiframe:
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 */
647static int
648l1oip_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
756fail:
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
774static void
775l1oip_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
799static int
800l1oip_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
825static void
826l1oip_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 */
842static void
843l1oip_keepalive(void *data)
844{
845	struct l1oip *hc = (struct l1oip *)data;
846
847	schedule_work(&hc->workq);
848}
849
850static void
851l1oip_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 */
885static int
886handle_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
948static int
949channel_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
993static int
994open_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
1020static int
1021open_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
1046static int
1047l1oip_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
1101static int
1102handle_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
1184static int
1185channel_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
1212static int
1213l1oip_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 */
1244static void
1245release_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
1284static void
1285l1oip_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 */
1299static int
1300init_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
1452static int __init
1453l1oip_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
1524module_init(l1oip_init);
1525module_exit(l1oip_cleanup);
1526