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