4 * Copyright (C) 2001 Convergence integrated media GmbH
5 * Ralph Metzler <ralph@convergence.de>
6 * Copyright (C) 2002 Ralph Metzler <rjkm@metzlerbros.de>
8 * ULE Decapsulation code:
9 * Copyright (C) 2003, 2004 gcs - Global Communication & Services GmbH.
10 * and Department of Scientific Computing
11 * Paris Lodron University of Salzburg.
12 * Hilmar Linder <hlinder@cosy.sbg.ac.at>
13 * and Wolfram Stering <wstering@cosy.sbg.ac.at>
15 * ULE Decaps according to RFC 4326.
17 * This program is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU General Public License
19 * as published by the Free Software Foundation; either version 2
20 * of the License, or (at your option) any later version.
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
30 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
35 * Feb 2004: hl/ws v1: Implementing draft-fair-ipdvb-ule-01.txt
37 * Dec 2004: hl/ws v2: Implementing draft-ietf-ipdvb-ule-03.txt:
38 * ULE Extension header handling.
39 * Bugreports by Moritz Vieth and Hanno Tersteegen,
40 * Fraunhofer Institute for Open Communication Systems
41 * Competence Center for Advanced Satellite Communications.
42 * Bugfixes and robustness improvements.
43 * Filtering on dest MAC addresses, if present (D-Bit = 0)
44 * ULE_DEBUG compile-time option.
45 * Apr 2006: cp v3: Bugfixes and compliency with RFC 4326 (ULE) by
46 * Christian Praehauser <cpraehaus@cosy.sbg.ac.at>,
47 * Paris Lodron University of Salzburg.
51 * FIXME / TODO (dvb_net.c):
53 * Unloading does not work for 2.6.9 kernels: a refcount doesn't go to zero.
57 #define pr_fmt(fmt) "dvb_net: " fmt
59 #include <linux/module.h>
60 #include <linux/kernel.h>
61 #include <linux/netdevice.h>
62 #include <linux/etherdevice.h>
63 #include <linux/dvb/net.h>
64 #include <linux/uio.h>
65 #include <asm/uaccess.h>
66 #include <linux/crc32.h>
67 #include <linux/mutex.h>
68 #include <linux/sched.h>
70 #include "dvb_demux.h"
73 static inline __u32
iov_crc32( __u32 c
, struct kvec
*iov
, unsigned int cnt
)
76 for (j
= 0; j
< cnt
; j
++)
77 c
= crc32_be( c
, iov
[j
].iov_base
, iov
[j
].iov_len
);
82 #define DVB_NET_MULTICAST_MAX 10
88 static void hexdump(const unsigned char *buf
, unsigned short len
)
90 print_hex_dump_debug("", DUMP_PREFIX_OFFSET
, 16, 1, buf
, len
, true);
98 struct net_device
*net
;
100 struct dmx_demux
*demux
;
101 struct dmx_section_feed
*secfeed
;
102 struct dmx_section_filter
*secfilter
;
103 struct dmx_ts_feed
*tsfeed
;
105 struct dmx_section_filter
*multi_secfilter
[DVB_NET_MULTICAST_MAX
];
106 unsigned char multi_macs
[DVB_NET_MULTICAST_MAX
][6];
108 #define RX_MODE_UNI 0
109 #define RX_MODE_MULTI 1
110 #define RX_MODE_ALL_MULTI 2
111 #define RX_MODE_PROMISC 3
112 struct work_struct set_multicast_list_wq
;
113 struct work_struct restart_net_feed_wq
;
114 unsigned char feedtype
; /* Either FEED_TYPE_ or FEED_TYPE_ULE */
115 int need_pusi
; /* Set to 1, if synchronization on PUSI required. */
116 unsigned char tscc
; /* TS continuity counter after sync on PUSI. */
117 struct sk_buff
*ule_skb
; /* ULE SNDU decodes into this buffer. */
118 unsigned char *ule_next_hdr
; /* Pointer into skb to next ULE extension header. */
119 unsigned short ule_sndu_len
; /* ULE SNDU length in bytes, w/o D-Bit. */
120 unsigned short ule_sndu_type
; /* ULE SNDU type field, complete. */
121 unsigned char ule_sndu_type_1
; /* ULE SNDU type field, if split across 2 TS cells. */
122 unsigned char ule_dbit
; /* Whether the DestMAC address present
123 * or not (bit is set). */
124 unsigned char ule_bridged
; /* Whether the ULE_BRIDGED extension header was found. */
125 int ule_sndu_remain
; /* Nr. of bytes still required for current ULE SNDU. */
126 unsigned long ts_count
; /* Current ts cell counter. */
132 * Determine the packet's protocol ID. The rule here is that we
133 * assume 802.3 if the type field is short enough to be a length.
134 * This is normal practice and works for any 'now in use' protocol.
136 * stolen from eth.c out of the linux kernel, hacked for dvb-device
137 * by Michael Holzt <kju@debian.org>
139 static __be16
dvb_net_eth_type_trans(struct sk_buff
*skb
,
140 struct net_device
*dev
)
145 skb_reset_mac_header(skb
);
146 skb_pull(skb
,dev
->hard_header_len
);
149 if (*eth
->h_dest
& 1) {
150 if(ether_addr_equal(eth
->h_dest
,dev
->broadcast
))
151 skb
->pkt_type
=PACKET_BROADCAST
;
153 skb
->pkt_type
=PACKET_MULTICAST
;
156 if (ntohs(eth
->h_proto
) >= ETH_P_802_3_MIN
)
162 * This is a magic hack to spot IPX packets. Older Novell breaks
163 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
164 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
165 * won't work for fault tolerant netware but does for the rest.
167 if (*(unsigned short *)rawp
== 0xFFFF)
168 return htons(ETH_P_802_3
);
173 return htons(ETH_P_802_2
);
184 /* ULE Extension Header handlers. */
187 #define ULE_BRIDGED 1
189 #define ULE_OPTEXTHDR_PADDING 0
191 static int ule_test_sndu( struct dvb_net_priv
*p
)
196 static int ule_bridged_sndu( struct dvb_net_priv
*p
)
198 struct ethhdr
*hdr
= (struct ethhdr
*) p
->ule_next_hdr
;
199 if(ntohs(hdr
->h_proto
) < ETH_P_802_3_MIN
) {
200 int framelen
= p
->ule_sndu_len
- ((p
->ule_next_hdr
+sizeof(struct ethhdr
)) - p
->ule_skb
->data
);
201 /* A frame Type < ETH_P_802_3_MIN for a bridged frame, introduces a LLC Length field. */
202 if(framelen
!= ntohs(hdr
->h_proto
)) {
208 * "A bridged SNDU is a Mandatory Extension Header of Type 1.
209 * It must be the final (or only) extension header specified in the header chain of a SNDU."
210 * The 'ule_bridged' flag will cause the extension header processing loop to terminate.
216 static int ule_exthdr_padding(struct dvb_net_priv
*p
)
221 /** Handle ULE extension headers.
222 * Function is called after a successful CRC32 verification of an ULE SNDU to complete its decoding.
223 * Returns: >= 0: nr. of bytes consumed by next extension header
224 * -1: Mandatory extension header that is not recognized or TEST SNDU; discard.
226 static int handle_one_ule_extension( struct dvb_net_priv
*p
)
228 /* Table of mandatory extension header handlers. The header type is the index. */
229 static int (*ule_mandatory_ext_handlers
[255])( struct dvb_net_priv
*p
) =
230 { [0] = ule_test_sndu
, [1] = ule_bridged_sndu
, [2] = NULL
, };
232 /* Table of optional extension header handlers. The header type is the index. */
233 static int (*ule_optional_ext_handlers
[255])( struct dvb_net_priv
*p
) =
234 { [0] = ule_exthdr_padding
, [1] = NULL
, };
237 unsigned char hlen
= (p
->ule_sndu_type
& 0x0700) >> 8;
238 unsigned char htype
= p
->ule_sndu_type
& 0x00FF;
240 /* Discriminate mandatory and optional extension headers. */
242 /* Mandatory extension header */
243 if (ule_mandatory_ext_handlers
[htype
]) {
244 ext_len
= ule_mandatory_ext_handlers
[htype
]( p
);
246 p
->ule_next_hdr
+= ext_len
;
247 if (!p
->ule_bridged
) {
248 p
->ule_sndu_type
= ntohs(*(__be16
*)p
->ule_next_hdr
);
249 p
->ule_next_hdr
+= 2;
251 p
->ule_sndu_type
= ntohs(*(__be16
*)(p
->ule_next_hdr
+ ((p
->ule_dbit
? 2 : 3) * ETH_ALEN
)));
252 /* This assures the extension handling loop will terminate. */
255 // else: extension handler failed or SNDU should be discarded
257 ext_len
= -1; /* SNDU has to be discarded. */
259 /* Optional extension header. Calculate the length. */
261 /* Process the optional extension header according to its type. */
262 if (ule_optional_ext_handlers
[htype
])
263 (void)ule_optional_ext_handlers
[htype
]( p
);
264 p
->ule_next_hdr
+= ext_len
;
265 p
->ule_sndu_type
= ntohs( *(__be16
*)(p
->ule_next_hdr
-2) );
267 * note: the length of the next header type is included in the
268 * length of THIS optional extension header
275 static int handle_ule_extensions( struct dvb_net_priv
*p
)
277 int total_ext_len
= 0, l
;
279 p
->ule_next_hdr
= p
->ule_skb
->data
;
281 l
= handle_one_ule_extension( p
);
283 return l
; /* Stop extension header processing and discard SNDU. */
286 pr_debug("ule_next_hdr=%p, ule_sndu_type=%i, l=%i, total_ext_len=%i\n",
287 p
->ule_next_hdr
, (int)p
->ule_sndu_type
,
291 } while (p
->ule_sndu_type
< ETH_P_802_3_MIN
);
293 return total_ext_len
;
297 /** Prepare for a new ULE SNDU: reset the decoder state. */
298 static inline void reset_ule( struct dvb_net_priv
*p
)
301 p
->ule_next_hdr
= NULL
;
303 p
->ule_sndu_type
= 0;
304 p
->ule_sndu_type_1
= 0;
305 p
->ule_sndu_remain
= 0;
311 * Decode ULE SNDUs according to draft-ietf-ipdvb-ule-03.txt from a sequence of
312 * TS cells of a single PID.
314 static void dvb_net_ule( struct net_device
*dev
, const u8
*buf
, size_t buf_len
)
316 struct dvb_net_priv
*priv
= netdev_priv(dev
);
317 unsigned long skipped
= 0L;
318 const u8
*ts
, *ts_end
, *from_where
= NULL
;
319 u8 ts_remain
= 0, how_much
= 0, new_ts
= 1;
320 struct ethhdr
*ethh
= NULL
;
324 /* The code inside ULE_DEBUG keeps a history of the last 100 TS cells processed. */
325 static unsigned char ule_hist
[100*TS_SZ
];
326 static unsigned char *ule_where
= ule_hist
, ule_dump
;
329 /* For all TS cells in current buffer.
330 * Appearently, we are called for every single TS cell.
332 for (ts
= buf
, ts_end
= buf
+ buf_len
; ts
< ts_end
; /* no default incr. */ ) {
335 /* We are about to process a new TS cell. */
338 if (ule_where
>= &ule_hist
[100*TS_SZ
]) ule_where
= ule_hist
;
339 memcpy( ule_where
, ts
, TS_SZ
);
341 hexdump( ule_where
, TS_SZ
);
347 /* Check TS error conditions: sync_byte, transport_error_indicator, scrambling_control . */
348 if ((ts
[0] != TS_SYNC
) || (ts
[1] & TS_TEI
) || ((ts
[3] & TS_SC
) != 0)) {
349 pr_warn("%lu: Invalid TS cell: SYNC %#x, TEI %u, SC %#x.\n",
350 priv
->ts_count
, ts
[0],
351 (ts
[1] & TS_TEI
) >> 7,
352 (ts
[3] & TS_SC
) >> 6);
354 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
356 dev_kfree_skb( priv
->ule_skb
);
357 /* Prepare for next SNDU. */
358 dev
->stats
.rx_errors
++;
359 dev
->stats
.rx_frame_errors
++;
364 /* Continue with next TS cell. */
373 /* Synchronize on PUSI, if required. */
374 if (priv
->need_pusi
) {
375 if (ts
[1] & TS_PUSI
) {
376 /* Find beginning of first ULE SNDU in current TS cell. */
377 /* Synchronize continuity counter. */
378 priv
->tscc
= ts
[3] & 0x0F;
379 /* There is a pointer field here. */
380 if (ts
[4] > ts_remain
) {
381 pr_err("%lu: Invalid ULE packet (pointer field %d)\n",
382 priv
->ts_count
, ts
[4]);
387 /* Skip to destination of pointer field. */
388 from_where
= &ts
[5] + ts
[4];
389 ts_remain
-= 1 + ts
[4];
400 /* Check continuity counter. */
401 if ((ts
[3] & 0x0F) == priv
->tscc
)
402 priv
->tscc
= (priv
->tscc
+ 1) & 0x0F;
404 /* TS discontinuity handling: */
405 pr_warn("%lu: TS discontinuity: got %#x, expected %#x.\n",
406 priv
->ts_count
, ts
[3] & 0x0F,
408 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
410 dev_kfree_skb( priv
->ule_skb
);
411 /* Prepare for next SNDU. */
412 // reset_ule(priv); moved to below.
413 dev
->stats
.rx_errors
++;
414 dev
->stats
.rx_frame_errors
++;
417 /* skip to next PUSI. */
421 /* If we still have an incomplete payload, but PUSI is
422 * set; some TS cells are missing.
423 * This is only possible here, if we missed exactly 16 TS
424 * cells (continuity counter wrap). */
425 if (ts
[1] & TS_PUSI
) {
426 if (! priv
->need_pusi
) {
427 if (!(*from_where
< (ts_remain
-1)) || *from_where
!= priv
->ule_sndu_remain
) {
428 /* Pointer field is invalid. Drop this TS cell and any started ULE SNDU. */
429 pr_warn("%lu: Invalid pointer field: %u.\n",
433 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
436 dev_kfree_skb(priv
->ule_skb
);
439 if (error
|| priv
->ule_sndu_remain
) {
440 dev
->stats
.rx_errors
++;
441 dev
->stats
.rx_frame_errors
++;
449 /* Skip pointer field (we're processing a
450 * packed payload). */
456 if (priv
->ule_sndu_remain
> 183) {
457 /* Current SNDU lacks more data than there could be available in the
458 * current TS cell. */
459 dev
->stats
.rx_errors
++;
460 dev
->stats
.rx_length_errors
++;
461 pr_warn("%lu: Expected %d more SNDU bytes, but got PUSI (pf %d, ts_remain %d). Flushing incomplete payload.\n",
463 priv
->ule_sndu_remain
,
465 dev_kfree_skb(priv
->ule_skb
);
466 /* Prepare for next SNDU. */
468 /* Resync: go to where pointer field points to: start of next ULE SNDU. */
475 /* Check if new payload needs to be started. */
476 if (priv
->ule_skb
== NULL
) {
477 /* Start a new payload with skb.
478 * Find ULE header. It is only guaranteed that the
479 * length field (2 bytes) is contained in the current
481 * Check ts_remain has to be >= 2 here. */
483 pr_warn("Invalid payload packing: only %d bytes left in TS. Resyncing.\n",
485 priv
->ule_sndu_len
= 0;
491 if (! priv
->ule_sndu_len
) {
492 /* Got at least two bytes, thus extrace the SNDU length. */
493 priv
->ule_sndu_len
= from_where
[0] << 8 | from_where
[1];
494 if (priv
->ule_sndu_len
& 0x8000) {
495 /* D-Bit is set: no dest mac present. */
496 priv
->ule_sndu_len
&= 0x7FFF;
501 if (priv
->ule_sndu_len
< 5) {
502 pr_warn("%lu: Invalid ULE SNDU length %u. Resyncing.\n",
505 dev
->stats
.rx_errors
++;
506 dev
->stats
.rx_length_errors
++;
507 priv
->ule_sndu_len
= 0;
514 ts_remain
-= 2; /* consume the 2 bytes SNDU length. */
518 priv
->ule_sndu_remain
= priv
->ule_sndu_len
+ 2;
520 * State of current TS:
521 * ts_remain (remaining bytes in the current TS cell)
522 * 0 ule_type is not available now, we need the next TS cell
523 * 1 the first byte of the ule_type is present
524 * >=2 full ULE header present, maybe some payload data as well.
528 priv
->ule_sndu_remain
--;
529 priv
->ule_sndu_type
= from_where
[0] << 8;
530 priv
->ule_sndu_type_1
= 1; /* first byte of ule_type is set. */
531 ts_remain
-= 1; from_where
+= 1;
532 /* Continue w/ next TS. */
539 default: /* complete ULE header is present in current TS. */
540 /* Extract ULE type field. */
541 if (priv
->ule_sndu_type_1
) {
542 priv
->ule_sndu_type_1
= 0;
543 priv
->ule_sndu_type
|= from_where
[0];
544 from_where
+= 1; /* points to payload start. */
547 /* Complete type is present in new TS. */
548 priv
->ule_sndu_type
= from_where
[0] << 8 | from_where
[1];
549 from_where
+= 2; /* points to payload start. */
555 /* Allocate the skb (decoder target buffer) with the correct size, as follows:
556 * prepare for the largest case: bridged SNDU with MAC address (dbit = 0). */
557 priv
->ule_skb
= dev_alloc_skb( priv
->ule_sndu_len
+ ETH_HLEN
+ ETH_ALEN
);
558 if (priv
->ule_skb
== NULL
) {
559 pr_notice("%s: Memory squeeze, dropping packet.\n",
561 dev
->stats
.rx_dropped
++;
565 /* This includes the CRC32 _and_ dest mac, if !dbit. */
566 priv
->ule_sndu_remain
= priv
->ule_sndu_len
;
567 priv
->ule_skb
->dev
= dev
;
568 /* Leave space for Ethernet or bridged SNDU header (eth hdr plus one MAC addr). */
569 skb_reserve( priv
->ule_skb
, ETH_HLEN
+ ETH_ALEN
);
572 /* Copy data into our current skb. */
573 how_much
= min(priv
->ule_sndu_remain
, (int)ts_remain
);
574 memcpy(skb_put(priv
->ule_skb
, how_much
), from_where
, how_much
);
575 priv
->ule_sndu_remain
-= how_much
;
576 ts_remain
-= how_much
;
577 from_where
+= how_much
;
579 /* Check for complete payload. */
580 if (priv
->ule_sndu_remain
<= 0) {
581 /* Check CRC32, we've got it in our skb already. */
582 __be16 ulen
= htons(priv
->ule_sndu_len
);
583 __be16 utype
= htons(priv
->ule_sndu_type
);
585 struct kvec iov
[3] = {
586 { &ulen
, sizeof ulen
},
587 { &utype
, sizeof utype
},
588 { priv
->ule_skb
->data
, priv
->ule_skb
->len
- 4 }
590 u32 ule_crc
= ~0L, expected_crc
;
591 if (priv
->ule_dbit
) {
592 /* Set D-bit for CRC32 verification,
593 * if it was set originally. */
594 ulen
|= htons(0x8000);
597 ule_crc
= iov_crc32(ule_crc
, iov
, 3);
598 tail
= skb_tail_pointer(priv
->ule_skb
);
599 expected_crc
= *(tail
- 4) << 24 |
603 if (ule_crc
!= expected_crc
) {
604 pr_warn("%lu: CRC32 check FAILED: %08x / %08x, SNDU len %d type %#x, ts_remain %d, next 2: %x.\n",
605 priv
->ts_count
, ule_crc
, expected_crc
,
606 priv
->ule_sndu_len
, priv
->ule_sndu_type
,
608 ts_remain
> 2 ? *(unsigned short *)from_where
: 0);
611 hexdump( iov
[0].iov_base
, iov
[0].iov_len
);
612 hexdump( iov
[1].iov_base
, iov
[1].iov_len
);
613 hexdump( iov
[2].iov_base
, iov
[2].iov_len
);
615 if (ule_where
== ule_hist
) {
616 hexdump( &ule_hist
[98*TS_SZ
], TS_SZ
);
617 hexdump( &ule_hist
[99*TS_SZ
], TS_SZ
);
618 } else if (ule_where
== &ule_hist
[TS_SZ
]) {
619 hexdump( &ule_hist
[99*TS_SZ
], TS_SZ
);
620 hexdump( ule_hist
, TS_SZ
);
622 hexdump( ule_where
- TS_SZ
- TS_SZ
, TS_SZ
);
623 hexdump( ule_where
- TS_SZ
, TS_SZ
);
628 dev
->stats
.rx_errors
++;
629 dev
->stats
.rx_crc_errors
++;
630 dev_kfree_skb(priv
->ule_skb
);
632 /* CRC32 verified OK. */
633 u8 dest_addr
[ETH_ALEN
];
634 static const u8 bc_addr
[ETH_ALEN
] =
635 { [ 0 ... ETH_ALEN
-1] = 0xff };
637 /* CRC32 was OK. Remove it from skb. */
638 priv
->ule_skb
->tail
-= 4;
639 priv
->ule_skb
->len
-= 4;
641 if (!priv
->ule_dbit
) {
643 * The destination MAC address is the
644 * next data in the skb. It comes
645 * before any extension headers.
647 * Check if the payload of this SNDU
648 * should be passed up the stack.
650 register int drop
= 0;
651 if (priv
->rx_mode
!= RX_MODE_PROMISC
) {
652 if (priv
->ule_skb
->data
[0] & 0x01) {
653 /* multicast or broadcast */
654 if (!ether_addr_equal(priv
->ule_skb
->data
, bc_addr
)) {
656 if (priv
->rx_mode
== RX_MODE_MULTI
) {
658 for(i
= 0; i
< priv
->multi_num
&&
659 !ether_addr_equal(priv
->ule_skb
->data
,
660 priv
->multi_macs
[i
]); i
++)
662 if (i
== priv
->multi_num
)
664 } else if (priv
->rx_mode
!= RX_MODE_ALL_MULTI
)
665 drop
= 1; /* no broadcast; */
666 /* else: all multicast mode: accept all multicast packets */
668 /* else: broadcast */
670 else if (!ether_addr_equal(priv
->ule_skb
->data
, dev
->dev_addr
))
672 /* else: destination address matches the MAC address of our receiver device */
674 /* else: promiscuous mode; pass everything up the stack */
678 netdev_dbg(dev
, "Dropping SNDU: MAC destination address does not match: dest addr: %pM, dev addr: %pM\n",
679 priv
->ule_skb
->data
, dev
->dev_addr
);
681 dev_kfree_skb(priv
->ule_skb
);
686 skb_copy_from_linear_data(priv
->ule_skb
,
689 skb_pull(priv
->ule_skb
, ETH_ALEN
);
693 /* Handle ULE Extension Headers. */
694 if (priv
->ule_sndu_type
< ETH_P_802_3_MIN
) {
695 /* There is an extension header. Handle it accordingly. */
696 int l
= handle_ule_extensions(priv
);
698 /* Mandatory extension header unknown or TEST SNDU. Drop it. */
699 // pr_warn("Dropping SNDU, extension headers.\n" );
700 dev_kfree_skb(priv
->ule_skb
);
703 skb_pull(priv
->ule_skb
, l
);
707 * Construct/assure correct ethernet header.
708 * Note: in bridged mode (priv->ule_bridged !=
709 * 0) we already have the (original) ethernet
710 * header at the start of the payload (after
711 * optional dest. address and any extension
715 if (!priv
->ule_bridged
) {
716 skb_push(priv
->ule_skb
, ETH_HLEN
);
717 ethh
= (struct ethhdr
*)priv
->ule_skb
->data
;
718 if (!priv
->ule_dbit
) {
719 /* dest_addr buffer is only valid if priv->ule_dbit == 0 */
720 memcpy(ethh
->h_dest
, dest_addr
, ETH_ALEN
);
721 eth_zero_addr(ethh
->h_source
);
723 else /* zeroize source and dest */
724 memset( ethh
, 0, ETH_ALEN
*2 );
726 ethh
->h_proto
= htons(priv
->ule_sndu_type
);
728 /* else: skb is in correct state; nothing to do. */
729 priv
->ule_bridged
= 0;
731 /* Stuff into kernel's protocol stack. */
732 priv
->ule_skb
->protocol
= dvb_net_eth_type_trans(priv
->ule_skb
, dev
);
733 /* If D-bit is set (i.e. destination MAC address not present),
734 * receive the packet anyhow. */
735 /* if (priv->ule_dbit && skb->pkt_type == PACKET_OTHERHOST)
736 priv->ule_skb->pkt_type = PACKET_HOST; */
737 dev
->stats
.rx_packets
++;
738 dev
->stats
.rx_bytes
+= priv
->ule_skb
->len
;
739 netif_rx(priv
->ule_skb
);
742 /* Prepare for next SNDU. */
746 /* More data in current TS (look at the bytes following the CRC32)? */
747 if (ts_remain
>= 2 && *((unsigned short *)from_where
) != 0xFFFF) {
748 /* Next ULE SNDU starts right there. */
750 priv
->ule_skb
= NULL
;
751 priv
->ule_sndu_type_1
= 0;
752 priv
->ule_sndu_len
= 0;
753 // pr_warn("More data in current TS: [%#x %#x %#x %#x]\n",
754 // *(from_where + 0), *(from_where + 1),
755 // *(from_where + 2), *(from_where + 3));
756 // pr_warn("ts @ %p, stopped @ %p:\n", ts, from_where + 0);
762 if (priv
->ule_skb
== NULL
) {
764 priv
->ule_sndu_type_1
= 0;
765 priv
->ule_sndu_len
= 0;
768 } /* for all available TS cells */
771 static int dvb_net_ts_callback(const u8
*buffer1
, size_t buffer1_len
,
772 const u8
*buffer2
, size_t buffer2_len
,
773 struct dmx_ts_feed
*feed
)
775 struct net_device
*dev
= feed
->priv
;
778 pr_warn("buffer2 not NULL: %p.\n", buffer2
);
779 if (buffer1_len
> 32768)
780 pr_warn("length > 32k: %zu.\n", buffer1_len
);
781 /* pr_info("TS callback: %u bytes, %u TS cells @ %p.\n",
782 buffer1_len, buffer1_len / TS_SZ, buffer1); */
783 dvb_net_ule(dev
, buffer1
, buffer1_len
);
788 static void dvb_net_sec(struct net_device
*dev
,
789 const u8
*pkt
, int pkt_len
)
793 struct net_device_stats
*stats
= &dev
->stats
;
796 /* note: pkt_len includes a 32bit checksum */
798 pr_warn("%s: IP/MPE packet length = %d too small.\n",
801 stats
->rx_length_errors
++;
804 /* it seems some ISPs manage to screw up here, so we have to
805 * relax the error checks... */
807 if ((pkt
[5] & 0xfd) != 0xc1) {
808 /* drop scrambled or broken packets */
810 if ((pkt
[5] & 0x3c) != 0x00) {
814 stats
->rx_crc_errors
++;
818 /* handle LLC/SNAP, see rfc-1042 */
819 if (pkt_len
< 24 || memcmp(&pkt
[12], "\xaa\xaa\x03\0\0\0", 6)) {
826 /* FIXME: assemble datagram from multiple sections */
828 stats
->rx_frame_errors
++;
832 /* we have 14 byte ethernet header (ip header follows);
833 * 12 byte MPE header; 4 byte checksum; + 2 byte alignment, 8 byte LLC/SNAP
835 if (!(skb
= dev_alloc_skb(pkt_len
- 4 - 12 + 14 + 2 - snap
))) {
836 //pr_notice("%s: Memory squeeze, dropping packet.\n", dev->name);
840 skb_reserve(skb
, 2); /* longword align L3 header */
843 /* copy L3 payload */
844 eth
= (u8
*) skb_put(skb
, pkt_len
- 12 - 4 + 14 - snap
);
845 memcpy(eth
+ 14, pkt
+ 12 + snap
, pkt_len
- 12 - 4 - snap
);
847 /* create ethernet header: */
855 eth
[6]=eth
[7]=eth
[8]=eth
[9]=eth
[10]=eth
[11]=0;
861 /* protocol numbers are from rfc-1700 or
862 * http://www.iana.org/assignments/ethernet-numbers
864 if (pkt
[12] >> 4 == 6) { /* version field from IP header */
865 eth
[12] = 0x86; /* IPv6 */
868 eth
[12] = 0x08; /* IPv4 */
873 skb
->protocol
= dvb_net_eth_type_trans(skb
, dev
);
876 stats
->rx_bytes
+=skb
->len
;
880 static int dvb_net_sec_callback(const u8
*buffer1
, size_t buffer1_len
,
881 const u8
*buffer2
, size_t buffer2_len
,
882 struct dmx_section_filter
*filter
)
884 struct net_device
*dev
= filter
->priv
;
887 * we rely on the DVB API definition where exactly one complete
888 * section is delivered in buffer1
890 dvb_net_sec (dev
, buffer1
, buffer1_len
);
894 static int dvb_net_tx(struct sk_buff
*skb
, struct net_device
*dev
)
900 static u8 mask_normal
[6]={0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
901 static u8 mask_allmulti
[6]={0xff, 0xff, 0xff, 0x00, 0x00, 0x00};
902 static u8 mac_allmulti
[6]={0x01, 0x00, 0x5e, 0x00, 0x00, 0x00};
903 static u8 mask_promisc
[6]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
905 static int dvb_net_filter_sec_set(struct net_device
*dev
,
906 struct dmx_section_filter
**secfilter
,
907 u8
*mac
, u8
*mac_mask
)
909 struct dvb_net_priv
*priv
= netdev_priv(dev
);
913 ret
= priv
->secfeed
->allocate_filter(priv
->secfeed
, secfilter
);
915 pr_err("%s: could not get filter\n", dev
->name
);
919 (*secfilter
)->priv
=(void *) dev
;
921 memset((*secfilter
)->filter_value
, 0x00, DMX_MAX_FILTER_SIZE
);
922 memset((*secfilter
)->filter_mask
, 0x00, DMX_MAX_FILTER_SIZE
);
923 memset((*secfilter
)->filter_mode
, 0xff, DMX_MAX_FILTER_SIZE
);
925 (*secfilter
)->filter_value
[0]=0x3e;
926 (*secfilter
)->filter_value
[3]=mac
[5];
927 (*secfilter
)->filter_value
[4]=mac
[4];
928 (*secfilter
)->filter_value
[8]=mac
[3];
929 (*secfilter
)->filter_value
[9]=mac
[2];
930 (*secfilter
)->filter_value
[10]=mac
[1];
931 (*secfilter
)->filter_value
[11]=mac
[0];
933 (*secfilter
)->filter_mask
[0] = 0xff;
934 (*secfilter
)->filter_mask
[3] = mac_mask
[5];
935 (*secfilter
)->filter_mask
[4] = mac_mask
[4];
936 (*secfilter
)->filter_mask
[8] = mac_mask
[3];
937 (*secfilter
)->filter_mask
[9] = mac_mask
[2];
938 (*secfilter
)->filter_mask
[10] = mac_mask
[1];
939 (*secfilter
)->filter_mask
[11]=mac_mask
[0];
941 netdev_dbg(dev
, "filter mac=%pM mask=%pM\n", mac
, mac_mask
);
946 static int dvb_net_feed_start(struct net_device
*dev
)
949 struct dvb_net_priv
*priv
= netdev_priv(dev
);
950 struct dmx_demux
*demux
= priv
->demux
;
951 unsigned char *mac
= (unsigned char *) dev
->dev_addr
;
953 netdev_dbg(dev
, "rx_mode %i\n", priv
->rx_mode
);
954 mutex_lock(&priv
->mutex
);
955 if (priv
->tsfeed
|| priv
->secfeed
|| priv
->secfilter
|| priv
->multi_secfilter
[0])
956 pr_err("%s: BUG %d\n", __func__
, __LINE__
);
959 priv
->secfilter
=NULL
;
962 if (priv
->feedtype
== DVB_NET_FEEDTYPE_MPE
) {
963 netdev_dbg(dev
, "alloc secfeed\n");
964 ret
=demux
->allocate_section_feed(demux
, &priv
->secfeed
,
965 dvb_net_sec_callback
);
967 pr_err("%s: could not allocate section feed\n",
972 ret
= priv
->secfeed
->set(priv
->secfeed
, priv
->pid
, 32768, 1);
975 pr_err("%s: could not set section feed\n", dev
->name
);
976 priv
->demux
->release_section_feed(priv
->demux
, priv
->secfeed
);
981 if (priv
->rx_mode
!= RX_MODE_PROMISC
) {
982 netdev_dbg(dev
, "set secfilter\n");
983 dvb_net_filter_sec_set(dev
, &priv
->secfilter
, mac
, mask_normal
);
986 switch (priv
->rx_mode
) {
988 for (i
= 0; i
< priv
->multi_num
; i
++) {
989 netdev_dbg(dev
, "set multi_secfilter[%d]\n", i
);
990 dvb_net_filter_sec_set(dev
, &priv
->multi_secfilter
[i
],
991 priv
->multi_macs
[i
], mask_normal
);
994 case RX_MODE_ALL_MULTI
:
996 netdev_dbg(dev
, "set multi_secfilter[0]\n");
997 dvb_net_filter_sec_set(dev
, &priv
->multi_secfilter
[0],
998 mac_allmulti
, mask_allmulti
);
1000 case RX_MODE_PROMISC
:
1002 netdev_dbg(dev
, "set secfilter\n");
1003 dvb_net_filter_sec_set(dev
, &priv
->secfilter
, mac
, mask_promisc
);
1007 netdev_dbg(dev
, "start filtering\n");
1008 priv
->secfeed
->start_filtering(priv
->secfeed
);
1009 } else if (priv
->feedtype
== DVB_NET_FEEDTYPE_ULE
) {
1010 ktime_t timeout
= ns_to_ktime(10 * NSEC_PER_MSEC
);
1012 /* we have payloads encapsulated in TS */
1013 netdev_dbg(dev
, "alloc tsfeed\n");
1014 ret
= demux
->allocate_ts_feed(demux
, &priv
->tsfeed
, dvb_net_ts_callback
);
1016 pr_err("%s: could not allocate ts feed\n", dev
->name
);
1020 /* Set netdevice pointer for ts decaps callback. */
1021 priv
->tsfeed
->priv
= (void *)dev
;
1022 ret
= priv
->tsfeed
->set(priv
->tsfeed
,
1023 priv
->pid
, /* pid */
1024 TS_PACKET
, /* type */
1025 DMX_PES_OTHER
, /* pes type */
1026 32768, /* circular buffer size */
1027 timeout
/* timeout */
1031 pr_err("%s: could not set ts feed\n", dev
->name
);
1032 priv
->demux
->release_ts_feed(priv
->demux
, priv
->tsfeed
);
1033 priv
->tsfeed
= NULL
;
1037 netdev_dbg(dev
, "start filtering\n");
1038 priv
->tsfeed
->start_filtering(priv
->tsfeed
);
1043 mutex_unlock(&priv
->mutex
);
1047 static int dvb_net_feed_stop(struct net_device
*dev
)
1049 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1052 mutex_lock(&priv
->mutex
);
1053 if (priv
->feedtype
== DVB_NET_FEEDTYPE_MPE
) {
1054 if (priv
->secfeed
) {
1055 if (priv
->secfeed
->is_filtering
) {
1056 netdev_dbg(dev
, "stop secfeed\n");
1057 priv
->secfeed
->stop_filtering(priv
->secfeed
);
1060 if (priv
->secfilter
) {
1061 netdev_dbg(dev
, "release secfilter\n");
1062 priv
->secfeed
->release_filter(priv
->secfeed
,
1064 priv
->secfilter
=NULL
;
1067 for (i
=0; i
<priv
->multi_num
; i
++) {
1068 if (priv
->multi_secfilter
[i
]) {
1069 netdev_dbg(dev
, "release multi_filter[%d]\n",
1071 priv
->secfeed
->release_filter(priv
->secfeed
,
1072 priv
->multi_secfilter
[i
]);
1073 priv
->multi_secfilter
[i
] = NULL
;
1077 priv
->demux
->release_section_feed(priv
->demux
, priv
->secfeed
);
1078 priv
->secfeed
= NULL
;
1080 pr_err("%s: no feed to stop\n", dev
->name
);
1081 } else if (priv
->feedtype
== DVB_NET_FEEDTYPE_ULE
) {
1083 if (priv
->tsfeed
->is_filtering
) {
1084 netdev_dbg(dev
, "stop tsfeed\n");
1085 priv
->tsfeed
->stop_filtering(priv
->tsfeed
);
1087 priv
->demux
->release_ts_feed(priv
->demux
, priv
->tsfeed
);
1088 priv
->tsfeed
= NULL
;
1091 pr_err("%s: no ts feed to stop\n", dev
->name
);
1094 mutex_unlock(&priv
->mutex
);
1099 static int dvb_set_mc_filter(struct net_device
*dev
, unsigned char *addr
)
1101 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1103 if (priv
->multi_num
== DVB_NET_MULTICAST_MAX
)
1106 memcpy(priv
->multi_macs
[priv
->multi_num
], addr
, ETH_ALEN
);
1113 static void wq_set_multicast_list (struct work_struct
*work
)
1115 struct dvb_net_priv
*priv
=
1116 container_of(work
, struct dvb_net_priv
, set_multicast_list_wq
);
1117 struct net_device
*dev
= priv
->net
;
1119 dvb_net_feed_stop(dev
);
1120 priv
->rx_mode
= RX_MODE_UNI
;
1121 netif_addr_lock_bh(dev
);
1123 if (dev
->flags
& IFF_PROMISC
) {
1124 netdev_dbg(dev
, "promiscuous mode\n");
1125 priv
->rx_mode
= RX_MODE_PROMISC
;
1126 } else if ((dev
->flags
& IFF_ALLMULTI
)) {
1127 netdev_dbg(dev
, "allmulti mode\n");
1128 priv
->rx_mode
= RX_MODE_ALL_MULTI
;
1129 } else if (!netdev_mc_empty(dev
)) {
1130 struct netdev_hw_addr
*ha
;
1132 netdev_dbg(dev
, "set_mc_list, %d entries\n",
1133 netdev_mc_count(dev
));
1135 priv
->rx_mode
= RX_MODE_MULTI
;
1136 priv
->multi_num
= 0;
1138 netdev_for_each_mc_addr(ha
, dev
)
1139 dvb_set_mc_filter(dev
, ha
->addr
);
1142 netif_addr_unlock_bh(dev
);
1143 dvb_net_feed_start(dev
);
1147 static void dvb_net_set_multicast_list (struct net_device
*dev
)
1149 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1150 schedule_work(&priv
->set_multicast_list_wq
);
1154 static void wq_restart_net_feed (struct work_struct
*work
)
1156 struct dvb_net_priv
*priv
=
1157 container_of(work
, struct dvb_net_priv
, restart_net_feed_wq
);
1158 struct net_device
*dev
= priv
->net
;
1160 if (netif_running(dev
)) {
1161 dvb_net_feed_stop(dev
);
1162 dvb_net_feed_start(dev
);
1167 static int dvb_net_set_mac (struct net_device
*dev
, void *p
)
1169 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1170 struct sockaddr
*addr
=p
;
1172 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1174 if (netif_running(dev
))
1175 schedule_work(&priv
->restart_net_feed_wq
);
1181 static int dvb_net_open(struct net_device
*dev
)
1183 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1186 dvb_net_feed_start(dev
);
1191 static int dvb_net_stop(struct net_device
*dev
)
1193 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1196 return dvb_net_feed_stop(dev
);
1199 static const struct header_ops dvb_header_ops
= {
1200 .create
= eth_header
,
1201 .parse
= eth_header_parse
,
1205 static const struct net_device_ops dvb_netdev_ops
= {
1206 .ndo_open
= dvb_net_open
,
1207 .ndo_stop
= dvb_net_stop
,
1208 .ndo_start_xmit
= dvb_net_tx
,
1209 .ndo_set_rx_mode
= dvb_net_set_multicast_list
,
1210 .ndo_set_mac_address
= dvb_net_set_mac
,
1211 .ndo_change_mtu
= eth_change_mtu
,
1212 .ndo_validate_addr
= eth_validate_addr
,
1215 static void dvb_net_setup(struct net_device
*dev
)
1219 dev
->header_ops
= &dvb_header_ops
;
1220 dev
->netdev_ops
= &dvb_netdev_ops
;
1223 dev
->flags
|= IFF_NOARP
;
1226 static int get_if(struct dvb_net
*dvbnet
)
1230 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++)
1231 if (!dvbnet
->state
[i
])
1234 if (i
== DVB_NET_DEVICES_MAX
)
1241 static int dvb_net_add_if(struct dvb_net
*dvbnet
, u16 pid
, u8 feedtype
)
1243 struct net_device
*net
;
1244 struct dvb_net_priv
*priv
;
1248 if (feedtype
!= DVB_NET_FEEDTYPE_MPE
&& feedtype
!= DVB_NET_FEEDTYPE_ULE
)
1250 if ((if_num
= get_if(dvbnet
)) < 0)
1253 net
= alloc_netdev(sizeof(struct dvb_net_priv
), "dvb",
1254 NET_NAME_UNKNOWN
, dvb_net_setup
);
1258 if (dvbnet
->dvbdev
->id
)
1259 snprintf(net
->name
, IFNAMSIZ
, "dvb%d%u%d",
1260 dvbnet
->dvbdev
->adapter
->num
, dvbnet
->dvbdev
->id
, if_num
);
1262 /* compatibility fix to keep dvb0_0 format */
1263 snprintf(net
->name
, IFNAMSIZ
, "dvb%d_%d",
1264 dvbnet
->dvbdev
->adapter
->num
, if_num
);
1267 memcpy(net
->dev_addr
, dvbnet
->dvbdev
->adapter
->proposed_mac
, 6);
1269 dvbnet
->device
[if_num
] = net
;
1271 priv
= netdev_priv(net
);
1273 priv
->demux
= dvbnet
->demux
;
1275 priv
->rx_mode
= RX_MODE_UNI
;
1276 priv
->need_pusi
= 1;
1278 priv
->feedtype
= feedtype
;
1281 INIT_WORK(&priv
->set_multicast_list_wq
, wq_set_multicast_list
);
1282 INIT_WORK(&priv
->restart_net_feed_wq
, wq_restart_net_feed
);
1283 mutex_init(&priv
->mutex
);
1285 net
->base_addr
= pid
;
1287 if ((result
= register_netdev(net
)) < 0) {
1288 dvbnet
->device
[if_num
] = NULL
;
1292 pr_info("created network interface %s\n", net
->name
);
1297 static int dvb_net_remove_if(struct dvb_net
*dvbnet
, unsigned long num
)
1299 struct net_device
*net
= dvbnet
->device
[num
];
1300 struct dvb_net_priv
*priv
;
1302 if (!dvbnet
->state
[num
])
1304 priv
= netdev_priv(net
);
1309 flush_work(&priv
->set_multicast_list_wq
);
1310 flush_work(&priv
->restart_net_feed_wq
);
1311 pr_info("removed network interface %s\n", net
->name
);
1312 unregister_netdev(net
);
1313 dvbnet
->state
[num
]=0;
1314 dvbnet
->device
[num
] = NULL
;
1320 static int dvb_net_do_ioctl(struct file
*file
,
1321 unsigned int cmd
, void *parg
)
1323 struct dvb_device
*dvbdev
= file
->private_data
;
1324 struct dvb_net
*dvbnet
= dvbdev
->priv
;
1327 if (((file
->f_flags
&O_ACCMODE
)==O_RDONLY
))
1330 if (mutex_lock_interruptible(&dvbnet
->ioctl_mutex
))
1331 return -ERESTARTSYS
;
1336 struct dvb_net_if
*dvbnetif
= parg
;
1339 if (!capable(CAP_SYS_ADMIN
)) {
1344 if (!try_module_get(dvbdev
->adapter
->module
)) {
1349 result
=dvb_net_add_if(dvbnet
, dvbnetif
->pid
, dvbnetif
->feedtype
);
1351 module_put(dvbdev
->adapter
->module
);
1355 dvbnetif
->if_num
=result
;
1360 struct net_device
*netdev
;
1361 struct dvb_net_priv
*priv_data
;
1362 struct dvb_net_if
*dvbnetif
= parg
;
1364 if (dvbnetif
->if_num
>= DVB_NET_DEVICES_MAX
||
1365 !dvbnet
->state
[dvbnetif
->if_num
]) {
1370 netdev
= dvbnet
->device
[dvbnetif
->if_num
];
1372 priv_data
= netdev_priv(netdev
);
1373 dvbnetif
->pid
=priv_data
->pid
;
1374 dvbnetif
->feedtype
=priv_data
->feedtype
;
1379 if (!capable(CAP_SYS_ADMIN
)) {
1383 if ((unsigned long) parg
>= DVB_NET_DEVICES_MAX
) {
1387 ret
= dvb_net_remove_if(dvbnet
, (unsigned long) parg
);
1389 module_put(dvbdev
->adapter
->module
);
1393 /* binary compatibility cruft */
1394 case __NET_ADD_IF_OLD
:
1396 struct __dvb_net_if_old
*dvbnetif
= parg
;
1399 if (!capable(CAP_SYS_ADMIN
)) {
1404 if (!try_module_get(dvbdev
->adapter
->module
)) {
1409 result
=dvb_net_add_if(dvbnet
, dvbnetif
->pid
, DVB_NET_FEEDTYPE_MPE
);
1411 module_put(dvbdev
->adapter
->module
);
1415 dvbnetif
->if_num
=result
;
1418 case __NET_GET_IF_OLD
:
1420 struct net_device
*netdev
;
1421 struct dvb_net_priv
*priv_data
;
1422 struct __dvb_net_if_old
*dvbnetif
= parg
;
1424 if (dvbnetif
->if_num
>= DVB_NET_DEVICES_MAX
||
1425 !dvbnet
->state
[dvbnetif
->if_num
]) {
1430 netdev
= dvbnet
->device
[dvbnetif
->if_num
];
1432 priv_data
= netdev_priv(netdev
);
1433 dvbnetif
->pid
=priv_data
->pid
;
1442 mutex_unlock(&dvbnet
->ioctl_mutex
);
1446 static long dvb_net_ioctl(struct file
*file
,
1447 unsigned int cmd
, unsigned long arg
)
1449 return dvb_usercopy(file
, cmd
, arg
, dvb_net_do_ioctl
);
1452 static int dvb_net_close(struct inode
*inode
, struct file
*file
)
1454 struct dvb_device
*dvbdev
= file
->private_data
;
1455 struct dvb_net
*dvbnet
= dvbdev
->priv
;
1457 dvb_generic_release(inode
, file
);
1459 if(dvbdev
->users
== 1 && dvbnet
->exit
== 1)
1460 wake_up(&dvbdev
->wait_queue
);
1465 static const struct file_operations dvb_net_fops
= {
1466 .owner
= THIS_MODULE
,
1467 .unlocked_ioctl
= dvb_net_ioctl
,
1468 .open
= dvb_generic_open
,
1469 .release
= dvb_net_close
,
1470 .llseek
= noop_llseek
,
1473 static const struct dvb_device dvbdev_net
= {
1477 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
1480 .fops
= &dvb_net_fops
,
1483 void dvb_net_release (struct dvb_net
*dvbnet
)
1488 if (dvbnet
->dvbdev
->users
< 1)
1489 wait_event(dvbnet
->dvbdev
->wait_queue
,
1490 dvbnet
->dvbdev
->users
==1);
1492 dvb_unregister_device(dvbnet
->dvbdev
);
1494 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++) {
1495 if (!dvbnet
->state
[i
])
1497 dvb_net_remove_if(dvbnet
, i
);
1500 EXPORT_SYMBOL(dvb_net_release
);
1503 int dvb_net_init (struct dvb_adapter
*adap
, struct dvb_net
*dvbnet
,
1504 struct dmx_demux
*dmx
)
1508 mutex_init(&dvbnet
->ioctl_mutex
);
1509 dvbnet
->demux
= dmx
;
1511 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++)
1512 dvbnet
->state
[i
] = 0;
1514 return dvb_register_device(adap
, &dvbnet
->dvbdev
, &dvbdev_net
,
1515 dvbnet
, DVB_DEVICE_NET
, 0);
1517 EXPORT_SYMBOL(dvb_net_init
);