4 * Copyright (C) 2001 Convergence integrated media GmbH
5 * Ralph Metzler <ralph@convergence.de>
6 * Copyright (C) 2002 Ralph Metzler <rjkm@metzlerbros.de>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
27 #include <linux/dvb/net.h>
28 #include <asm/uaccess.h>
30 #include "dvb_demux.h"
32 #include "dvb_functions.h"
36 #define dprintk(x...) printk(x)
42 #define DVB_NET_MULTICAST_MAX 10
46 struct net_device_stats stats
;
49 struct dmx_demux
*demux
;
50 struct dmx_section_feed
*secfeed
;
51 struct dmx_section_filter
*secfilter
;
53 struct dmx_section_filter
*multi_secfilter
[DVB_NET_MULTICAST_MAX
];
54 unsigned char multi_macs
[DVB_NET_MULTICAST_MAX
][6];
57 #define RX_MODE_MULTI 1
58 #define RX_MODE_ALL_MULTI 2
59 #define RX_MODE_PROMISC 3
60 struct work_struct set_multicast_list_wq
;
61 struct work_struct restart_net_feed_wq
;
66 * Determine the packet's protocol ID. The rule here is that we
67 * assume 802.3 if the type field is short enough to be a length.
68 * This is normal practice and works for any 'now in use' protocol.
70 * stolen from eth.c out of the linux kernel, hacked for dvb-device
71 * by Michael Holzt <kju@debian.org>
73 static unsigned short dvb_net_eth_type_trans(struct sk_buff
*skb
,
74 struct net_device
*dev
)
79 skb
->mac
.raw
=skb
->data
;
80 skb_pull(skb
,dev
->hard_header_len
);
81 eth
= skb
->mac
.ethernet
;
83 if (*eth
->h_dest
& 1) {
84 if(memcmp(eth
->h_dest
,dev
->broadcast
, ETH_ALEN
)==0)
85 skb
->pkt_type
=PACKET_BROADCAST
;
87 skb
->pkt_type
=PACKET_MULTICAST
;
90 if (ntohs(eth
->h_proto
) >= 1536)
96 * This is a magic hack to spot IPX packets. Older Novell breaks
97 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
98 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
99 * won't work for fault tolerant netware but does for the rest.
101 if (*(unsigned short *)rawp
== 0xFFFF)
102 return htons(ETH_P_802_3
);
107 return htons(ETH_P_802_2
);
111 static void dvb_net_sec(struct net_device
*dev
, u8
*pkt
, int pkt_len
)
116 /* note: pkt_len includes a 32bit checksum */
118 printk("%s: IP/MPE packet length = %d too small.\n",
120 ((struct dvb_net_priv
*) dev
->priv
)->stats
.rx_errors
++;
121 ((struct dvb_net_priv
*) dev
->priv
)->stats
.rx_length_errors
++;
124 if ((pkt
[5] & 0xfd) != 0xc1) {
125 /* drop scrambled or broken packets */
126 ((struct dvb_net_priv
*) dev
->priv
)->stats
.rx_errors
++;
127 ((struct dvb_net_priv
*) dev
->priv
)->stats
.rx_crc_errors
++;
131 //FIXME: handle LLC/SNAP
132 ((struct dvb_net_priv
*)dev
->priv
)->stats
.rx_dropped
++;
136 /* FIXME: assemble datagram from multiple sections */
137 ((struct dvb_net_priv
*) dev
->priv
)->stats
.rx_errors
++;
138 ((struct dvb_net_priv
*) dev
->priv
)->stats
.rx_frame_errors
++;
142 /* we have 14 byte ethernet header (ip header follows);
143 * 12 byte MPE header; 4 byte checksum; + 2 byte alignment
145 if (!(skb
= dev_alloc_skb(pkt_len
- 4 - 12 + 14 + 2))) {
146 //printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
147 ((struct dvb_net_priv
*) dev
->priv
)->stats
.rx_dropped
++;
150 skb_reserve(skb
, 2); /* longword align L3 header */
153 /* copy L3 payload */
154 eth
= (u8
*) skb_put(skb
, pkt_len
- 12 - 4 + 14);
155 memcpy(eth
+ 14, pkt
+ 12, pkt_len
- 12 - 4);
157 /* create ethernet header: */
165 eth
[6]=eth
[7]=eth
[8]=eth
[9]=eth
[10]=eth
[11]=0;
167 eth
[12] = 0x08; /* ETH_P_IP */
170 skb
->protocol
= dvb_net_eth_type_trans(skb
, dev
);
172 ((struct dvb_net_priv
*)dev
->priv
)->stats
.rx_packets
++;
173 ((struct dvb_net_priv
*)dev
->priv
)->stats
.rx_bytes
+=skb
->len
;
177 static int dvb_net_callback(const u8
*buffer1
, size_t buffer1_len
,
178 const u8
*buffer2
, size_t buffer2_len
,
179 struct dmx_section_filter
*filter
,
180 enum dmx_success success
)
182 struct net_device
*dev
=(struct net_device
*) filter
->priv
;
185 * we rely on the DVB API definition where exactly one complete
186 * section is delivered in buffer1
188 dvb_net_sec (dev
, (u8
*) buffer1
, buffer1_len
);
192 static int dvb_net_tx(struct sk_buff
*skb
, struct net_device
*dev
)
197 static u8 mask_normal
[6]={0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
198 static u8 mask_allmulti
[6]={0xff, 0xff, 0xff, 0x00, 0x00, 0x00};
199 static u8 mac_allmulti
[6]={0x01, 0x00, 0x5e, 0x00, 0x00, 0x00};
200 static u8 mask_promisc
[6]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
202 static int dvb_net_filter_set(struct net_device
*dev
,
203 struct dmx_section_filter
**secfilter
,
204 u8
*mac
, u8
*mac_mask
)
206 struct dvb_net_priv
*priv
= (struct dvb_net_priv
*) dev
->priv
;
210 ret
= priv
->secfeed
->allocate_filter(priv
->secfeed
, secfilter
);
212 printk("%s: could not get filter\n", dev
->name
);
216 (*secfilter
)->priv
=(void *) dev
;
218 memset((*secfilter
)->filter_value
, 0x00, DMX_MAX_FILTER_SIZE
);
219 memset((*secfilter
)->filter_mask
, 0x00, DMX_MAX_FILTER_SIZE
);
220 memset((*secfilter
)->filter_mode
, 0xff, DMX_MAX_FILTER_SIZE
);
222 (*secfilter
)->filter_value
[0]=0x3e;
223 (*secfilter
)->filter_value
[3]=mac
[5];
224 (*secfilter
)->filter_value
[4]=mac
[4];
225 (*secfilter
)->filter_value
[8]=mac
[3];
226 (*secfilter
)->filter_value
[9]=mac
[2];
227 (*secfilter
)->filter_value
[10]=mac
[1];
228 (*secfilter
)->filter_value
[11]=mac
[0];
230 (*secfilter
)->filter_mask
[0] = 0xff;
231 (*secfilter
)->filter_mask
[3] = mac_mask
[5];
232 (*secfilter
)->filter_mask
[4] = mac_mask
[4];
233 (*secfilter
)->filter_mask
[8] = mac_mask
[3];
234 (*secfilter
)->filter_mask
[9] = mac_mask
[2];
235 (*secfilter
)->filter_mask
[10] = mac_mask
[1];
236 (*secfilter
)->filter_mask
[11]=mac_mask
[0];
238 dprintk("%s: filter mac=%02x %02x %02x %02x %02x %02x\n",
239 dev
->name
, mac
[0], mac
[1], mac
[2], mac
[3], mac
[4], mac
[5]);
240 dprintk("%s: filter mask=%02x %02x %02x %02x %02x %02x\n",
241 dev
->name
, mac_mask
[0], mac_mask
[1], mac_mask
[2],
242 mac_mask
[3], mac_mask
[4], mac_mask
[5]);
247 static int dvb_net_feed_start(struct net_device
*dev
)
250 struct dvb_net_priv
*priv
= (struct dvb_net_priv
*) dev
->priv
;
251 struct dmx_demux
*demux
= priv
->demux
;
252 unsigned char *mac
= (unsigned char *) dev
->dev_addr
;
254 dprintk("%s: rx_mode %i\n", __FUNCTION__
, priv
->rx_mode
);
255 if (priv
->secfeed
|| priv
->secfilter
|| priv
->multi_secfilter
[0])
256 printk("%s: BUG %d\n", __FUNCTION__
, __LINE__
);
261 dprintk("%s: alloc secfeed\n", __FUNCTION__
);
262 ret
=demux
->allocate_section_feed(demux
, &priv
->secfeed
,
265 printk("%s: could not allocate section feed\n", dev
->name
);
269 ret
= priv
->secfeed
->set(priv
->secfeed
, priv
->pid
, 32768, 0, 1);
272 printk("%s: could not set section feed\n", dev
->name
);
273 priv
->demux
->release_section_feed(priv
->demux
, priv
->secfeed
);
278 if (priv
->rx_mode
!= RX_MODE_PROMISC
) {
279 dprintk("%s: set secfilter\n", __FUNCTION__
);
280 dvb_net_filter_set(dev
, &priv
->secfilter
, mac
, mask_normal
);
283 switch (priv
->rx_mode
) {
285 for (i
= 0; i
< priv
->multi_num
; i
++) {
286 dprintk("%s: set multi_secfilter[%d]\n", __FUNCTION__
, i
);
287 dvb_net_filter_set(dev
, &priv
->multi_secfilter
[i
],
288 priv
->multi_macs
[i
], mask_normal
);
291 case RX_MODE_ALL_MULTI
:
293 dprintk("%s: set multi_secfilter[0]\n", __FUNCTION__
);
294 dvb_net_filter_set(dev
, &priv
->multi_secfilter
[0],
295 mac_allmulti
, mask_allmulti
);
297 case RX_MODE_PROMISC
:
299 dprintk("%s: set secfilter\n", __FUNCTION__
);
300 dvb_net_filter_set(dev
, &priv
->secfilter
, mac
, mask_promisc
);
304 dprintk("%s: start filtering\n", __FUNCTION__
);
305 priv
->secfeed
->start_filtering(priv
->secfeed
);
309 static void dvb_net_feed_stop(struct net_device
*dev
)
311 struct dvb_net_priv
*priv
= (struct dvb_net_priv
*) dev
->priv
;
314 dprintk("%s\n", __FUNCTION__
);
316 if (priv
->secfeed
->is_filtering
) {
317 dprintk("%s: stop secfeed\n", __FUNCTION__
);
318 priv
->secfeed
->stop_filtering(priv
->secfeed
);
321 if (priv
->secfilter
) {
322 dprintk("%s: release secfilter\n", __FUNCTION__
);
323 priv
->secfeed
->release_filter(priv
->secfeed
,
328 for (i
=0; i
<priv
->multi_num
; i
++) {
329 if (priv
->multi_secfilter
[i
]) {
330 dprintk("%s: release multi_filter[%d]\n", __FUNCTION__
, i
);
331 priv
->secfeed
->release_filter(priv
->secfeed
,
332 priv
->multi_secfilter
[i
]);
333 priv
->multi_secfilter
[i
]=0;
337 priv
->demux
->release_section_feed(priv
->demux
, priv
->secfeed
);
340 printk("%s: no feed to stop\n", dev
->name
);
344 static int dvb_set_mc_filter (struct net_device
*dev
, struct dev_mc_list
*mc
)
346 struct dvb_net_priv
*priv
= (struct dvb_net_priv
*) dev
->priv
;
348 if (priv
->multi_num
== DVB_NET_MULTICAST_MAX
)
351 memcpy(priv
->multi_macs
[priv
->multi_num
], mc
->dmi_addr
, 6);
358 static void wq_set_multicast_list (void *data
)
360 struct net_device
*dev
= data
;
361 struct dvb_net_priv
*priv
= (struct dvb_net_priv
*) dev
->priv
;
363 dvb_net_feed_stop(dev
);
365 priv
->rx_mode
= RX_MODE_UNI
;
367 if(dev
->flags
& IFF_PROMISC
) {
368 dprintk("%s: promiscuous mode\n", dev
->name
);
369 priv
->rx_mode
= RX_MODE_PROMISC
;
370 } else if ((dev
->flags
& IFF_ALLMULTI
)) {
371 dprintk("%s: allmulti mode\n", dev
->name
);
372 priv
->rx_mode
= RX_MODE_ALL_MULTI
;
373 } else if (dev
->mc_count
) {
375 struct dev_mc_list
*mc
;
377 dprintk("%s: set_mc_list, %d entries\n",
378 dev
->name
, dev
->mc_count
);
380 priv
->rx_mode
= RX_MODE_MULTI
;
383 for (mci
= 0, mc
=dev
->mc_list
;
385 mc
= mc
->next
, mci
++) {
386 dvb_set_mc_filter(dev
, mc
);
390 dvb_net_feed_start(dev
);
394 static void dvb_net_set_multicast_list (struct net_device
*dev
)
396 struct dvb_net_priv
*priv
= (struct dvb_net_priv
*) dev
->priv
;
397 schedule_work(&priv
->set_multicast_list_wq
);
401 static int dvb_net_set_config(struct net_device
*dev
, struct ifmap
*map
)
403 if (netif_running(dev
))
409 static void wq_restart_net_feed (void *data
)
411 struct net_device
*dev
= data
;
413 if (netif_running(dev
)) {
414 dvb_net_feed_stop(dev
);
415 dvb_net_feed_start(dev
);
420 static int dvb_net_set_mac (struct net_device
*dev
, void *p
)
422 struct dvb_net_priv
*priv
= (struct dvb_net_priv
*) dev
->priv
;
423 struct sockaddr
*addr
=p
;
425 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
427 if (netif_running(dev
))
428 schedule_work(&priv
->restart_net_feed_wq
);
434 static int dvb_net_open(struct net_device
*dev
)
436 struct dvb_net_priv
*priv
= (struct dvb_net_priv
*) dev
->priv
;
439 dvb_net_feed_start(dev
);
444 static int dvb_net_stop(struct net_device
*dev
)
446 struct dvb_net_priv
*priv
= (struct dvb_net_priv
*) dev
->priv
;
449 dvb_net_feed_stop(dev
);
453 static struct net_device_stats
* dvb_net_get_stats(struct net_device
*dev
)
455 return &((struct dvb_net_priv
*) dev
->priv
)->stats
;
459 static int dvb_net_init_dev(struct net_device
*dev
)
463 dev
->open
= dvb_net_open
;
464 dev
->stop
= dvb_net_stop
;
465 dev
->hard_start_xmit
= dvb_net_tx
;
466 dev
->get_stats
= dvb_net_get_stats
;
467 dev
->set_multicast_list
= dvb_net_set_multicast_list
;
468 dev
->set_config
= dvb_net_set_config
;
469 dev
->set_mac_address
= dvb_net_set_mac
;
472 dev
->hard_header_cache
= NULL
;
474 dev
->flags
|= IFF_NOARP
;
479 static int get_if(struct dvb_net
*dvbnet
)
483 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++)
484 if (!dvbnet
->state
[i
])
487 if (i
== DVB_NET_DEVICES_MAX
)
495 static int dvb_net_add_if(struct dvb_net
*dvbnet
, u16 pid
)
497 struct net_device
*net
;
498 struct dmx_demux
*demux
;
499 struct dvb_net_priv
*priv
;
503 if ((if_num
= get_if(dvbnet
)) < 0)
506 net
=&dvbnet
->device
[if_num
];
509 memset(net
, 0, sizeof(struct net_device
));
511 memcpy(net
->name
, "dvb0_0", 7);
512 net
->name
[3] = dvbnet
->dvbdev
->adapter
->num
+ '0';
513 net
->name
[5] = if_num
+ '0';
515 memcpy(net
->dev_addr
, dvbnet
->dvbdev
->adapter
->proposed_mac
, 6);
517 net
->init
= dvb_net_init_dev
;
519 if (!(net
->priv
= kmalloc(sizeof(struct dvb_net_priv
), GFP_KERNEL
)))
523 memset(priv
, 0, sizeof(struct dvb_net_priv
));
526 priv
->rx_mode
= RX_MODE_UNI
;
528 INIT_WORK(&priv
->set_multicast_list_wq
, wq_set_multicast_list
, net
);
529 INIT_WORK(&priv
->restart_net_feed_wq
, wq_restart_net_feed
, net
);
531 net
->base_addr
= pid
;
533 if ((result
= register_netdev(net
)) < 0) {
541 static int dvb_net_remove_if(struct dvb_net
*dvbnet
, int num
)
543 struct dvb_net_priv
*priv
= dvbnet
->device
[num
].priv
;
545 if (!dvbnet
->state
[num
])
550 dvb_net_stop(&dvbnet
->device
[num
]);
551 flush_scheduled_work();
553 unregister_netdev(&dvbnet
->device
[num
]);
554 dvbnet
->state
[num
]=0;
559 static int dvb_net_do_ioctl(struct inode
*inode
, struct file
*file
,
560 unsigned int cmd
, void *parg
)
562 struct dvb_device
*dvbdev
= (struct dvb_device
*) file
->private_data
;
563 struct dvb_net
*dvbnet
= (struct dvb_net
*) dvbdev
->priv
;
565 if (((file
->f_flags
&O_ACCMODE
)==O_RDONLY
))
571 struct dvb_net_if
*dvbnetif
=(struct dvb_net_if
*)parg
;
574 if (!capable(CAP_SYS_ADMIN
))
576 result
=dvb_net_add_if(dvbnet
, dvbnetif
->pid
);
579 dvbnetif
->if_num
=result
;
584 struct net_device
*netdev
;
585 struct dvb_net_priv
*priv_data
;
586 struct dvb_net_if
*dvbnetif
=(struct dvb_net_if
*)parg
;
588 if (dvbnetif
->if_num
>= DVB_NET_DEVICES_MAX
||
589 !dvbnet
->state
[dvbnetif
->if_num
])
592 netdev
=(struct net_device
*)&dvbnet
->device
[dvbnetif
->if_num
];
593 priv_data
=(struct dvb_net_priv
*)netdev
->priv
;
594 dvbnetif
->pid
=priv_data
->pid
;
598 if (!capable(CAP_SYS_ADMIN
))
600 return dvb_net_remove_if(dvbnet
, (int) parg
);
607 static int dvb_net_ioctl(struct inode
*inode
, struct file
*file
,
608 unsigned int cmd
, unsigned long arg
)
610 return dvb_usercopy(inode
, file
, cmd
, arg
, dvb_net_do_ioctl
);
613 static struct file_operations dvb_net_fops
= {
614 .owner
= THIS_MODULE
,
617 .ioctl
= dvb_net_ioctl
,
618 .open
= dvb_generic_open
,
619 .release
= dvb_generic_release
,
623 static struct dvb_device dvbdev_net
= {
627 .fops
= &dvb_net_fops
,
631 void dvb_net_release (struct dvb_net
*dvbnet
)
635 dvb_unregister_device(dvbnet
->dvbdev
);
637 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++) {
638 if (!dvbnet
->state
[i
])
640 dvb_net_remove_if(dvbnet
, i
);
645 int dvb_net_init (struct dvb_adapter
*adap
, struct dvb_net
*dvbnet
,
646 struct dmx_demux
*dmx
)
652 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++)
653 dvbnet
->state
[i
] = 0;
655 dvb_register_device (adap
, &dvbnet
->dvbdev
, &dvbdev_net
,
656 dvbnet
, DVB_DEVICE_NET
);