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 #include <linux/module.h>
58 #include <linux/kernel.h>
59 #include <linux/netdevice.h>
60 #include <linux/etherdevice.h>
61 #include <linux/dvb/net.h>
62 #include <linux/smp_lock.h>
63 #include <linux/uio.h>
64 #include <asm/uaccess.h>
65 #include <linux/crc32.h>
66 #include <linux/mutex.h>
67 #include <linux/sched.h>
69 #include "dvb_demux.h"
72 static int dvb_net_debug
;
73 module_param(dvb_net_debug
, int, 0444);
74 MODULE_PARM_DESC(dvb_net_debug
, "enable debug messages");
76 #define dprintk(x...) do { if (dvb_net_debug) printk(x); } while (0)
79 static inline __u32
iov_crc32( __u32 c
, struct kvec
*iov
, unsigned int cnt
)
82 for (j
= 0; j
< cnt
; j
++)
83 c
= crc32_be( c
, iov
[j
].iov_base
, iov
[j
].iov_len
);
88 #define DVB_NET_MULTICAST_MAX 10
94 #define MAC_ADDR_PRINTFMT "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x"
95 #define MAX_ADDR_PRINTFMT_ARGS(macap) (macap)[0],(macap)[1],(macap)[2],(macap)[3],(macap)[4],(macap)[5]
97 #define isprint(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))
99 static void hexdump( const unsigned char *buf
, unsigned short len
)
101 char str
[80], octet
[10];
104 for (ofs
= 0; ofs
< len
; ofs
+= 16) {
105 sprintf( str
, "%03d: ", ofs
);
107 for (i
= 0; i
< 16; i
++) {
109 sprintf( octet
, "%02x ", buf
[ofs
+ i
] );
111 strcpy( octet
, " " );
113 strcat( str
, octet
);
118 for (i
= 0; (i
< 16) && ((i
+ ofs
) < len
); i
++)
119 str
[l
++] = isprint( buf
[ofs
+ i
] ) ? buf
[ofs
+ i
] : '.';
122 printk( KERN_WARNING
"%s\n", str
);
128 struct dvb_net_priv
{
131 struct net_device
*net
;
132 struct dvb_net
*host
;
133 struct dmx_demux
*demux
;
134 struct dmx_section_feed
*secfeed
;
135 struct dmx_section_filter
*secfilter
;
136 struct dmx_ts_feed
*tsfeed
;
138 struct dmx_section_filter
*multi_secfilter
[DVB_NET_MULTICAST_MAX
];
139 unsigned char multi_macs
[DVB_NET_MULTICAST_MAX
][6];
141 #define RX_MODE_UNI 0
142 #define RX_MODE_MULTI 1
143 #define RX_MODE_ALL_MULTI 2
144 #define RX_MODE_PROMISC 3
145 struct work_struct set_multicast_list_wq
;
146 struct work_struct restart_net_feed_wq
;
147 unsigned char feedtype
; /* Either FEED_TYPE_ or FEED_TYPE_ULE */
148 int need_pusi
; /* Set to 1, if synchronization on PUSI required. */
149 unsigned char tscc
; /* TS continuity counter after sync on PUSI. */
150 struct sk_buff
*ule_skb
; /* ULE SNDU decodes into this buffer. */
151 unsigned char *ule_next_hdr
; /* Pointer into skb to next ULE extension header. */
152 unsigned short ule_sndu_len
; /* ULE SNDU length in bytes, w/o D-Bit. */
153 unsigned short ule_sndu_type
; /* ULE SNDU type field, complete. */
154 unsigned char ule_sndu_type_1
; /* ULE SNDU type field, if split across 2 TS cells. */
155 unsigned char ule_dbit
; /* Whether the DestMAC address present
156 * or not (bit is set). */
157 unsigned char ule_bridged
; /* Whether the ULE_BRIDGED extension header was found. */
158 int ule_sndu_remain
; /* Nr. of bytes still required for current ULE SNDU. */
159 unsigned long ts_count
; /* Current ts cell counter. */
165 * Determine the packet's protocol ID. The rule here is that we
166 * assume 802.3 if the type field is short enough to be a length.
167 * This is normal practice and works for any 'now in use' protocol.
169 * stolen from eth.c out of the linux kernel, hacked for dvb-device
170 * by Michael Holzt <kju@debian.org>
172 static __be16
dvb_net_eth_type_trans(struct sk_buff
*skb
,
173 struct net_device
*dev
)
178 skb_reset_mac_header(skb
);
179 skb_pull(skb
,dev
->hard_header_len
);
182 if (*eth
->h_dest
& 1) {
183 if(memcmp(eth
->h_dest
,dev
->broadcast
, ETH_ALEN
)==0)
184 skb
->pkt_type
=PACKET_BROADCAST
;
186 skb
->pkt_type
=PACKET_MULTICAST
;
189 if (ntohs(eth
->h_proto
) >= 1536)
195 * This is a magic hack to spot IPX packets. Older Novell breaks
196 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
197 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
198 * won't work for fault tolerant netware but does for the rest.
200 if (*(unsigned short *)rawp
== 0xFFFF)
201 return htons(ETH_P_802_3
);
206 return htons(ETH_P_802_2
);
217 /* ULE Extension Header handlers. */
220 #define ULE_BRIDGED 1
222 #define ULE_OPTEXTHDR_PADDING 0
224 static int ule_test_sndu( struct dvb_net_priv
*p
)
229 static int ule_bridged_sndu( struct dvb_net_priv
*p
)
231 struct ethhdr
*hdr
= (struct ethhdr
*) p
->ule_next_hdr
;
232 if(ntohs(hdr
->h_proto
) < 1536) {
233 int framelen
= p
->ule_sndu_len
- ((p
->ule_next_hdr
+sizeof(struct ethhdr
)) - p
->ule_skb
->data
);
234 /* A frame Type < 1536 for a bridged frame, introduces a LLC Length field. */
235 if(framelen
!= ntohs(hdr
->h_proto
)) {
241 * "A bridged SNDU is a Mandatory Extension Header of Type 1.
242 * It must be the final (or only) extension header specified in the header chain of a SNDU."
243 * The 'ule_bridged' flag will cause the extension header processing loop to terminate.
249 static int ule_exthdr_padding(struct dvb_net_priv
*p
)
254 /** Handle ULE extension headers.
255 * Function is called after a successful CRC32 verification of an ULE SNDU to complete its decoding.
256 * Returns: >= 0: nr. of bytes consumed by next extension header
257 * -1: Mandatory extension header that is not recognized or TEST SNDU; discard.
259 static int handle_one_ule_extension( struct dvb_net_priv
*p
)
261 /* Table of mandatory extension header handlers. The header type is the index. */
262 static int (*ule_mandatory_ext_handlers
[255])( struct dvb_net_priv
*p
) =
263 { [0] = ule_test_sndu
, [1] = ule_bridged_sndu
, [2] = NULL
, };
265 /* Table of optional extension header handlers. The header type is the index. */
266 static int (*ule_optional_ext_handlers
[255])( struct dvb_net_priv
*p
) =
267 { [0] = ule_exthdr_padding
, [1] = NULL
, };
270 unsigned char hlen
= (p
->ule_sndu_type
& 0x0700) >> 8;
271 unsigned char htype
= p
->ule_sndu_type
& 0x00FF;
273 /* Discriminate mandatory and optional extension headers. */
275 /* Mandatory extension header */
276 if (ule_mandatory_ext_handlers
[htype
]) {
277 ext_len
= ule_mandatory_ext_handlers
[htype
]( p
);
279 p
->ule_next_hdr
+= ext_len
;
280 if (!p
->ule_bridged
) {
281 p
->ule_sndu_type
= ntohs(*(__be16
*)p
->ule_next_hdr
);
282 p
->ule_next_hdr
+= 2;
284 p
->ule_sndu_type
= ntohs(*(__be16
*)(p
->ule_next_hdr
+ ((p
->ule_dbit
? 2 : 3) * ETH_ALEN
)));
285 /* This assures the extension handling loop will terminate. */
288 // else: extension handler failed or SNDU should be discarded
290 ext_len
= -1; /* SNDU has to be discarded. */
292 /* Optional extension header. Calculate the length. */
294 /* Process the optional extension header according to its type. */
295 if (ule_optional_ext_handlers
[htype
])
296 (void)ule_optional_ext_handlers
[htype
]( p
);
297 p
->ule_next_hdr
+= ext_len
;
298 p
->ule_sndu_type
= ntohs( *(__be16
*)(p
->ule_next_hdr
-2) );
300 * note: the length of the next header type is included in the
301 * length of THIS optional extension header
308 static int handle_ule_extensions( struct dvb_net_priv
*p
)
310 int total_ext_len
= 0, l
;
312 p
->ule_next_hdr
= p
->ule_skb
->data
;
314 l
= handle_one_ule_extension( p
);
316 return l
; /* Stop extension header processing and discard SNDU. */
319 dprintk("handle_ule_extensions: ule_next_hdr=%p, ule_sndu_type=%i, "
320 "l=%i, total_ext_len=%i\n", p
->ule_next_hdr
,
321 (int) p
->ule_sndu_type
, l
, total_ext_len
);
324 } while (p
->ule_sndu_type
< 1536);
326 return total_ext_len
;
330 /** Prepare for a new ULE SNDU: reset the decoder state. */
331 static inline void reset_ule( struct dvb_net_priv
*p
)
334 p
->ule_next_hdr
= NULL
;
336 p
->ule_sndu_type
= 0;
337 p
->ule_sndu_type_1
= 0;
338 p
->ule_sndu_remain
= 0;
344 * Decode ULE SNDUs according to draft-ietf-ipdvb-ule-03.txt from a sequence of
345 * TS cells of a single PID.
347 static void dvb_net_ule( struct net_device
*dev
, const u8
*buf
, size_t buf_len
)
349 struct dvb_net_priv
*priv
= netdev_priv(dev
);
350 unsigned long skipped
= 0L;
351 const u8
*ts
, *ts_end
, *from_where
= NULL
;
352 u8 ts_remain
= 0, how_much
= 0, new_ts
= 1;
353 struct ethhdr
*ethh
= NULL
;
356 /* The code inside ULE_DEBUG keeps a history of the last 100 TS cells processed. */
357 static unsigned char ule_hist
[100*TS_SZ
];
358 static unsigned char *ule_where
= ule_hist
, ule_dump
;
361 /* For all TS cells in current buffer.
362 * Appearently, we are called for every single TS cell.
364 for (ts
= buf
, ts_end
= buf
+ buf_len
; ts
< ts_end
; /* no default incr. */ ) {
367 /* We are about to process a new TS cell. */
370 if (ule_where
>= &ule_hist
[100*TS_SZ
]) ule_where
= ule_hist
;
371 memcpy( ule_where
, ts
, TS_SZ
);
373 hexdump( ule_where
, TS_SZ
);
379 /* Check TS error conditions: sync_byte, transport_error_indicator, scrambling_control . */
380 if ((ts
[0] != TS_SYNC
) || (ts
[1] & TS_TEI
) || ((ts
[3] & TS_SC
) != 0)) {
381 printk(KERN_WARNING
"%lu: Invalid TS cell: SYNC %#x, TEI %u, SC %#x.\n",
382 priv
->ts_count
, ts
[0], ts
[1] & TS_TEI
>> 7, ts
[3] & 0xC0 >> 6);
384 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
386 dev_kfree_skb( priv
->ule_skb
);
387 /* Prepare for next SNDU. */
388 dev
->stats
.rx_errors
++;
389 dev
->stats
.rx_frame_errors
++;
394 /* Continue with next TS cell. */
403 /* Synchronize on PUSI, if required. */
404 if (priv
->need_pusi
) {
405 if (ts
[1] & TS_PUSI
) {
406 /* Find beginning of first ULE SNDU in current TS cell. */
407 /* Synchronize continuity counter. */
408 priv
->tscc
= ts
[3] & 0x0F;
409 /* There is a pointer field here. */
410 if (ts
[4] > ts_remain
) {
411 printk(KERN_ERR
"%lu: Invalid ULE packet "
412 "(pointer field %d)\n", priv
->ts_count
, ts
[4]);
417 /* Skip to destination of pointer field. */
418 from_where
= &ts
[5] + ts
[4];
419 ts_remain
-= 1 + ts
[4];
430 /* Check continuity counter. */
431 if ((ts
[3] & 0x0F) == priv
->tscc
)
432 priv
->tscc
= (priv
->tscc
+ 1) & 0x0F;
434 /* TS discontinuity handling: */
435 printk(KERN_WARNING
"%lu: TS discontinuity: got %#x, "
436 "expected %#x.\n", priv
->ts_count
, ts
[3] & 0x0F, priv
->tscc
);
437 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
439 dev_kfree_skb( priv
->ule_skb
);
440 /* Prepare for next SNDU. */
441 // reset_ule(priv); moved to below.
442 dev
->stats
.rx_errors
++;
443 dev
->stats
.rx_frame_errors
++;
446 /* skip to next PUSI. */
450 /* If we still have an incomplete payload, but PUSI is
451 * set; some TS cells are missing.
452 * This is only possible here, if we missed exactly 16 TS
453 * cells (continuity counter wrap). */
454 if (ts
[1] & TS_PUSI
) {
455 if (! priv
->need_pusi
) {
456 if (!(*from_where
< (ts_remain
-1)) || *from_where
!= priv
->ule_sndu_remain
) {
457 /* Pointer field is invalid. Drop this TS cell and any started ULE SNDU. */
458 printk(KERN_WARNING
"%lu: Invalid pointer "
459 "field: %u.\n", priv
->ts_count
, *from_where
);
461 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
463 dev_kfree_skb( priv
->ule_skb
);
464 dev
->stats
.rx_errors
++;
465 dev
->stats
.rx_frame_errors
++;
471 /* Skip pointer field (we're processing a
472 * packed payload). */
478 if (priv
->ule_sndu_remain
> 183) {
479 /* Current SNDU lacks more data than there could be available in the
480 * current TS cell. */
481 dev
->stats
.rx_errors
++;
482 dev
->stats
.rx_length_errors
++;
483 printk(KERN_WARNING
"%lu: Expected %d more SNDU bytes, but "
484 "got PUSI (pf %d, ts_remain %d). Flushing incomplete payload.\n",
485 priv
->ts_count
, priv
->ule_sndu_remain
, ts
[4], ts_remain
);
486 dev_kfree_skb(priv
->ule_skb
);
487 /* Prepare for next SNDU. */
489 /* Resync: go to where pointer field points to: start of next ULE SNDU. */
496 /* Check if new payload needs to be started. */
497 if (priv
->ule_skb
== NULL
) {
498 /* Start a new payload with skb.
499 * Find ULE header. It is only guaranteed that the
500 * length field (2 bytes) is contained in the current
502 * Check ts_remain has to be >= 2 here. */
504 printk(KERN_WARNING
"Invalid payload packing: only %d "
505 "bytes left in TS. Resyncing.\n", ts_remain
);
506 priv
->ule_sndu_len
= 0;
512 if (! priv
->ule_sndu_len
) {
513 /* Got at least two bytes, thus extrace the SNDU length. */
514 priv
->ule_sndu_len
= from_where
[0] << 8 | from_where
[1];
515 if (priv
->ule_sndu_len
& 0x8000) {
516 /* D-Bit is set: no dest mac present. */
517 priv
->ule_sndu_len
&= 0x7FFF;
522 if (priv
->ule_sndu_len
< 5) {
523 printk(KERN_WARNING
"%lu: Invalid ULE SNDU length %u. "
524 "Resyncing.\n", priv
->ts_count
, priv
->ule_sndu_len
);
525 dev
->stats
.rx_errors
++;
526 dev
->stats
.rx_length_errors
++;
527 priv
->ule_sndu_len
= 0;
534 ts_remain
-= 2; /* consume the 2 bytes SNDU length. */
539 * State of current TS:
540 * ts_remain (remaining bytes in the current TS cell)
541 * 0 ule_type is not available now, we need the next TS cell
542 * 1 the first byte of the ule_type is present
543 * >=2 full ULE header present, maybe some payload data as well.
547 priv
->ule_sndu_type
= from_where
[0] << 8;
548 priv
->ule_sndu_type_1
= 1; /* first byte of ule_type is set. */
549 ts_remain
-= 1; from_where
+= 1;
550 /* Continue w/ next TS. */
557 default: /* complete ULE header is present in current TS. */
558 /* Extract ULE type field. */
559 if (priv
->ule_sndu_type_1
) {
560 priv
->ule_sndu_type
|= from_where
[0];
561 from_where
+= 1; /* points to payload start. */
564 /* Complete type is present in new TS. */
565 priv
->ule_sndu_type
= from_where
[0] << 8 | from_where
[1];
566 from_where
+= 2; /* points to payload start. */
572 /* Allocate the skb (decoder target buffer) with the correct size, as follows:
573 * prepare for the largest case: bridged SNDU with MAC address (dbit = 0). */
574 priv
->ule_skb
= dev_alloc_skb( priv
->ule_sndu_len
+ ETH_HLEN
+ ETH_ALEN
);
575 if (priv
->ule_skb
== NULL
) {
576 printk(KERN_NOTICE
"%s: Memory squeeze, dropping packet.\n",
578 dev
->stats
.rx_dropped
++;
582 /* This includes the CRC32 _and_ dest mac, if !dbit. */
583 priv
->ule_sndu_remain
= priv
->ule_sndu_len
;
584 priv
->ule_skb
->dev
= dev
;
585 /* Leave space for Ethernet or bridged SNDU header (eth hdr plus one MAC addr). */
586 skb_reserve( priv
->ule_skb
, ETH_HLEN
+ ETH_ALEN
);
589 /* Copy data into our current skb. */
590 how_much
= min(priv
->ule_sndu_remain
, (int)ts_remain
);
591 memcpy(skb_put(priv
->ule_skb
, how_much
), from_where
, how_much
);
592 priv
->ule_sndu_remain
-= how_much
;
593 ts_remain
-= how_much
;
594 from_where
+= how_much
;
596 /* Check for complete payload. */
597 if (priv
->ule_sndu_remain
<= 0) {
598 /* Check CRC32, we've got it in our skb already. */
599 __be16 ulen
= htons(priv
->ule_sndu_len
);
600 __be16 utype
= htons(priv
->ule_sndu_type
);
602 struct kvec iov
[3] = {
603 { &ulen
, sizeof ulen
},
604 { &utype
, sizeof utype
},
605 { priv
->ule_skb
->data
, priv
->ule_skb
->len
- 4 }
607 u32 ule_crc
= ~0L, expected_crc
;
608 if (priv
->ule_dbit
) {
609 /* Set D-bit for CRC32 verification,
610 * if it was set originally. */
611 ulen
|= htons(0x8000);
614 ule_crc
= iov_crc32(ule_crc
, iov
, 3);
615 tail
= skb_tail_pointer(priv
->ule_skb
);
616 expected_crc
= *(tail
- 4) << 24 |
620 if (ule_crc
!= expected_crc
) {
621 printk(KERN_WARNING
"%lu: CRC32 check FAILED: %08x / %08x, SNDU len %d type %#x, ts_remain %d, next 2: %x.\n",
622 priv
->ts_count
, ule_crc
, expected_crc
, priv
->ule_sndu_len
, priv
->ule_sndu_type
, ts_remain
, ts_remain
> 2 ? *(unsigned short *)from_where
: 0);
625 hexdump( iov
[0].iov_base
, iov
[0].iov_len
);
626 hexdump( iov
[1].iov_base
, iov
[1].iov_len
);
627 hexdump( iov
[2].iov_base
, iov
[2].iov_len
);
629 if (ule_where
== ule_hist
) {
630 hexdump( &ule_hist
[98*TS_SZ
], TS_SZ
);
631 hexdump( &ule_hist
[99*TS_SZ
], TS_SZ
);
632 } else if (ule_where
== &ule_hist
[TS_SZ
]) {
633 hexdump( &ule_hist
[99*TS_SZ
], TS_SZ
);
634 hexdump( ule_hist
, TS_SZ
);
636 hexdump( ule_where
- TS_SZ
- TS_SZ
, TS_SZ
);
637 hexdump( ule_where
- TS_SZ
, TS_SZ
);
642 dev
->stats
.rx_errors
++;
643 dev
->stats
.rx_crc_errors
++;
644 dev_kfree_skb(priv
->ule_skb
);
646 /* CRC32 verified OK. */
647 u8 dest_addr
[ETH_ALEN
];
648 static const u8 bc_addr
[ETH_ALEN
] =
649 { [ 0 ... ETH_ALEN
-1] = 0xff };
651 /* CRC32 was OK. Remove it from skb. */
652 priv
->ule_skb
->tail
-= 4;
653 priv
->ule_skb
->len
-= 4;
655 if (!priv
->ule_dbit
) {
657 * The destination MAC address is the
658 * next data in the skb. It comes
659 * before any extension headers.
661 * Check if the payload of this SNDU
662 * should be passed up the stack.
664 register int drop
= 0;
665 if (priv
->rx_mode
!= RX_MODE_PROMISC
) {
666 if (priv
->ule_skb
->data
[0] & 0x01) {
667 /* multicast or broadcast */
668 if (memcmp(priv
->ule_skb
->data
, bc_addr
, ETH_ALEN
)) {
670 if (priv
->rx_mode
== RX_MODE_MULTI
) {
672 for(i
= 0; i
< priv
->multi_num
&& memcmp(priv
->ule_skb
->data
, priv
->multi_macs
[i
], ETH_ALEN
); i
++)
674 if (i
== priv
->multi_num
)
676 } else if (priv
->rx_mode
!= RX_MODE_ALL_MULTI
)
677 drop
= 1; /* no broadcast; */
678 /* else: all multicast mode: accept all multicast packets */
680 /* else: broadcast */
682 else if (memcmp(priv
->ule_skb
->data
, dev
->dev_addr
, ETH_ALEN
))
684 /* else: destination address matches the MAC address of our receiver device */
686 /* else: promiscuous mode; pass everything up the stack */
690 dprintk("Dropping SNDU: MAC destination address does not match: dest addr: "MAC_ADDR_PRINTFMT
", dev addr: "MAC_ADDR_PRINTFMT
"\n",
691 MAX_ADDR_PRINTFMT_ARGS(priv
->ule_skb
->data
), MAX_ADDR_PRINTFMT_ARGS(dev
->dev_addr
));
693 dev_kfree_skb(priv
->ule_skb
);
698 skb_copy_from_linear_data(priv
->ule_skb
,
701 skb_pull(priv
->ule_skb
, ETH_ALEN
);
705 /* Handle ULE Extension Headers. */
706 if (priv
->ule_sndu_type
< 1536) {
707 /* There is an extension header. Handle it accordingly. */
708 int l
= handle_ule_extensions(priv
);
710 /* Mandatory extension header unknown or TEST SNDU. Drop it. */
711 // printk( KERN_WARNING "Dropping SNDU, extension headers.\n" );
712 dev_kfree_skb(priv
->ule_skb
);
715 skb_pull(priv
->ule_skb
, l
);
719 * Construct/assure correct ethernet header.
720 * Note: in bridged mode (priv->ule_bridged !=
721 * 0) we already have the (original) ethernet
722 * header at the start of the payload (after
723 * optional dest. address and any extension
727 if (!priv
->ule_bridged
) {
728 skb_push(priv
->ule_skb
, ETH_HLEN
);
729 ethh
= (struct ethhdr
*)priv
->ule_skb
->data
;
730 if (!priv
->ule_dbit
) {
731 /* dest_addr buffer is only valid if priv->ule_dbit == 0 */
732 memcpy(ethh
->h_dest
, dest_addr
, ETH_ALEN
);
733 memset(ethh
->h_source
, 0, ETH_ALEN
);
735 else /* zeroize source and dest */
736 memset( ethh
, 0, ETH_ALEN
*2 );
738 ethh
->h_proto
= htons(priv
->ule_sndu_type
);
740 /* else: skb is in correct state; nothing to do. */
741 priv
->ule_bridged
= 0;
743 /* Stuff into kernel's protocol stack. */
744 priv
->ule_skb
->protocol
= dvb_net_eth_type_trans(priv
->ule_skb
, dev
);
745 /* If D-bit is set (i.e. destination MAC address not present),
746 * receive the packet anyhow. */
747 /* if (priv->ule_dbit && skb->pkt_type == PACKET_OTHERHOST)
748 priv->ule_skb->pkt_type = PACKET_HOST; */
749 dev
->stats
.rx_packets
++;
750 dev
->stats
.rx_bytes
+= priv
->ule_skb
->len
;
751 netif_rx(priv
->ule_skb
);
754 /* Prepare for next SNDU. */
758 /* More data in current TS (look at the bytes following the CRC32)? */
759 if (ts_remain
>= 2 && *((unsigned short *)from_where
) != 0xFFFF) {
760 /* Next ULE SNDU starts right there. */
762 priv
->ule_skb
= NULL
;
763 priv
->ule_sndu_type_1
= 0;
764 priv
->ule_sndu_len
= 0;
765 // printk(KERN_WARNING "More data in current TS: [%#x %#x %#x %#x]\n",
766 // *(from_where + 0), *(from_where + 1),
767 // *(from_where + 2), *(from_where + 3));
768 // printk(KERN_WARNING "ts @ %p, stopped @ %p:\n", ts, from_where + 0);
774 if (priv
->ule_skb
== NULL
) {
776 priv
->ule_sndu_type_1
= 0;
777 priv
->ule_sndu_len
= 0;
780 } /* for all available TS cells */
783 static int dvb_net_ts_callback(const u8
*buffer1
, size_t buffer1_len
,
784 const u8
*buffer2
, size_t buffer2_len
,
785 struct dmx_ts_feed
*feed
, enum dmx_success success
)
787 struct net_device
*dev
= feed
->priv
;
790 printk(KERN_WARNING
"buffer2 not NULL: %p.\n", buffer2
);
791 if (buffer1_len
> 32768)
792 printk(KERN_WARNING
"length > 32k: %zu.\n", buffer1_len
);
793 /* printk("TS callback: %u bytes, %u TS cells @ %p.\n",
794 buffer1_len, buffer1_len / TS_SZ, buffer1); */
795 dvb_net_ule(dev
, buffer1
, buffer1_len
);
800 static void dvb_net_sec(struct net_device
*dev
,
801 const u8
*pkt
, int pkt_len
)
805 struct net_device_stats
*stats
= &dev
->stats
;
808 /* note: pkt_len includes a 32bit checksum */
810 printk("%s: IP/MPE packet length = %d too small.\n",
813 stats
->rx_length_errors
++;
816 /* it seems some ISPs manage to screw up here, so we have to
817 * relax the error checks... */
819 if ((pkt
[5] & 0xfd) != 0xc1) {
820 /* drop scrambled or broken packets */
822 if ((pkt
[5] & 0x3c) != 0x00) {
826 stats
->rx_crc_errors
++;
830 /* handle LLC/SNAP, see rfc-1042 */
831 if (pkt_len
< 24 || memcmp(&pkt
[12], "\xaa\xaa\x03\0\0\0", 6)) {
838 /* FIXME: assemble datagram from multiple sections */
840 stats
->rx_frame_errors
++;
844 /* we have 14 byte ethernet header (ip header follows);
845 * 12 byte MPE header; 4 byte checksum; + 2 byte alignment, 8 byte LLC/SNAP
847 if (!(skb
= dev_alloc_skb(pkt_len
- 4 - 12 + 14 + 2 - snap
))) {
848 //printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
852 skb_reserve(skb
, 2); /* longword align L3 header */
855 /* copy L3 payload */
856 eth
= (u8
*) skb_put(skb
, pkt_len
- 12 - 4 + 14 - snap
);
857 memcpy(eth
+ 14, pkt
+ 12 + snap
, pkt_len
- 12 - 4 - snap
);
859 /* create ethernet header: */
867 eth
[6]=eth
[7]=eth
[8]=eth
[9]=eth
[10]=eth
[11]=0;
873 /* protocol numbers are from rfc-1700 or
874 * http://www.iana.org/assignments/ethernet-numbers
876 if (pkt
[12] >> 4 == 6) { /* version field from IP header */
877 eth
[12] = 0x86; /* IPv6 */
880 eth
[12] = 0x08; /* IPv4 */
885 skb
->protocol
= dvb_net_eth_type_trans(skb
, dev
);
888 stats
->rx_bytes
+=skb
->len
;
892 static int dvb_net_sec_callback(const u8
*buffer1
, size_t buffer1_len
,
893 const u8
*buffer2
, size_t buffer2_len
,
894 struct dmx_section_filter
*filter
,
895 enum dmx_success success
)
897 struct net_device
*dev
= filter
->priv
;
900 * we rely on the DVB API definition where exactly one complete
901 * section is delivered in buffer1
903 dvb_net_sec (dev
, buffer1
, buffer1_len
);
907 static int dvb_net_tx(struct sk_buff
*skb
, struct net_device
*dev
)
913 static u8 mask_normal
[6]={0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
914 static u8 mask_allmulti
[6]={0xff, 0xff, 0xff, 0x00, 0x00, 0x00};
915 static u8 mac_allmulti
[6]={0x01, 0x00, 0x5e, 0x00, 0x00, 0x00};
916 static u8 mask_promisc
[6]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
918 static int dvb_net_filter_sec_set(struct net_device
*dev
,
919 struct dmx_section_filter
**secfilter
,
920 u8
*mac
, u8
*mac_mask
)
922 struct dvb_net_priv
*priv
= netdev_priv(dev
);
926 ret
= priv
->secfeed
->allocate_filter(priv
->secfeed
, secfilter
);
928 printk("%s: could not get filter\n", dev
->name
);
932 (*secfilter
)->priv
=(void *) dev
;
934 memset((*secfilter
)->filter_value
, 0x00, DMX_MAX_FILTER_SIZE
);
935 memset((*secfilter
)->filter_mask
, 0x00, DMX_MAX_FILTER_SIZE
);
936 memset((*secfilter
)->filter_mode
, 0xff, DMX_MAX_FILTER_SIZE
);
938 (*secfilter
)->filter_value
[0]=0x3e;
939 (*secfilter
)->filter_value
[3]=mac
[5];
940 (*secfilter
)->filter_value
[4]=mac
[4];
941 (*secfilter
)->filter_value
[8]=mac
[3];
942 (*secfilter
)->filter_value
[9]=mac
[2];
943 (*secfilter
)->filter_value
[10]=mac
[1];
944 (*secfilter
)->filter_value
[11]=mac
[0];
946 (*secfilter
)->filter_mask
[0] = 0xff;
947 (*secfilter
)->filter_mask
[3] = mac_mask
[5];
948 (*secfilter
)->filter_mask
[4] = mac_mask
[4];
949 (*secfilter
)->filter_mask
[8] = mac_mask
[3];
950 (*secfilter
)->filter_mask
[9] = mac_mask
[2];
951 (*secfilter
)->filter_mask
[10] = mac_mask
[1];
952 (*secfilter
)->filter_mask
[11]=mac_mask
[0];
954 dprintk("%s: filter mac=%pM\n", dev
->name
, mac
);
955 dprintk("%s: filter mask=%pM\n", dev
->name
, mac_mask
);
960 static int dvb_net_feed_start(struct net_device
*dev
)
963 struct dvb_net_priv
*priv
= netdev_priv(dev
);
964 struct dmx_demux
*demux
= priv
->demux
;
965 unsigned char *mac
= (unsigned char *) dev
->dev_addr
;
967 dprintk("%s: rx_mode %i\n", __func__
, priv
->rx_mode
);
968 mutex_lock(&priv
->mutex
);
969 if (priv
->tsfeed
|| priv
->secfeed
|| priv
->secfilter
|| priv
->multi_secfilter
[0])
970 printk("%s: BUG %d\n", __func__
, __LINE__
);
973 priv
->secfilter
=NULL
;
976 if (priv
->feedtype
== DVB_NET_FEEDTYPE_MPE
) {
977 dprintk("%s: alloc secfeed\n", __func__
);
978 ret
=demux
->allocate_section_feed(demux
, &priv
->secfeed
,
979 dvb_net_sec_callback
);
981 printk("%s: could not allocate section feed\n", dev
->name
);
985 ret
= priv
->secfeed
->set(priv
->secfeed
, priv
->pid
, 32768, 1);
988 printk("%s: could not set section feed\n", dev
->name
);
989 priv
->demux
->release_section_feed(priv
->demux
, priv
->secfeed
);
994 if (priv
->rx_mode
!= RX_MODE_PROMISC
) {
995 dprintk("%s: set secfilter\n", __func__
);
996 dvb_net_filter_sec_set(dev
, &priv
->secfilter
, mac
, mask_normal
);
999 switch (priv
->rx_mode
) {
1001 for (i
= 0; i
< priv
->multi_num
; i
++) {
1002 dprintk("%s: set multi_secfilter[%d]\n", __func__
, i
);
1003 dvb_net_filter_sec_set(dev
, &priv
->multi_secfilter
[i
],
1004 priv
->multi_macs
[i
], mask_normal
);
1007 case RX_MODE_ALL_MULTI
:
1009 dprintk("%s: set multi_secfilter[0]\n", __func__
);
1010 dvb_net_filter_sec_set(dev
, &priv
->multi_secfilter
[0],
1011 mac_allmulti
, mask_allmulti
);
1013 case RX_MODE_PROMISC
:
1015 dprintk("%s: set secfilter\n", __func__
);
1016 dvb_net_filter_sec_set(dev
, &priv
->secfilter
, mac
, mask_promisc
);
1020 dprintk("%s: start filtering\n", __func__
);
1021 priv
->secfeed
->start_filtering(priv
->secfeed
);
1022 } else if (priv
->feedtype
== DVB_NET_FEEDTYPE_ULE
) {
1023 struct timespec timeout
= { 0, 10000000 }; // 10 msec
1025 /* we have payloads encapsulated in TS */
1026 dprintk("%s: alloc tsfeed\n", __func__
);
1027 ret
= demux
->allocate_ts_feed(demux
, &priv
->tsfeed
, dvb_net_ts_callback
);
1029 printk("%s: could not allocate ts feed\n", dev
->name
);
1033 /* Set netdevice pointer for ts decaps callback. */
1034 priv
->tsfeed
->priv
= (void *)dev
;
1035 ret
= priv
->tsfeed
->set(priv
->tsfeed
,
1036 priv
->pid
, /* pid */
1037 TS_PACKET
, /* type */
1038 DMX_TS_PES_OTHER
, /* pes type */
1039 32768, /* circular buffer size */
1040 timeout
/* timeout */
1044 printk("%s: could not set ts feed\n", dev
->name
);
1045 priv
->demux
->release_ts_feed(priv
->demux
, priv
->tsfeed
);
1046 priv
->tsfeed
= NULL
;
1050 dprintk("%s: start filtering\n", __func__
);
1051 priv
->tsfeed
->start_filtering(priv
->tsfeed
);
1056 mutex_unlock(&priv
->mutex
);
1060 static int dvb_net_feed_stop(struct net_device
*dev
)
1062 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1065 dprintk("%s\n", __func__
);
1066 mutex_lock(&priv
->mutex
);
1067 if (priv
->feedtype
== DVB_NET_FEEDTYPE_MPE
) {
1068 if (priv
->secfeed
) {
1069 if (priv
->secfeed
->is_filtering
) {
1070 dprintk("%s: stop secfeed\n", __func__
);
1071 priv
->secfeed
->stop_filtering(priv
->secfeed
);
1074 if (priv
->secfilter
) {
1075 dprintk("%s: release secfilter\n", __func__
);
1076 priv
->secfeed
->release_filter(priv
->secfeed
,
1078 priv
->secfilter
=NULL
;
1081 for (i
=0; i
<priv
->multi_num
; i
++) {
1082 if (priv
->multi_secfilter
[i
]) {
1083 dprintk("%s: release multi_filter[%d]\n",
1085 priv
->secfeed
->release_filter(priv
->secfeed
,
1086 priv
->multi_secfilter
[i
]);
1087 priv
->multi_secfilter
[i
] = NULL
;
1091 priv
->demux
->release_section_feed(priv
->demux
, priv
->secfeed
);
1092 priv
->secfeed
= NULL
;
1094 printk("%s: no feed to stop\n", dev
->name
);
1095 } else if (priv
->feedtype
== DVB_NET_FEEDTYPE_ULE
) {
1097 if (priv
->tsfeed
->is_filtering
) {
1098 dprintk("%s: stop tsfeed\n", __func__
);
1099 priv
->tsfeed
->stop_filtering(priv
->tsfeed
);
1101 priv
->demux
->release_ts_feed(priv
->demux
, priv
->tsfeed
);
1102 priv
->tsfeed
= NULL
;
1105 printk("%s: no ts feed to stop\n", dev
->name
);
1108 mutex_unlock(&priv
->mutex
);
1113 static int dvb_set_mc_filter (struct net_device
*dev
, struct dev_mc_list
*mc
)
1115 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1117 if (priv
->multi_num
== DVB_NET_MULTICAST_MAX
)
1120 memcpy(priv
->multi_macs
[priv
->multi_num
], mc
->dmi_addr
, 6);
1127 static void wq_set_multicast_list (struct work_struct
*work
)
1129 struct dvb_net_priv
*priv
=
1130 container_of(work
, struct dvb_net_priv
, set_multicast_list_wq
);
1131 struct net_device
*dev
= priv
->net
;
1133 dvb_net_feed_stop(dev
);
1134 priv
->rx_mode
= RX_MODE_UNI
;
1135 netif_addr_lock_bh(dev
);
1137 if (dev
->flags
& IFF_PROMISC
) {
1138 dprintk("%s: promiscuous mode\n", dev
->name
);
1139 priv
->rx_mode
= RX_MODE_PROMISC
;
1140 } else if ((dev
->flags
& IFF_ALLMULTI
)) {
1141 dprintk("%s: allmulti mode\n", dev
->name
);
1142 priv
->rx_mode
= RX_MODE_ALL_MULTI
;
1143 } else if (!netdev_mc_empty(dev
)) {
1145 struct dev_mc_list
*mc
;
1147 dprintk("%s: set_mc_list, %d entries\n",
1148 dev
->name
, netdev_mc_count(dev
));
1150 priv
->rx_mode
= RX_MODE_MULTI
;
1151 priv
->multi_num
= 0;
1153 for (mci
= 0, mc
=dev
->mc_list
;
1154 mci
< netdev_mc_count(dev
);
1155 mc
= mc
->next
, mci
++) {
1156 dvb_set_mc_filter(dev
, mc
);
1160 netif_addr_unlock_bh(dev
);
1161 dvb_net_feed_start(dev
);
1165 static void dvb_net_set_multicast_list (struct net_device
*dev
)
1167 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1168 schedule_work(&priv
->set_multicast_list_wq
);
1172 static void wq_restart_net_feed (struct work_struct
*work
)
1174 struct dvb_net_priv
*priv
=
1175 container_of(work
, struct dvb_net_priv
, restart_net_feed_wq
);
1176 struct net_device
*dev
= priv
->net
;
1178 if (netif_running(dev
)) {
1179 dvb_net_feed_stop(dev
);
1180 dvb_net_feed_start(dev
);
1185 static int dvb_net_set_mac (struct net_device
*dev
, void *p
)
1187 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1188 struct sockaddr
*addr
=p
;
1190 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1192 if (netif_running(dev
))
1193 schedule_work(&priv
->restart_net_feed_wq
);
1199 static int dvb_net_open(struct net_device
*dev
)
1201 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1204 dvb_net_feed_start(dev
);
1209 static int dvb_net_stop(struct net_device
*dev
)
1211 struct dvb_net_priv
*priv
= netdev_priv(dev
);
1214 return dvb_net_feed_stop(dev
);
1217 static const struct header_ops dvb_header_ops
= {
1218 .create
= eth_header
,
1219 .parse
= eth_header_parse
,
1220 .rebuild
= eth_rebuild_header
,
1224 static const struct net_device_ops dvb_netdev_ops
= {
1225 .ndo_open
= dvb_net_open
,
1226 .ndo_stop
= dvb_net_stop
,
1227 .ndo_start_xmit
= dvb_net_tx
,
1228 .ndo_set_multicast_list
= dvb_net_set_multicast_list
,
1229 .ndo_set_mac_address
= dvb_net_set_mac
,
1230 .ndo_change_mtu
= eth_change_mtu
,
1231 .ndo_validate_addr
= eth_validate_addr
,
1234 static void dvb_net_setup(struct net_device
*dev
)
1238 dev
->header_ops
= &dvb_header_ops
;
1239 dev
->netdev_ops
= &dvb_netdev_ops
;
1242 dev
->flags
|= IFF_NOARP
;
1245 static int get_if(struct dvb_net
*dvbnet
)
1249 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++)
1250 if (!dvbnet
->state
[i
])
1253 if (i
== DVB_NET_DEVICES_MAX
)
1260 static int dvb_net_add_if(struct dvb_net
*dvbnet
, u16 pid
, u8 feedtype
)
1262 struct net_device
*net
;
1263 struct dvb_net_priv
*priv
;
1267 if (feedtype
!= DVB_NET_FEEDTYPE_MPE
&& feedtype
!= DVB_NET_FEEDTYPE_ULE
)
1269 if ((if_num
= get_if(dvbnet
)) < 0)
1272 net
= alloc_netdev(sizeof(struct dvb_net_priv
), "dvb", dvb_net_setup
);
1276 if (dvbnet
->dvbdev
->id
)
1277 snprintf(net
->name
, IFNAMSIZ
, "dvb%d%u%d",
1278 dvbnet
->dvbdev
->adapter
->num
, dvbnet
->dvbdev
->id
, if_num
);
1280 /* compatibility fix to keep dvb0_0 format */
1281 snprintf(net
->name
, IFNAMSIZ
, "dvb%d_%d",
1282 dvbnet
->dvbdev
->adapter
->num
, if_num
);
1285 memcpy(net
->dev_addr
, dvbnet
->dvbdev
->adapter
->proposed_mac
, 6);
1287 dvbnet
->device
[if_num
] = net
;
1289 priv
= netdev_priv(net
);
1291 priv
->demux
= dvbnet
->demux
;
1293 priv
->rx_mode
= RX_MODE_UNI
;
1294 priv
->need_pusi
= 1;
1296 priv
->feedtype
= feedtype
;
1299 INIT_WORK(&priv
->set_multicast_list_wq
, wq_set_multicast_list
);
1300 INIT_WORK(&priv
->restart_net_feed_wq
, wq_restart_net_feed
);
1301 mutex_init(&priv
->mutex
);
1303 net
->base_addr
= pid
;
1305 if ((result
= register_netdev(net
)) < 0) {
1306 dvbnet
->device
[if_num
] = NULL
;
1310 printk("dvb_net: created network interface %s\n", net
->name
);
1315 static int dvb_net_remove_if(struct dvb_net
*dvbnet
, unsigned long num
)
1317 struct net_device
*net
= dvbnet
->device
[num
];
1318 struct dvb_net_priv
*priv
;
1320 if (!dvbnet
->state
[num
])
1322 priv
= netdev_priv(net
);
1327 flush_scheduled_work();
1328 printk("dvb_net: removed network interface %s\n", net
->name
);
1329 unregister_netdev(net
);
1330 dvbnet
->state
[num
]=0;
1331 dvbnet
->device
[num
] = NULL
;
1337 static int dvb_net_do_ioctl(struct file
*file
,
1338 unsigned int cmd
, void *parg
)
1340 struct dvb_device
*dvbdev
= file
->private_data
;
1341 struct dvb_net
*dvbnet
= dvbdev
->priv
;
1343 if (((file
->f_flags
&O_ACCMODE
)==O_RDONLY
))
1349 struct dvb_net_if
*dvbnetif
= parg
;
1352 if (!capable(CAP_SYS_ADMIN
))
1355 if (!try_module_get(dvbdev
->adapter
->module
))
1358 result
=dvb_net_add_if(dvbnet
, dvbnetif
->pid
, dvbnetif
->feedtype
);
1360 module_put(dvbdev
->adapter
->module
);
1363 dvbnetif
->if_num
=result
;
1368 struct net_device
*netdev
;
1369 struct dvb_net_priv
*priv_data
;
1370 struct dvb_net_if
*dvbnetif
= parg
;
1372 if (dvbnetif
->if_num
>= DVB_NET_DEVICES_MAX
||
1373 !dvbnet
->state
[dvbnetif
->if_num
])
1376 netdev
= dvbnet
->device
[dvbnetif
->if_num
];
1378 priv_data
= netdev_priv(netdev
);
1379 dvbnetif
->pid
=priv_data
->pid
;
1380 dvbnetif
->feedtype
=priv_data
->feedtype
;
1387 if (!capable(CAP_SYS_ADMIN
))
1389 if ((unsigned long) parg
>= DVB_NET_DEVICES_MAX
)
1391 ret
= dvb_net_remove_if(dvbnet
, (unsigned long) parg
);
1393 module_put(dvbdev
->adapter
->module
);
1397 /* binary compatibility cruft */
1398 case __NET_ADD_IF_OLD
:
1400 struct __dvb_net_if_old
*dvbnetif
= parg
;
1403 if (!capable(CAP_SYS_ADMIN
))
1406 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
);
1414 dvbnetif
->if_num
=result
;
1417 case __NET_GET_IF_OLD
:
1419 struct net_device
*netdev
;
1420 struct dvb_net_priv
*priv_data
;
1421 struct __dvb_net_if_old
*dvbnetif
= parg
;
1423 if (dvbnetif
->if_num
>= DVB_NET_DEVICES_MAX
||
1424 !dvbnet
->state
[dvbnetif
->if_num
])
1427 netdev
= dvbnet
->device
[dvbnetif
->if_num
];
1429 priv_data
= netdev_priv(netdev
);
1430 dvbnetif
->pid
=priv_data
->pid
;
1439 static long dvb_net_ioctl(struct file
*file
,
1440 unsigned int cmd
, unsigned long arg
)
1445 ret
= dvb_usercopy(file
, cmd
, arg
, dvb_net_do_ioctl
);
1451 static int dvb_net_close(struct inode
*inode
, struct file
*file
)
1453 struct dvb_device
*dvbdev
= file
->private_data
;
1454 struct dvb_net
*dvbnet
= dvbdev
->priv
;
1456 dvb_generic_release(inode
, file
);
1458 if(dvbdev
->users
== 1 && dvbnet
->exit
== 1) {
1459 fops_put(file
->f_op
);
1461 wake_up(&dvbdev
->wait_queue
);
1467 static const struct file_operations dvb_net_fops
= {
1468 .owner
= THIS_MODULE
,
1469 .unlocked_ioctl
= dvb_net_ioctl
,
1470 .open
= dvb_generic_open
,
1471 .release
= dvb_net_close
,
1474 static struct dvb_device dvbdev_net
= {
1478 .fops
= &dvb_net_fops
,
1482 void dvb_net_release (struct dvb_net
*dvbnet
)
1487 if (dvbnet
->dvbdev
->users
< 1)
1488 wait_event(dvbnet
->dvbdev
->wait_queue
,
1489 dvbnet
->dvbdev
->users
==1);
1491 dvb_unregister_device(dvbnet
->dvbdev
);
1493 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++) {
1494 if (!dvbnet
->state
[i
])
1496 dvb_net_remove_if(dvbnet
, i
);
1499 EXPORT_SYMBOL(dvb_net_release
);
1502 int dvb_net_init (struct dvb_adapter
*adap
, struct dvb_net
*dvbnet
,
1503 struct dmx_demux
*dmx
)
1507 dvbnet
->demux
= dmx
;
1509 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++)
1510 dvbnet
->state
[i
] = 0;
1512 dvb_register_device (adap
, &dvbnet
->dvbdev
, &dvbdev_net
,
1513 dvbnet
, DVB_DEVICE_NET
);
1517 EXPORT_SYMBOL(dvb_net_init
);