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 <linux/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.
315 struct dvb_net_ule_handle
{
316 struct net_device
*dev
;
317 struct dvb_net_priv
*priv
;
321 unsigned long skipped
;
322 const u8
*ts
, *ts_end
, *from_where
;
323 u8 ts_remain
, how_much
, new_ts
;
327 * The code inside ULE_DEBUG keeps a history of the
328 * last 100 TS cells processed.
330 static unsigned char ule_hist
[100*TS_SZ
];
331 static unsigned char *ule_where
= ule_hist
, ule_dump
;
335 static int dvb_net_ule_new_ts_cell(struct dvb_net_ule_handle
*h
)
337 /* We are about to process a new TS cell. */
340 if (h
->ule_where
>= &h
->ule_hist
[100*TS_SZ
])
341 h
->ule_where
= h
->ule_hist
;
342 memcpy(h
->ule_where
, h
->ts
, TS_SZ
);
344 hexdump(h
->ule_where
, TS_SZ
);
347 h
->ule_where
+= TS_SZ
;
351 * Check TS h->error conditions: sync_byte, transport_error_indicator,
352 * scrambling_control .
354 if ((h
->ts
[0] != TS_SYNC
) || (h
->ts
[1] & TS_TEI
) ||
355 ((h
->ts
[3] & TS_SC
) != 0)) {
356 pr_warn("%lu: Invalid TS cell: SYNC %#x, TEI %u, SC %#x.\n",
357 h
->priv
->ts_count
, h
->ts
[0],
358 (h
->ts
[1] & TS_TEI
) >> 7,
359 (h
->ts
[3] & TS_SC
) >> 6);
361 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
362 if (h
->priv
->ule_skb
) {
363 dev_kfree_skb(h
->priv
->ule_skb
);
364 /* Prepare for next SNDU. */
365 h
->dev
->stats
.rx_errors
++;
366 h
->dev
->stats
.rx_frame_errors
++;
369 h
->priv
->need_pusi
= 1;
371 /* Continue with next TS cell. */
378 h
->from_where
= h
->ts
+ 4;
383 static int dvb_net_ule_ts_pusi(struct dvb_net_ule_handle
*h
)
385 if (h
->ts
[1] & TS_PUSI
) {
386 /* Find beginning of first ULE SNDU in current TS cell. */
387 /* Synchronize continuity counter. */
388 h
->priv
->tscc
= h
->ts
[3] & 0x0F;
389 /* There is a pointer field here. */
390 if (h
->ts
[4] > h
->ts_remain
) {
391 pr_err("%lu: Invalid ULE packet (pointer field %d)\n",
392 h
->priv
->ts_count
, h
->ts
[4]);
397 /* Skip to destination of pointer field. */
398 h
->from_where
= &h
->ts
[5] + h
->ts
[4];
399 h
->ts_remain
-= 1 + h
->ts
[4];
411 static int dvb_net_ule_new_ts(struct dvb_net_ule_handle
*h
)
413 /* Check continuity counter. */
414 if ((h
->ts
[3] & 0x0F) == h
->priv
->tscc
)
415 h
->priv
->tscc
= (h
->priv
->tscc
+ 1) & 0x0F;
417 /* TS discontinuity handling: */
418 pr_warn("%lu: TS discontinuity: got %#x, expected %#x.\n",
419 h
->priv
->ts_count
, h
->ts
[3] & 0x0F,
421 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
422 if (h
->priv
->ule_skb
) {
423 dev_kfree_skb(h
->priv
->ule_skb
);
424 /* Prepare for next SNDU. */
425 // reset_ule(h->priv); moved to below.
426 h
->dev
->stats
.rx_errors
++;
427 h
->dev
->stats
.rx_frame_errors
++;
430 /* skip to next PUSI. */
431 h
->priv
->need_pusi
= 1;
435 * If we still have an incomplete payload, but PUSI is
436 * set; some TS cells are missing.
437 * This is only possible here, if we missed exactly 16 TS
438 * cells (continuity counter wrap).
440 if (h
->ts
[1] & TS_PUSI
) {
441 if (!h
->priv
->need_pusi
) {
442 if (!(*h
->from_where
< (h
->ts_remain
-1)) ||
443 *h
->from_where
!= h
->priv
->ule_sndu_remain
) {
445 * Pointer field is invalid.
446 * Drop this TS cell and any started ULE SNDU.
448 pr_warn("%lu: Invalid pointer field: %u.\n",
453 * Drop partly decoded SNDU, reset state,
456 if (h
->priv
->ule_skb
) {
458 dev_kfree_skb(h
->priv
->ule_skb
);
461 if (h
->error
|| h
->priv
->ule_sndu_remain
) {
462 h
->dev
->stats
.rx_errors
++;
463 h
->dev
->stats
.rx_frame_errors
++;
468 h
->priv
->need_pusi
= 1;
472 * Skip pointer field (we're processing a
478 h
->priv
->need_pusi
= 0;
480 if (h
->priv
->ule_sndu_remain
> 183) {
482 * Current SNDU lacks more data than there
483 * could be available in the current TS cell.
485 h
->dev
->stats
.rx_errors
++;
486 h
->dev
->stats
.rx_length_errors
++;
487 pr_warn("%lu: Expected %d more SNDU bytes, but got PUSI (pf %d, h->ts_remain %d). Flushing incomplete payload.\n",
489 h
->priv
->ule_sndu_remain
,
490 h
->ts
[4], h
->ts_remain
);
491 dev_kfree_skb(h
->priv
->ule_skb
);
492 /* Prepare for next SNDU. */
495 * Resync: go to where pointer field points to:
496 * start of next ULE SNDU.
498 h
->from_where
+= h
->ts
[4];
499 h
->ts_remain
-= h
->ts
[4];
507 * Start a new payload with skb.
508 * Find ULE header. It is only guaranteed that the
509 * length field (2 bytes) is contained in the current
511 * Check h.ts_remain has to be >= 2 here.
513 static int dvb_net_ule_new_payload(struct dvb_net_ule_handle
*h
)
515 if (h
->ts_remain
< 2) {
516 pr_warn("Invalid payload packing: only %d bytes left in TS. Resyncing.\n",
518 h
->priv
->ule_sndu_len
= 0;
519 h
->priv
->need_pusi
= 1;
524 if (!h
->priv
->ule_sndu_len
) {
525 /* Got at least two bytes, thus extrace the SNDU length. */
526 h
->priv
->ule_sndu_len
= h
->from_where
[0] << 8 |
528 if (h
->priv
->ule_sndu_len
& 0x8000) {
529 /* D-Bit is set: no dest mac present. */
530 h
->priv
->ule_sndu_len
&= 0x7FFF;
531 h
->priv
->ule_dbit
= 1;
533 h
->priv
->ule_dbit
= 0;
535 if (h
->priv
->ule_sndu_len
< 5) {
536 pr_warn("%lu: Invalid ULE SNDU length %u. Resyncing.\n",
538 h
->priv
->ule_sndu_len
);
539 h
->dev
->stats
.rx_errors
++;
540 h
->dev
->stats
.rx_length_errors
++;
541 h
->priv
->ule_sndu_len
= 0;
542 h
->priv
->need_pusi
= 1;
548 h
->ts_remain
-= 2; /* consume the 2 bytes SNDU length. */
552 h
->priv
->ule_sndu_remain
= h
->priv
->ule_sndu_len
+ 2;
554 * State of current TS:
555 * h->ts_remain (remaining bytes in the current TS cell)
556 * 0 ule_type is not available now, we need the next TS cell
557 * 1 the first byte of the ule_type is present
558 * >=2 full ULE header present, maybe some payload data as well.
560 switch (h
->ts_remain
) {
562 h
->priv
->ule_sndu_remain
--;
563 h
->priv
->ule_sndu_type
= h
->from_where
[0] << 8;
565 /* first byte of ule_type is set. */
566 h
->priv
->ule_sndu_type_1
= 1;
576 default: /* complete ULE header is present in current TS. */
577 /* Extract ULE type field. */
578 if (h
->priv
->ule_sndu_type_1
) {
579 h
->priv
->ule_sndu_type_1
= 0;
580 h
->priv
->ule_sndu_type
|= h
->from_where
[0];
581 h
->from_where
+= 1; /* points to payload start. */
584 /* Complete type is present in new TS. */
585 h
->priv
->ule_sndu_type
= h
->from_where
[0] << 8 |
587 h
->from_where
+= 2; /* points to payload start. */
594 * Allocate the skb (decoder target buffer) with the correct size,
597 * prepare for the largest case: bridged SNDU with MAC address
600 h
->priv
->ule_skb
= dev_alloc_skb(h
->priv
->ule_sndu_len
+
601 ETH_HLEN
+ ETH_ALEN
);
602 if (!h
->priv
->ule_skb
) {
603 pr_notice("%s: Memory squeeze, dropping packet.\n",
605 h
->dev
->stats
.rx_dropped
++;
609 /* This includes the CRC32 _and_ dest mac, if !dbit. */
610 h
->priv
->ule_sndu_remain
= h
->priv
->ule_sndu_len
;
611 h
->priv
->ule_skb
->dev
= h
->dev
;
613 * Leave space for Ethernet or bridged SNDU header
614 * (eth hdr plus one MAC addr).
616 skb_reserve(h
->priv
->ule_skb
, ETH_HLEN
+ ETH_ALEN
);
622 static int dvb_net_ule_should_drop(struct dvb_net_ule_handle
*h
)
624 static const u8 bc_addr
[ETH_ALEN
] = { [0 ... ETH_ALEN
- 1] = 0xff };
627 * The destination MAC address is the next data in the skb. It comes
628 * before any extension headers.
630 * Check if the payload of this SNDU should be passed up the stack.
632 if (h
->priv
->rx_mode
== RX_MODE_PROMISC
)
635 if (h
->priv
->ule_skb
->data
[0] & 0x01) {
636 /* multicast or broadcast */
637 if (!ether_addr_equal(h
->priv
->ule_skb
->data
, bc_addr
)) {
639 if (h
->priv
->rx_mode
== RX_MODE_MULTI
) {
642 for (i
= 0; i
< h
->priv
->multi_num
&&
643 !ether_addr_equal(h
->priv
->ule_skb
->data
,
644 h
->priv
->multi_macs
[i
]);
647 if (i
== h
->priv
->multi_num
)
649 } else if (h
->priv
->rx_mode
!= RX_MODE_ALL_MULTI
)
650 return 1; /* no broadcast; */
653 * all multicast mode: accept all multicast packets
656 /* else: broadcast */
657 } else if (!ether_addr_equal(h
->priv
->ule_skb
->data
, h
->dev
->dev_addr
))
664 static void dvb_net_ule_check_crc(struct dvb_net_ule_handle
*h
,
665 u32 ule_crc
, u32 expected_crc
)
667 u8 dest_addr
[ETH_ALEN
];
669 if (ule_crc
!= expected_crc
) {
670 pr_warn("%lu: CRC32 check FAILED: %08x / %08x, SNDU len %d type %#x, ts_remain %d, next 2: %x.\n",
671 h
->priv
->ts_count
, ule_crc
, expected_crc
,
672 h
->priv
->ule_sndu_len
, h
->priv
->ule_sndu_type
,
675 *(unsigned short *)h
->from_where
: 0);
678 hexdump(iov
[0].iov_base
, iov
[0].iov_len
);
679 hexdump(iov
[1].iov_base
, iov
[1].iov_len
);
680 hexdump(iov
[2].iov_base
, iov
[2].iov_len
);
682 if (h
->ule_where
== h
->ule_hist
) {
683 hexdump(&h
->ule_hist
[98*TS_SZ
], TS_SZ
);
684 hexdump(&h
->ule_hist
[99*TS_SZ
], TS_SZ
);
685 } else if (h
->ule_where
== &h
->ule_hist
[TS_SZ
]) {
686 hexdump(&h
->ule_hist
[99*TS_SZ
], TS_SZ
);
687 hexdump(h
->ule_hist
, TS_SZ
);
689 hexdump(h
->ule_where
- TS_SZ
- TS_SZ
, TS_SZ
);
690 hexdump(h
->ule_where
- TS_SZ
, TS_SZ
);
695 h
->dev
->stats
.rx_errors
++;
696 h
->dev
->stats
.rx_crc_errors
++;
697 dev_kfree_skb(h
->priv
->ule_skb
);
702 /* CRC32 verified OK. */
704 /* CRC32 was OK, so remove it from skb. */
705 h
->priv
->ule_skb
->tail
-= 4;
706 h
->priv
->ule_skb
->len
-= 4;
708 if (!h
->priv
->ule_dbit
) {
709 if (dvb_net_ule_should_drop(h
)) {
712 "Dropping SNDU: MAC destination address does not match: dest addr: %pM, h->dev addr: %pM\n",
713 h
->priv
->ule_skb
->data
, h
->dev
->dev_addr
);
715 dev_kfree_skb(h
->priv
->ule_skb
);
719 skb_copy_from_linear_data(h
->priv
->ule_skb
, dest_addr
,
721 skb_pull(h
->priv
->ule_skb
, ETH_ALEN
);
723 /* dest_addr buffer is only valid if h->priv->ule_dbit == 0 */
724 eth_zero_addr(dest_addr
);
727 /* Handle ULE Extension Headers. */
728 if (h
->priv
->ule_sndu_type
< ETH_P_802_3_MIN
) {
729 /* There is an extension header. Handle it accordingly. */
730 int l
= handle_ule_extensions(h
->priv
);
734 * Mandatory extension header unknown or TEST SNDU.
738 // pr_warn("Dropping SNDU, extension headers.\n" );
739 dev_kfree_skb(h
->priv
->ule_skb
);
742 skb_pull(h
->priv
->ule_skb
, l
);
746 * Construct/assure correct ethernet header.
747 * Note: in bridged mode (h->priv->ule_bridged != 0)
748 * we already have the (original) ethernet
749 * header at the start of the payload (after
750 * optional dest. address and any extension
753 if (!h
->priv
->ule_bridged
) {
754 skb_push(h
->priv
->ule_skb
, ETH_HLEN
);
755 h
->ethh
= (struct ethhdr
*)h
->priv
->ule_skb
->data
;
756 memcpy(h
->ethh
->h_dest
, dest_addr
, ETH_ALEN
);
757 eth_zero_addr(h
->ethh
->h_source
);
758 h
->ethh
->h_proto
= htons(h
->priv
->ule_sndu_type
);
760 /* else: skb is in correct state; nothing to do. */
761 h
->priv
->ule_bridged
= 0;
763 /* Stuff into kernel's protocol stack. */
764 h
->priv
->ule_skb
->protocol
= dvb_net_eth_type_trans(h
->priv
->ule_skb
,
767 * If D-bit is set (i.e. destination MAC address not present),
768 * receive the packet anyhow.
771 if (h
->priv
->ule_dbit
&& skb
->pkt_type
== PACKET_OTHERHOST
)
772 h
->priv
->ule_skb
->pkt_type
= PACKET_HOST
;
774 h
->dev
->stats
.rx_packets
++;
775 h
->dev
->stats
.rx_bytes
+= h
->priv
->ule_skb
->len
;
776 netif_rx(h
->priv
->ule_skb
);
779 static void dvb_net_ule(struct net_device
*dev
, const u8
*buf
, size_t buf_len
)
782 struct dvb_net_ule_handle h
= {
796 .ule_where
= ule_hist
,
801 * For all TS cells in current buffer.
802 * Appearently, we are called for every single TS cell.
804 for (h
.ts
= h
.buf
, h
.ts_end
= h
.buf
+ h
.buf_len
;
805 h
.ts
< h
.ts_end
; /* no incr. */) {
807 /* We are about to process a new TS cell. */
808 if (dvb_net_ule_new_ts_cell(&h
))
812 /* Synchronize on PUSI, if required. */
813 if (h
.priv
->need_pusi
) {
814 if (dvb_net_ule_ts_pusi(&h
))
819 if (dvb_net_ule_new_ts(&h
))
823 /* Check if new payload needs to be started. */
824 if (h
.priv
->ule_skb
== NULL
) {
825 ret
= dvb_net_ule_new_payload(&h
);
832 /* Copy data into our current skb. */
833 h
.how_much
= min(h
.priv
->ule_sndu_remain
, (int)h
.ts_remain
);
834 memcpy(skb_put(h
.priv
->ule_skb
, h
.how_much
),
835 h
.from_where
, h
.how_much
);
836 h
.priv
->ule_sndu_remain
-= h
.how_much
;
837 h
.ts_remain
-= h
.how_much
;
838 h
.from_where
+= h
.how_much
;
840 /* Check for complete payload. */
841 if (h
.priv
->ule_sndu_remain
<= 0) {
842 /* Check CRC32, we've got it in our skb already. */
843 __be16 ulen
= htons(h
.priv
->ule_sndu_len
);
844 __be16 utype
= htons(h
.priv
->ule_sndu_type
);
846 struct kvec iov
[3] = {
847 { &ulen
, sizeof ulen
},
848 { &utype
, sizeof utype
},
849 { h
.priv
->ule_skb
->data
,
850 h
.priv
->ule_skb
->len
- 4 }
852 u32 ule_crc
= ~0L, expected_crc
;
853 if (h
.priv
->ule_dbit
) {
854 /* Set D-bit for CRC32 verification,
855 * if it was set originally. */
856 ulen
|= htons(0x8000);
859 ule_crc
= iov_crc32(ule_crc
, iov
, 3);
860 tail
= skb_tail_pointer(h
.priv
->ule_skb
);
861 expected_crc
= *(tail
- 4) << 24 |
866 dvb_net_ule_check_crc(&h
, ule_crc
, expected_crc
);
868 /* Prepare for next SNDU. */
872 /* More data in current TS (look at the bytes following the CRC32)? */
873 if (h
.ts_remain
>= 2 && *((unsigned short *)h
.from_where
) != 0xFFFF) {
874 /* Next ULE SNDU starts right there. */
876 h
.priv
->ule_skb
= NULL
;
877 h
.priv
->ule_sndu_type_1
= 0;
878 h
.priv
->ule_sndu_len
= 0;
879 // pr_warn("More data in current TS: [%#x %#x %#x %#x]\n",
880 // *(h.from_where + 0), *(h.from_where + 1),
881 // *(h.from_where + 2), *(h.from_where + 3));
882 // pr_warn("h.ts @ %p, stopped @ %p:\n", h.ts, h.from_where + 0);
883 // hexdump(h.ts, 188);
888 if (h
.priv
->ule_skb
== NULL
) {
889 h
.priv
->need_pusi
= 1;
890 h
.priv
->ule_sndu_type_1
= 0;
891 h
.priv
->ule_sndu_len
= 0;
894 } /* for all available TS cells */
897 static int dvb_net_ts_callback(const u8
*buffer1
, size_t buffer1_len
,
898 const u8
*buffer2
, size_t buffer2_len
,
899 struct dmx_ts_feed
*feed
)
901 struct net_device
*dev
= feed
->priv
;
904 pr_warn("buffer2 not NULL: %p.\n", buffer2
);
905 if (buffer1_len
> 32768)
906 pr_warn("length > 32k: %zu.\n", buffer1_len
);
907 /* pr_info("TS callback: %u bytes, %u TS cells @ %p.\n",
908 buffer1_len, buffer1_len / TS_SZ, buffer1); */
909 dvb_net_ule(dev
, buffer1
, buffer1_len
);
914 static void dvb_net_sec(struct net_device
*dev
,
915 const u8
*pkt
, int pkt_len
)
919 struct net_device_stats
*stats
= &dev
->stats
;
922 /* note: pkt_len includes a 32bit checksum */
924 pr_warn("%s: IP/MPE packet length = %d too small.\n",
927 stats
->rx_length_errors
++;
930 /* it seems some ISPs manage to screw up here, so we have to
931 * relax the error checks... */
933 if ((pkt
[5] & 0xfd) != 0xc1) {
934 /* drop scrambled or broken packets */
936 if ((pkt
[5] & 0x3c) != 0x00) {
940 stats
->rx_crc_errors
++;
944 /* handle LLC/SNAP, see rfc-1042 */
945 if (pkt_len
< 24 || memcmp(&pkt
[12], "\xaa\xaa\x03\0\0\0", 6)) {
952 /* FIXME: assemble datagram from multiple sections */
954 stats
->rx_frame_errors
++;
958 /* we have 14 byte ethernet header (ip header follows);
959 * 12 byte MPE header; 4 byte checksum; + 2 byte alignment, 8 byte LLC/SNAP
961 if (!(skb
= dev_alloc_skb(pkt_len
- 4 - 12 + 14 + 2 - snap
))) {
962 //pr_notice("%s: Memory squeeze, dropping packet.\n", dev->name);
966 skb_reserve(skb
, 2); /* longword align L3 header */
969 /* copy L3 payload */
970 eth
= (u8
*) skb_put(skb
, pkt_len
- 12 - 4 + 14 - snap
);
971 memcpy(eth
+ 14, pkt
+ 12 + snap
, pkt_len
- 12 - 4 - snap
);
973 /* create ethernet header: */
981 eth
[6]=eth
[7]=eth
[8]=eth
[9]=eth
[10]=eth
[11]=0;
987 /* protocol numbers are from rfc-1700 or
988 * http://www.iana.org/assignments/ethernet-numbers
990 if (pkt
[12] >> 4 == 6) { /* version field from IP header */
991 eth
[12] = 0x86; /* IPv6 */
994 eth
[12] = 0x08; /* IPv4 */
999 skb
->protocol
= dvb_net_eth_type_trans(skb
, dev
);
1001 stats
->rx_packets
++;
1002 stats
->rx_bytes
+=skb
->len
;
1006 static int dvb_net_sec_callback(const u8
*buffer1
, size_t buffer1_len
,
1007 const u8
*buffer2
, size_t buffer2_len
,
1008 struct dmx_section_filter
*filter
)
1010 struct net_device
*dev
= filter
->priv
;
1013 * we rely on the DVB API definition where exactly one complete
1014 * section is delivered in buffer1
1016 dvb_net_sec (dev
, buffer1
, buffer1_len
);
1020 static int dvb_net_tx(struct sk_buff
*skb
, struct net_device
*dev
)
1023 return NETDEV_TX_OK
;
1026 static u8 mask_normal
[6]={0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1027 static u8 mask_allmulti
[6]={0xff, 0xff, 0xff, 0x00, 0x00, 0x00};
1028 static u8 mac_allmulti
[6]={0x01, 0x00, 0x5e, 0x00, 0x00, 0x00};
1029 static u8 mask_promisc
[6]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1031 static int dvb_net_filter_sec_set(struct net_device
*dev
,
1032 struct dmx_section_filter
**secfilter
,
1033 u8
*mac
, u8
*mac_mask
)
1035 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1039 ret
= priv
->secfeed
->allocate_filter(priv
->secfeed
, secfilter
);
1041 pr_err("%s: could not get filter\n", dev
->name
);
1045 (*secfilter
)->priv
=(void *) dev
;
1047 memset((*secfilter
)->filter_value
, 0x00, DMX_MAX_FILTER_SIZE
);
1048 memset((*secfilter
)->filter_mask
, 0x00, DMX_MAX_FILTER_SIZE
);
1049 memset((*secfilter
)->filter_mode
, 0xff, DMX_MAX_FILTER_SIZE
);
1051 (*secfilter
)->filter_value
[0]=0x3e;
1052 (*secfilter
)->filter_value
[3]=mac
[5];
1053 (*secfilter
)->filter_value
[4]=mac
[4];
1054 (*secfilter
)->filter_value
[8]=mac
[3];
1055 (*secfilter
)->filter_value
[9]=mac
[2];
1056 (*secfilter
)->filter_value
[10]=mac
[1];
1057 (*secfilter
)->filter_value
[11]=mac
[0];
1059 (*secfilter
)->filter_mask
[0] = 0xff;
1060 (*secfilter
)->filter_mask
[3] = mac_mask
[5];
1061 (*secfilter
)->filter_mask
[4] = mac_mask
[4];
1062 (*secfilter
)->filter_mask
[8] = mac_mask
[3];
1063 (*secfilter
)->filter_mask
[9] = mac_mask
[2];
1064 (*secfilter
)->filter_mask
[10] = mac_mask
[1];
1065 (*secfilter
)->filter_mask
[11]=mac_mask
[0];
1067 netdev_dbg(dev
, "filter mac=%pM mask=%pM\n", mac
, mac_mask
);
1072 static int dvb_net_feed_start(struct net_device
*dev
)
1075 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1076 struct dmx_demux
*demux
= priv
->demux
;
1077 unsigned char *mac
= (unsigned char *) dev
->dev_addr
;
1079 netdev_dbg(dev
, "rx_mode %i\n", priv
->rx_mode
);
1080 mutex_lock(&priv
->mutex
);
1081 if (priv
->tsfeed
|| priv
->secfeed
|| priv
->secfilter
|| priv
->multi_secfilter
[0])
1082 pr_err("%s: BUG %d\n", __func__
, __LINE__
);
1085 priv
->secfilter
=NULL
;
1086 priv
->tsfeed
= NULL
;
1088 if (priv
->feedtype
== DVB_NET_FEEDTYPE_MPE
) {
1089 netdev_dbg(dev
, "alloc secfeed\n");
1090 ret
=demux
->allocate_section_feed(demux
, &priv
->secfeed
,
1091 dvb_net_sec_callback
);
1093 pr_err("%s: could not allocate section feed\n",
1098 ret
= priv
->secfeed
->set(priv
->secfeed
, priv
->pid
, 1);
1101 pr_err("%s: could not set section feed\n", dev
->name
);
1102 priv
->demux
->release_section_feed(priv
->demux
, priv
->secfeed
);
1107 if (priv
->rx_mode
!= RX_MODE_PROMISC
) {
1108 netdev_dbg(dev
, "set secfilter\n");
1109 dvb_net_filter_sec_set(dev
, &priv
->secfilter
, mac
, mask_normal
);
1112 switch (priv
->rx_mode
) {
1114 for (i
= 0; i
< priv
->multi_num
; i
++) {
1115 netdev_dbg(dev
, "set multi_secfilter[%d]\n", i
);
1116 dvb_net_filter_sec_set(dev
, &priv
->multi_secfilter
[i
],
1117 priv
->multi_macs
[i
], mask_normal
);
1120 case RX_MODE_ALL_MULTI
:
1122 netdev_dbg(dev
, "set multi_secfilter[0]\n");
1123 dvb_net_filter_sec_set(dev
, &priv
->multi_secfilter
[0],
1124 mac_allmulti
, mask_allmulti
);
1126 case RX_MODE_PROMISC
:
1128 netdev_dbg(dev
, "set secfilter\n");
1129 dvb_net_filter_sec_set(dev
, &priv
->secfilter
, mac
, mask_promisc
);
1133 netdev_dbg(dev
, "start filtering\n");
1134 priv
->secfeed
->start_filtering(priv
->secfeed
);
1135 } else if (priv
->feedtype
== DVB_NET_FEEDTYPE_ULE
) {
1136 ktime_t timeout
= ns_to_ktime(10 * NSEC_PER_MSEC
);
1138 /* we have payloads encapsulated in TS */
1139 netdev_dbg(dev
, "alloc tsfeed\n");
1140 ret
= demux
->allocate_ts_feed(demux
, &priv
->tsfeed
, dvb_net_ts_callback
);
1142 pr_err("%s: could not allocate ts feed\n", dev
->name
);
1146 /* Set netdevice pointer for ts decaps callback. */
1147 priv
->tsfeed
->priv
= (void *)dev
;
1148 ret
= priv
->tsfeed
->set(priv
->tsfeed
,
1149 priv
->pid
, /* pid */
1150 TS_PACKET
, /* type */
1151 DMX_PES_OTHER
, /* pes type */
1152 timeout
/* timeout */
1156 pr_err("%s: could not set ts feed\n", dev
->name
);
1157 priv
->demux
->release_ts_feed(priv
->demux
, priv
->tsfeed
);
1158 priv
->tsfeed
= NULL
;
1162 netdev_dbg(dev
, "start filtering\n");
1163 priv
->tsfeed
->start_filtering(priv
->tsfeed
);
1168 mutex_unlock(&priv
->mutex
);
1172 static int dvb_net_feed_stop(struct net_device
*dev
)
1174 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1177 mutex_lock(&priv
->mutex
);
1178 if (priv
->feedtype
== DVB_NET_FEEDTYPE_MPE
) {
1179 if (priv
->secfeed
) {
1180 if (priv
->secfeed
->is_filtering
) {
1181 netdev_dbg(dev
, "stop secfeed\n");
1182 priv
->secfeed
->stop_filtering(priv
->secfeed
);
1185 if (priv
->secfilter
) {
1186 netdev_dbg(dev
, "release secfilter\n");
1187 priv
->secfeed
->release_filter(priv
->secfeed
,
1189 priv
->secfilter
=NULL
;
1192 for (i
=0; i
<priv
->multi_num
; i
++) {
1193 if (priv
->multi_secfilter
[i
]) {
1194 netdev_dbg(dev
, "release multi_filter[%d]\n",
1196 priv
->secfeed
->release_filter(priv
->secfeed
,
1197 priv
->multi_secfilter
[i
]);
1198 priv
->multi_secfilter
[i
] = NULL
;
1202 priv
->demux
->release_section_feed(priv
->demux
, priv
->secfeed
);
1203 priv
->secfeed
= NULL
;
1205 pr_err("%s: no feed to stop\n", dev
->name
);
1206 } else if (priv
->feedtype
== DVB_NET_FEEDTYPE_ULE
) {
1208 if (priv
->tsfeed
->is_filtering
) {
1209 netdev_dbg(dev
, "stop tsfeed\n");
1210 priv
->tsfeed
->stop_filtering(priv
->tsfeed
);
1212 priv
->demux
->release_ts_feed(priv
->demux
, priv
->tsfeed
);
1213 priv
->tsfeed
= NULL
;
1216 pr_err("%s: no ts feed to stop\n", dev
->name
);
1219 mutex_unlock(&priv
->mutex
);
1224 static int dvb_set_mc_filter(struct net_device
*dev
, unsigned char *addr
)
1226 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1228 if (priv
->multi_num
== DVB_NET_MULTICAST_MAX
)
1231 memcpy(priv
->multi_macs
[priv
->multi_num
], addr
, ETH_ALEN
);
1238 static void wq_set_multicast_list (struct work_struct
*work
)
1240 struct dvb_net_priv
*priv
=
1241 container_of(work
, struct dvb_net_priv
, set_multicast_list_wq
);
1242 struct net_device
*dev
= priv
->net
;
1244 dvb_net_feed_stop(dev
);
1245 priv
->rx_mode
= RX_MODE_UNI
;
1246 netif_addr_lock_bh(dev
);
1248 if (dev
->flags
& IFF_PROMISC
) {
1249 netdev_dbg(dev
, "promiscuous mode\n");
1250 priv
->rx_mode
= RX_MODE_PROMISC
;
1251 } else if ((dev
->flags
& IFF_ALLMULTI
)) {
1252 netdev_dbg(dev
, "allmulti mode\n");
1253 priv
->rx_mode
= RX_MODE_ALL_MULTI
;
1254 } else if (!netdev_mc_empty(dev
)) {
1255 struct netdev_hw_addr
*ha
;
1257 netdev_dbg(dev
, "set_mc_list, %d entries\n",
1258 netdev_mc_count(dev
));
1260 priv
->rx_mode
= RX_MODE_MULTI
;
1261 priv
->multi_num
= 0;
1263 netdev_for_each_mc_addr(ha
, dev
)
1264 dvb_set_mc_filter(dev
, ha
->addr
);
1267 netif_addr_unlock_bh(dev
);
1268 dvb_net_feed_start(dev
);
1272 static void dvb_net_set_multicast_list (struct net_device
*dev
)
1274 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1275 schedule_work(&priv
->set_multicast_list_wq
);
1279 static void wq_restart_net_feed (struct work_struct
*work
)
1281 struct dvb_net_priv
*priv
=
1282 container_of(work
, struct dvb_net_priv
, restart_net_feed_wq
);
1283 struct net_device
*dev
= priv
->net
;
1285 if (netif_running(dev
)) {
1286 dvb_net_feed_stop(dev
);
1287 dvb_net_feed_start(dev
);
1292 static int dvb_net_set_mac (struct net_device
*dev
, void *p
)
1294 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1295 struct sockaddr
*addr
=p
;
1297 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1299 if (netif_running(dev
))
1300 schedule_work(&priv
->restart_net_feed_wq
);
1306 static int dvb_net_open(struct net_device
*dev
)
1308 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1311 dvb_net_feed_start(dev
);
1316 static int dvb_net_stop(struct net_device
*dev
)
1318 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1321 return dvb_net_feed_stop(dev
);
1324 static const struct header_ops dvb_header_ops
= {
1325 .create
= eth_header
,
1326 .parse
= eth_header_parse
,
1330 static const struct net_device_ops dvb_netdev_ops
= {
1331 .ndo_open
= dvb_net_open
,
1332 .ndo_stop
= dvb_net_stop
,
1333 .ndo_start_xmit
= dvb_net_tx
,
1334 .ndo_set_rx_mode
= dvb_net_set_multicast_list
,
1335 .ndo_set_mac_address
= dvb_net_set_mac
,
1336 .ndo_validate_addr
= eth_validate_addr
,
1339 static void dvb_net_setup(struct net_device
*dev
)
1343 dev
->header_ops
= &dvb_header_ops
;
1344 dev
->netdev_ops
= &dvb_netdev_ops
;
1346 dev
->max_mtu
= 4096;
1348 dev
->flags
|= IFF_NOARP
;
1351 static int get_if(struct dvb_net
*dvbnet
)
1355 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++)
1356 if (!dvbnet
->state
[i
])
1359 if (i
== DVB_NET_DEVICES_MAX
)
1366 static int dvb_net_add_if(struct dvb_net
*dvbnet
, u16 pid
, u8 feedtype
)
1368 struct net_device
*net
;
1369 struct dvb_net_priv
*priv
;
1373 if (feedtype
!= DVB_NET_FEEDTYPE_MPE
&& feedtype
!= DVB_NET_FEEDTYPE_ULE
)
1375 if ((if_num
= get_if(dvbnet
)) < 0)
1378 net
= alloc_netdev(sizeof(struct dvb_net_priv
), "dvb",
1379 NET_NAME_UNKNOWN
, dvb_net_setup
);
1383 if (dvbnet
->dvbdev
->id
)
1384 snprintf(net
->name
, IFNAMSIZ
, "dvb%d%u%d",
1385 dvbnet
->dvbdev
->adapter
->num
, dvbnet
->dvbdev
->id
, if_num
);
1387 /* compatibility fix to keep dvb0_0 format */
1388 snprintf(net
->name
, IFNAMSIZ
, "dvb%d_%d",
1389 dvbnet
->dvbdev
->adapter
->num
, if_num
);
1392 memcpy(net
->dev_addr
, dvbnet
->dvbdev
->adapter
->proposed_mac
, 6);
1394 dvbnet
->device
[if_num
] = net
;
1396 priv
= netdev_priv(net
);
1398 priv
->demux
= dvbnet
->demux
;
1400 priv
->rx_mode
= RX_MODE_UNI
;
1401 priv
->need_pusi
= 1;
1403 priv
->feedtype
= feedtype
;
1406 INIT_WORK(&priv
->set_multicast_list_wq
, wq_set_multicast_list
);
1407 INIT_WORK(&priv
->restart_net_feed_wq
, wq_restart_net_feed
);
1408 mutex_init(&priv
->mutex
);
1410 net
->base_addr
= pid
;
1412 if ((result
= register_netdev(net
)) < 0) {
1413 dvbnet
->device
[if_num
] = NULL
;
1417 pr_info("created network interface %s\n", net
->name
);
1422 static int dvb_net_remove_if(struct dvb_net
*dvbnet
, unsigned long num
)
1424 struct net_device
*net
= dvbnet
->device
[num
];
1425 struct dvb_net_priv
*priv
;
1427 if (!dvbnet
->state
[num
])
1429 priv
= netdev_priv(net
);
1434 flush_work(&priv
->set_multicast_list_wq
);
1435 flush_work(&priv
->restart_net_feed_wq
);
1436 pr_info("removed network interface %s\n", net
->name
);
1437 unregister_netdev(net
);
1438 dvbnet
->state
[num
]=0;
1439 dvbnet
->device
[num
] = NULL
;
1445 static int dvb_net_do_ioctl(struct file
*file
,
1446 unsigned int cmd
, void *parg
)
1448 struct dvb_device
*dvbdev
= file
->private_data
;
1449 struct dvb_net
*dvbnet
= dvbdev
->priv
;
1452 if (((file
->f_flags
&O_ACCMODE
)==O_RDONLY
))
1455 if (mutex_lock_interruptible(&dvbnet
->ioctl_mutex
))
1456 return -ERESTARTSYS
;
1461 struct dvb_net_if
*dvbnetif
= parg
;
1464 if (!capable(CAP_SYS_ADMIN
)) {
1469 if (!try_module_get(dvbdev
->adapter
->module
)) {
1474 result
=dvb_net_add_if(dvbnet
, dvbnetif
->pid
, dvbnetif
->feedtype
);
1476 module_put(dvbdev
->adapter
->module
);
1480 dvbnetif
->if_num
=result
;
1485 struct net_device
*netdev
;
1486 struct dvb_net_priv
*priv_data
;
1487 struct dvb_net_if
*dvbnetif
= parg
;
1489 if (dvbnetif
->if_num
>= DVB_NET_DEVICES_MAX
||
1490 !dvbnet
->state
[dvbnetif
->if_num
]) {
1495 netdev
= dvbnet
->device
[dvbnetif
->if_num
];
1497 priv_data
= netdev_priv(netdev
);
1498 dvbnetif
->pid
=priv_data
->pid
;
1499 dvbnetif
->feedtype
=priv_data
->feedtype
;
1504 if (!capable(CAP_SYS_ADMIN
)) {
1508 if ((unsigned long) parg
>= DVB_NET_DEVICES_MAX
) {
1512 ret
= dvb_net_remove_if(dvbnet
, (unsigned long) parg
);
1514 module_put(dvbdev
->adapter
->module
);
1518 /* binary compatibility cruft */
1519 case __NET_ADD_IF_OLD
:
1521 struct __dvb_net_if_old
*dvbnetif
= parg
;
1524 if (!capable(CAP_SYS_ADMIN
)) {
1529 if (!try_module_get(dvbdev
->adapter
->module
)) {
1534 result
=dvb_net_add_if(dvbnet
, dvbnetif
->pid
, DVB_NET_FEEDTYPE_MPE
);
1536 module_put(dvbdev
->adapter
->module
);
1540 dvbnetif
->if_num
=result
;
1543 case __NET_GET_IF_OLD
:
1545 struct net_device
*netdev
;
1546 struct dvb_net_priv
*priv_data
;
1547 struct __dvb_net_if_old
*dvbnetif
= parg
;
1549 if (dvbnetif
->if_num
>= DVB_NET_DEVICES_MAX
||
1550 !dvbnet
->state
[dvbnetif
->if_num
]) {
1555 netdev
= dvbnet
->device
[dvbnetif
->if_num
];
1557 priv_data
= netdev_priv(netdev
);
1558 dvbnetif
->pid
=priv_data
->pid
;
1567 mutex_unlock(&dvbnet
->ioctl_mutex
);
1571 static long dvb_net_ioctl(struct file
*file
,
1572 unsigned int cmd
, unsigned long arg
)
1574 return dvb_usercopy(file
, cmd
, arg
, dvb_net_do_ioctl
);
1577 static int dvb_net_close(struct inode
*inode
, struct file
*file
)
1579 struct dvb_device
*dvbdev
= file
->private_data
;
1580 struct dvb_net
*dvbnet
= dvbdev
->priv
;
1582 dvb_generic_release(inode
, file
);
1584 if(dvbdev
->users
== 1 && dvbnet
->exit
== 1)
1585 wake_up(&dvbdev
->wait_queue
);
1590 static const struct file_operations dvb_net_fops
= {
1591 .owner
= THIS_MODULE
,
1592 .unlocked_ioctl
= dvb_net_ioctl
,
1593 .open
= dvb_generic_open
,
1594 .release
= dvb_net_close
,
1595 .llseek
= noop_llseek
,
1598 static const struct dvb_device dvbdev_net
= {
1602 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
1605 .fops
= &dvb_net_fops
,
1608 void dvb_net_release (struct dvb_net
*dvbnet
)
1613 if (dvbnet
->dvbdev
->users
< 1)
1614 wait_event(dvbnet
->dvbdev
->wait_queue
,
1615 dvbnet
->dvbdev
->users
==1);
1617 dvb_unregister_device(dvbnet
->dvbdev
);
1619 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++) {
1620 if (!dvbnet
->state
[i
])
1622 dvb_net_remove_if(dvbnet
, i
);
1625 EXPORT_SYMBOL(dvb_net_release
);
1628 int dvb_net_init (struct dvb_adapter
*adap
, struct dvb_net
*dvbnet
,
1629 struct dmx_demux
*dmx
)
1633 mutex_init(&dvbnet
->ioctl_mutex
);
1634 dvbnet
->demux
= dmx
;
1636 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++)
1637 dvbnet
->state
[i
] = 0;
1639 return dvb_register_device(adap
, &dvbnet
->dvbdev
, &dvbdev_net
,
1640 dvbnet
, DVB_DEVICE_NET
, 0);
1642 EXPORT_SYMBOL(dvb_net_init
);