?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / media / dvb / dvb-core / dvb_net.c
blobab18a9193fc4d46914fc1ed9bf364ae4097c128b
1 /*
2 * dvb_net.c
3 *
4 * Copyright (C) 2001 Convergence integrated media GmbH
5 * Ralph Metzler <ralph@convergence.de>
6 * Copyright (C) 2002 Ralph Metzler <rjkm@metzlerbros.de>
7 *
8 * ULE Decapsulation code:
9 * Copyright (C) 2003 gcs - Global Communication & Services GmbH.
10 * and Institute for Computer Sciences
11 * Salzburg University.
12 * Hilmar Linder <hlinder@cosy.sbg.ac.at>
13 * and Wolfram Stering <wstering@cosy.sbg.ac.at>
14 *
15 * ULE Decaps according to draft-fair-ipdvb-ule-01.txt.
16 *
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.
21 *
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.
26 *
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
31 */
32
33 #include <linux/kernel.h>
34 #include <linux/netdevice.h>
35 #include <linux/etherdevice.h>
36 #include <linux/dvb/net.h>
37 #include <linux/uio.h>
38 #include <asm/uaccess.h>
39 #include <linux/crc32.h>
40
41 #include "dvb_demux.h"
42 #include "dvb_net.h"
43 #include "dvb_functions.h"
44
45
46 static inline __u32 iov_crc32( __u32 c, struct kvec *iov, unsigned int cnt )
47 {
48 unsigned int j;
49 for (j = 0; j < cnt; j++)
50 c = crc32_be( c, iov[j].iov_base, iov[j].iov_len );
51 return c;
52 }
53
54
55 #if 1
56 #define dprintk(x...) printk(x)
57 #else
58 #define dprintk(x...)
59 #endif
60
61
62 #define DVB_NET_MULTICAST_MAX 10
63
64 #define isprint(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))
65
66 static void hexdump( const unsigned char *buf, unsigned short len )
67 {
68 char str[80], octet[10];
69 int ofs, i, l;
70
71 for (ofs = 0; ofs < len; ofs += 16) {
72 sprintf( str, "%03d: ", ofs );
73
74 for (i = 0; i < 16; i++) {
75 if ((i + ofs) < len)
76 sprintf( octet, "%02x ", buf[ofs + i] );
77 else
78 strcpy( octet, " " );
79
80 strcat( str, octet );
81 }
82 strcat( str, " " );
83 l = strlen( str );
84
85 for (i = 0; (i < 16) && ((i + ofs) < len); i++)
86 str[l++] = isprint( buf[ofs + i] ) ? buf[ofs + i] : '.';
87
88 str[l] = '\0';
89 printk( KERN_WARNING "%s\n", str );
90 }
91 }
92
93
94 struct dvb_net_priv {
95 int in_use;
96 struct net_device_stats stats;
97 char name[6];
98 u16 pid;
99 struct dvb_net *host;
100 struct dmx_demux *demux;
101 struct dmx_section_feed *secfeed;
102 struct dmx_section_filter *secfilter;
103 struct dmx_ts_feed *tsfeed;
104 int multi_num;
105 struct dmx_section_filter *multi_secfilter[DVB_NET_MULTICAST_MAX];
106 unsigned char multi_macs[DVB_NET_MULTICAST_MAX][6];
107 int rx_mode;
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;
115 int need_pusi;
116 unsigned char tscc; /* TS continuity counter after sync. */
117 struct sk_buff *ule_skb;
118 unsigned short ule_sndu_len;
119 unsigned short ule_sndu_type;
120 unsigned char ule_sndu_type_1;
121 unsigned char ule_dbit; /* whether the DestMAC address present
122 * bit is set or not. */
123 unsigned char ule_ethhdr_complete; /* whether we have completed the Ethernet
124 * header for the current ULE SNDU. */
125 int ule_sndu_remain;
126 };
127
128
129 /**
130 * Determine the packet's protocol ID. The rule here is that we
131 * assume 802.3 if the type field is short enough to be a length.
132 * This is normal practice and works for any 'now in use' protocol.
133 *
134 * stolen from eth.c out of the linux kernel, hacked for dvb-device
135 * by Michael Holzt <kju@debian.org>
136 */
137 static unsigned short dvb_net_eth_type_trans(struct sk_buff *skb,
138 struct net_device *dev)
139 {
140 struct ethhdr *eth;
141 unsigned char *rawp;
142
143 skb->mac.raw=skb->data;
144 skb_pull(skb,dev->hard_header_len);
145 eth = eth_hdr(skb);
146
147 if (*eth->h_dest & 1) {
148 if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)
149 skb->pkt_type=PACKET_BROADCAST;
150 else
151 skb->pkt_type=PACKET_MULTICAST;
152 }
153
154 if (ntohs(eth->h_proto) >= 1536)
155 return eth->h_proto;
156
157 rawp = skb->data;
158
159 /**
160 * This is a magic hack to spot IPX packets. Older Novell breaks
161 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
162 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
163 * won't work for fault tolerant netware but does for the rest.
164 */
165 if (*(unsigned short *)rawp == 0xFFFF)
166 return htons(ETH_P_802_3);
167
168 /**
169 * Real 802.2 LLC
170 */
171 return htons(ETH_P_802_2);
172 }
173
174 #define TS_SZ 188
175 #define TS_SYNC 0x47
176 #define TS_TEI 0x80
177 #define TS_PUSI 0x40
178 #define TS_AF_A 0x20
179 #define TS_AF_D 0x10
180
181 #define ULE_TEST 0
182 #define ULE_BRIDGED 1
183 #define ULE_LLC 2
184
185 static inline void reset_ule( struct dvb_net_priv *p )
186 {
187 p->ule_skb = NULL;
188 p->ule_sndu_len = 0;
189 p->ule_sndu_type = 0;
190 p->ule_sndu_type_1 = 0;
191 p->ule_sndu_remain = 0;
192 p->ule_dbit = 0xFF;
193 p->ule_ethhdr_complete = 0;
194 }
195
196 static const char eth_dest_addr[] = { 0x0b, 0x0a, 0x09, 0x08, 0x04, 0x03 };
197
198 static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
199 {
200 struct dvb_net_priv *priv = (struct dvb_net_priv *)dev->priv;
201 unsigned long skipped = 0L, skblen = 0L;
202 u8 *ts, *ts_end, *from_where = NULL, ts_remain = 0, how_much = 0, new_ts = 1;
203 struct ethhdr *ethh = NULL;
204 unsigned int emergency_count = 0;
205
206 if (dev == NULL) {
207 printk( KERN_ERR "NO netdev struct!\n" );
208 return;
209 }
210
211 for (ts = (char *)buf, ts_end = (char *)buf + buf_len; ts < ts_end; ) {
212
213 if (emergency_count++ > 200) {
214 /* Huh?? */
215 hexdump(ts, TS_SZ);
216 printk(KERN_WARNING "*** LOOP ALERT! ts %p ts_remain %u "
217 "how_much %u, ule_skb %p, ule_len %u, ule_remain %u\n",
218 ts, ts_remain, how_much, priv->ule_skb,
219 priv->ule_sndu_len, priv->ule_sndu_remain);
220 break;
221 }
222
223 if (new_ts) {
224 if ((ts[0] != TS_SYNC) || (ts[1] & TS_TEI)) {
225 printk(KERN_WARNING "Invalid TS cell: SYNC %#x, TEI %u.\n",
226 ts[0], ts[1] & TS_TEI >> 7);
227 continue;
228 }
229 ts_remain = 184;
230 from_where = ts + 4;
231 }
232 /* Synchronize on PUSI, if required. */
233 if (priv->need_pusi) {
234 if (ts[1] & TS_PUSI) {
235 /* Find beginning of first ULE SNDU in current TS cell.
236 * priv->need_pusi = 0; */
237 priv->tscc = ts[3] & 0x0F;
238 /* There is a pointer field here. */
239 if (ts[4] > ts_remain) {
240 printk(KERN_ERR "Invalid ULE packet "
241 "(pointer field %d)\n", ts[4]);
242 continue;
243 }
244 from_where = &ts[5] + ts[4];
245 ts_remain -= 1 + ts[4];
246 skipped = 0;
247 } else {
248 skipped++;
249 continue;
250 }
251 }
252
253 /* Check continuity counter. */
254 if (new_ts) {
255 if ((ts[3] & 0x0F) == priv->tscc)
256 priv->tscc = (priv->tscc + 1) & 0x0F;
257 else {
258 /* TS discontinuity handling: */
259 if (priv->ule_skb) {
260 dev_kfree_skb( priv->ule_skb );
261 /* Prepare for next SNDU. */
262 reset_ule(priv);
263 ((struct dvb_net_priv *) dev->priv)->stats.rx_errors++;
264 ((struct dvb_net_priv *) dev->priv)->stats.rx_frame_errors++;
265 }
266 /* skip to next PUSI. */
267 printk(KERN_WARNING "TS discontinuity: got %#x, "
268 "exptected %#x.\n", ts[3] & 0x0F, priv->tscc);
269 priv->need_pusi = 1;
270 continue;
271 }
272 /* If we still have an incomplete payload, but PUSI is
273 * set, some TS cells are missing.
274 * This is only possible here, if we missed exactly 16 TS
275 * cells (continuity counter). */
276 if (ts[1] & TS_PUSI) {
277 if (! priv->need_pusi) {
278 /* printk(KERN_WARNING "Skipping pointer field %u.\n", *from_where); */
279 if (*from_where > 181) {
280 printk(KERN_WARNING "*** Invalid pointer "
281 "field: %u. Current TS cell "
282 "follows:\n", *from_where);
283 hexdump( ts, TS_SZ );
284 printk(KERN_WARNING "-------------------\n");
285 }
286 /* Skip pointer field (we're processing a
287 * packed payload). */
288 from_where += 1;
289 ts_remain -= 1;
290 } else
291 priv->need_pusi = 0;
292
293 if (priv->ule_sndu_remain > 183) {
294 ((struct dvb_net_priv *) dev->priv)->stats.rx_errors++;
295 ((struct dvb_net_priv *) dev->priv)->stats.rx_length_errors++;
296 printk(KERN_WARNING "Expected %d more SNDU bytes, but "
297 "got PUSI. Flushing incomplete payload.\n",
298 priv->ule_sndu_remain);
299 dev_kfree_skb(priv->ule_skb);
300 /* Prepare for next SNDU. */
301 reset_ule(priv);
302 }
303 }
304 }
305
306 /* Check if new payload needs to be started. */
307 if (priv->ule_skb == NULL) {
308 /* Start a new payload w/ skb.
309 * Find ULE header. It is only guaranteed that the
310 * length field (2 bytes) is contained in the current
311 * TS.
312 * Check ts_remain has to be >= 2 here. */
313 if (ts_remain < 2) {
314 printk(KERN_WARNING "Invalid payload packing: only %d "
315 "bytes left in TS. Resyncing.\n", ts_remain);
316 priv->ule_sndu_len = 0;
317 priv->need_pusi = 1;
318 continue;
319 }
320
321 if (! priv->ule_sndu_len) {
322 priv->ule_sndu_len = from_where[0] << 8 | from_where[1];
323 if (priv->ule_sndu_len & 0x8000) {
324 /* D-Bit is set: no dest mac present. */
325 priv->ule_sndu_len &= 0x7FFF;
326 priv->ule_dbit = 1;
327 } else
328 priv->ule_dbit = 0;
329
330 /* printk(KERN_WARNING "ULE D-Bit: %d, SNDU len %u.\n",
331 priv->ule_dbit, priv->ule_sndu_len); */
332
333 if (priv->ule_sndu_len > 32763) {
334 printk(KERN_WARNING "Invalid ULE SNDU length %u. "
335 "Resyncing.\n", priv->ule_sndu_len);
336 hexdump(ts, TS_SZ);
337 priv->ule_sndu_len = 0;
338 priv->need_pusi = 1;
339 new_ts = 1;
340 ts += TS_SZ;
341 continue;
342 }
343 ts_remain -= 2; /* consume the 2 bytes SNDU length. */
344 from_where += 2;
345 }
346
347 /*
348 * State of current TS:
349 * ts_remain (remaining bytes in the current TS cell)
350 * 0 ule_type is not available now, we need the next TS cell
351 * 1 the first byte of the ule_type is present
352 * >=2 full ULE header present, maybe some payload data as well.
353 */
354 switch (ts_remain) {
355 case 1:
356 priv->ule_sndu_type = from_where[0] << 8;
357 priv->ule_sndu_type_1 = 1; /* first byte of ule_type is set. */
358 /* ts_remain -= 1; from_where += 1;
359 * here not necessary, because we continue. */
360 case 0:
361 new_ts = 1;
362 ts += TS_SZ;
363 continue;
364
365 default: /* complete ULE header is present in current TS. */
366 /* Extract ULE type field. */
367 if (priv->ule_sndu_type_1) {
368 priv->ule_sndu_type |= from_where[0];
369 from_where += 1; /* points to payload start. */
370 ts_remain -= 1;
371 } else {
372 /* Complete type is present in new TS. */
373 priv->ule_sndu_type = from_where[0] << 8 | from_where[1];
374 from_where += 2; /* points to payload start. */
375 ts_remain -= 2;
376 }
377 break;
378 }
379
380 if (priv->ule_sndu_type == ULE_TEST) {
381 /* Test SNDU, discarded by the receiver. */
382 printk(KERN_WARNING "Discarding ULE Test SNDU (%d bytes). "
383 "Resyncing.\n", priv->ule_sndu_len);
384 priv->ule_sndu_len = 0;
385 priv->need_pusi = 1;
386 continue;
387 }
388
389 skblen = priv->ule_sndu_len; /* Including CRC32 */
390 if (priv->ule_sndu_type != ULE_BRIDGED) {
391 skblen += ETH_HLEN;
392 #if 1
393 if (! priv->ule_dbit)
394 skblen -= ETH_ALEN;
395 #endif
396 }
397 priv->ule_skb = dev_alloc_skb(skblen);
398 if (priv->ule_skb == NULL) {
399 printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n",
400 dev->name);
401 ((struct dvb_net_priv *)dev->priv)->stats.rx_dropped++;
402 return;
403 }
404
405 #if 0
406 if (priv->ule_sndu_type != ULE_BRIDGED) {
407 // skb_reserve(priv->ule_skb, 2); /* longword align L3 header */
408 // Create Ethernet header.
409 ethh = (struct ethhdr *)skb_put( priv->ule_skb, ETH_HLEN );
410 memset( ethh->h_source, 0x00, ETH_ALEN );
411 if (priv->ule_dbit) {
412 // Dest MAC address not present --> generate our own.
413 memcpy( ethh->h_dest, eth_dest_addr, ETH_ALEN );
414 } else {
415 // Dest MAC address could be split across two TS cells.
416 // FIXME: implement.
417
418 printk( KERN_WARNING "%s: got destination MAC "
419 "address.\n", dev->name );
420 memcpy( ethh->h_dest, eth_dest_addr, ETH_ALEN );
421 }
422 ethh->h_proto = htons(priv->ule_sndu_type == ULE_LLC ?
423 priv->ule_sndu_len : priv->ule_sndu_type);
424 }
425 #endif
426 /* this includes the CRC32 _and_ dest mac, if !dbit! */
427 priv->ule_sndu_remain = priv->ule_sndu_len;
428 priv->ule_skb->dev = dev;
429 }
430
431 /* Copy data into our current skb. */
432 how_much = min(priv->ule_sndu_remain, (int)ts_remain);
433 if ((priv->ule_ethhdr_complete < ETH_ALEN) &&
434 (priv->ule_sndu_type != ULE_BRIDGED)) {
435 ethh = (struct ethhdr *)priv->ule_skb->data;
436 if (! priv->ule_dbit) {
437 if (how_much >= (ETH_ALEN - priv->ule_ethhdr_complete)) {
438 /* copy dest mac address. */
439 memcpy(skb_put(priv->ule_skb,
440 (ETH_ALEN - priv->ule_ethhdr_complete)),
441 from_where,
442 (ETH_ALEN - priv->ule_ethhdr_complete));
443 memset(ethh->h_source, 0x00, ETH_ALEN);
444 ethh->h_proto = htons(priv->ule_sndu_type == ULE_LLC ?
445 priv->ule_sndu_len :
446 priv->ule_sndu_type);
447 skb_put(priv->ule_skb, ETH_ALEN + 2);
448
449 how_much -= (ETH_ALEN - priv->ule_ethhdr_complete);
450 priv->ule_sndu_remain -= (ETH_ALEN -
451 priv->ule_ethhdr_complete);
452 ts_remain -= (ETH_ALEN - priv->ule_ethhdr_complete);
453 from_where += (ETH_ALEN - priv->ule_ethhdr_complete);
454 priv->ule_ethhdr_complete = ETH_ALEN;
455 }
456 } else {
457 /* Generate whole Ethernet header. */
458 memcpy(ethh->h_dest, eth_dest_addr, ETH_ALEN);
459 memset(ethh->h_source, 0x00, ETH_ALEN);
460 ethh->h_proto = htons(priv->ule_sndu_type == ULE_LLC ?
461 priv->ule_sndu_len : priv->ule_sndu_type);
462 skb_put(priv->ule_skb, ETH_HLEN);
463 priv->ule_ethhdr_complete = ETH_ALEN;
464 }
465 }
466 /* printk(KERN_WARNING "Copying %u bytes, ule_sndu_remain = %u, "
467 "ule_sndu_len = %u.\n", how_much, priv->ule_sndu_remain,
468 priv->ule_sndu_len); */
469 memcpy(skb_put(priv->ule_skb, how_much), from_where, how_much);
470 priv->ule_sndu_remain -= how_much;
471 ts_remain -= how_much;
472 from_where += how_much;
473
474 if ((priv->ule_ethhdr_complete < ETH_ALEN) &&
475 (priv->ule_sndu_type != ULE_BRIDGED)) {
476 priv->ule_ethhdr_complete += how_much;
477 }
478
479 /* Check for complete payload. */
480 if (priv->ule_sndu_remain <= 0) {
481 /* Check CRC32, we've got it in our skb already. */
482 unsigned short ulen = htons(priv->ule_sndu_len);
483 unsigned short utype = htons(priv->ule_sndu_type);
484 struct kvec iov[4] = {
485 { &ulen, sizeof ulen },
486 { &utype, sizeof utype },
487 { NULL, 0 },
488 { priv->ule_skb->data + ETH_HLEN,
489 priv->ule_skb->len - ETH_HLEN - 4 }
490 };
491 unsigned long ule_crc = ~0L, expected_crc;
492 if (priv->ule_dbit) {
493 /* Set D-bit for CRC32 verification,
494 * if it was set originally. */
495 ulen |= 0x0080;
496 } else {
497 iov[2].iov_base = priv->ule_skb->data;
498 iov[2].iov_len = ETH_ALEN;
499 }
500 ule_crc = iov_crc32(ule_crc, iov, 4);
501 expected_crc = *((u8 *)priv->ule_skb->tail - 4) << 24 |
502 *((u8 *)priv->ule_skb->tail - 3) << 16 |
503 *((u8 *)priv->ule_skb->tail - 2) << 8 |
504 *((u8 *)priv->ule_skb->tail - 1);
505 if (ule_crc != expected_crc) {
506 printk(KERN_WARNING "CRC32 check %s: %#lx / %#lx.\n",
507 ule_crc != expected_crc ? "FAILED" : "OK",
508 ule_crc, expected_crc);
509 hexdump(priv->ule_skb->data + ETH_HLEN,
510 priv->ule_skb->len - ETH_HLEN);
511
512 ((struct dvb_net_priv *) dev->priv)->stats.rx_errors++;
513 ((struct dvb_net_priv *) dev->priv)->stats.rx_crc_errors++;
514 dev_kfree_skb(priv->ule_skb);
515 } else {
516 /* CRC32 was OK. Remove it from skb. */
517 priv->ule_skb->tail -= 4;
518 priv->ule_skb->len -= 4;
519 /* Stuff into kernel's protocol stack. */
520 priv->ule_skb->protocol = dvb_net_eth_type_trans(priv->ule_skb, dev);
521 /* If D-bit is set (i.e. destination MAC address not present),
522 * receive the packet anyhw. */
523 /* if (priv->ule_dbit && skb->pkt_type == PACKET_OTHERHOST) */
524 priv->ule_skb->pkt_type = PACKET_HOST;
525 ((struct dvb_net_priv *) dev->priv)->stats.rx_packets++;
526 ((struct dvb_net_priv *) dev->priv)->stats.rx_bytes += priv->ule_skb->len;
527 netif_rx(priv->ule_skb);
528 }
529 /* Prepare for next SNDU. */
530 reset_ule(priv);
531 }
532
533 /* More data in current TS (look at the bytes following the CRC32)? */
534 if (ts_remain >= 2 && *((unsigned short *)from_where) != 0xFFFF) {
535 /* Next ULE SNDU starts right there. */
536 new_ts = 0;
537 priv->ule_skb = NULL;
538 priv->ule_sndu_type_1 = 0;
539 priv->ule_sndu_len = 0;
540 // printk(KERN_WARNING "More data in current TS: [%#x %#x %#x %#x]\n",
541 // *(from_where + 0), *(from_where + 1),
542 // *(from_where + 2), *(from_where + 3));
543 // printk(KERN_WARNING "ts @ %p, stopped @ %p:\n", ts, from_where + 0);
544 // hexdump(ts, 188);
545 } else {
546 new_ts = 1;
547 ts += TS_SZ;
548 if (priv->ule_skb == NULL) {
549 priv->need_pusi = 1;
550 priv->ule_sndu_type_1 = 0;
551 priv->ule_sndu_len = 0;
552 }
553 }
554 } /* for all available TS cells */
555 }
556
557 static int dvb_net_ts_callback(const u8 *buffer1, size_t buffer1_len,
558 const u8 *buffer2, size_t buffer2_len,
559 struct dmx_ts_feed *feed, enum dmx_success success)
560 {
561 struct net_device *dev = (struct net_device *)feed->priv;
562
563 if (buffer2 != 0)
564 printk(KERN_WARNING "buffer2 not 0: %p.\n", buffer2);
565 if (buffer1_len > 32768)
566 printk(KERN_WARNING "length > 32k: %zu.\n", buffer1_len);
567 /* printk("TS callback: %u bytes, %u TS cells @ %p.\n",
568 buffer1_len, buffer1_len / TS_SZ, buffer1); */
569 dvb_net_ule(dev, buffer1, buffer1_len);
570 return 0;
571 }
572
573
574 static void dvb_net_sec(struct net_device *dev, u8 *pkt, int pkt_len)
575 {
576 u8 *eth;
577 struct sk_buff *skb;
578 struct net_device_stats *stats = &(((struct dvb_net_priv *) dev->priv)->stats);
579
580 /* note: pkt_len includes a 32bit checksum */
581 if (pkt_len < 16) {
582 printk("%s: IP/MPE packet length = %d too small.\n",
583 dev->name, pkt_len);
584 stats->rx_errors++;
585 stats->rx_length_errors++;
586 return;
587 }
588 /* it seems some ISPs manage to screw up here, so we have to
589 * relax the error checks... */
590 #if 0
591 if ((pkt[5] & 0xfd) != 0xc1) {
592 /* drop scrambled or broken packets */
593 #else
594 if ((pkt[5] & 0x3c) != 0x00) {
595 /* drop scrambled */
596 #endif
597 stats->rx_errors++;
598 stats->rx_crc_errors++;
599 return;
600 }
601 if (pkt[5] & 0x02) {
602 //FIXME: handle LLC/SNAP
603 stats->rx_dropped++;
604 return;
605 }
606 if (pkt[7]) {
607 /* FIXME: assemble datagram from multiple sections */
608 stats->rx_errors++;
609 stats->rx_frame_errors++;
610 return;
611 }
612
613 /* we have 14 byte ethernet header (ip header follows);
614 * 12 byte MPE header; 4 byte checksum; + 2 byte alignment
615 */
616 if (!(skb = dev_alloc_skb(pkt_len - 4 - 12 + 14 + 2))) {
617 //printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
618 stats->rx_dropped++;
619 return;
620 }
621 skb_reserve(skb, 2); /* longword align L3 header */
622 skb->dev = dev;
623
624 /* copy L3 payload */
625 eth = (u8 *) skb_put(skb, pkt_len - 12 - 4 + 14);
626 memcpy(eth + 14, pkt + 12, pkt_len - 12 - 4);
627
628 /* create ethernet header: */
629 eth[0]=pkt[0x0b];
630 eth[1]=pkt[0x0a];
631 eth[2]=pkt[0x09];
632 eth[3]=pkt[0x08];
633 eth[4]=pkt[0x04];
634 eth[5]=pkt[0x03];
635
636 eth[6]=eth[7]=eth[8]=eth[9]=eth[10]=eth[11]=0;
637
638 eth[12] = 0x08; /* ETH_P_IP */
639 eth[13] = 0x00;
640
641 skb->protocol = dvb_net_eth_type_trans(skb, dev);
642
643 stats->rx_packets++;
644 stats->rx_bytes+=skb->len;
645 netif_rx(skb);
646 }
647
648 static int dvb_net_sec_callback(const u8 *buffer1, size_t buffer1_len,
649 const u8 *buffer2, size_t buffer2_len,
650 struct dmx_section_filter *filter,
651 enum dmx_success success)
652 {
653 struct net_device *dev=(struct net_device *) filter->priv;
654
655 /**
656 * we rely on the DVB API definition where exactly one complete
657 * section is delivered in buffer1
658 */
659 dvb_net_sec (dev, (u8*) buffer1, buffer1_len);
660 return 0;
661 }
662
663 static int dvb_net_tx(struct sk_buff *skb, struct net_device *dev)
664 {
665 return 0;
666 }
667
668 static u8 mask_normal[6]={0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
669 static u8 mask_allmulti[6]={0xff, 0xff, 0xff, 0x00, 0x00, 0x00};
670 static u8 mac_allmulti[6]={0x01, 0x00, 0x5e, 0x00, 0x00, 0x00};
671 static u8 mask_promisc[6]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
672
673 static int dvb_net_filter_sec_set(struct net_device *dev,
674 struct dmx_section_filter **secfilter,
675 u8 *mac, u8 *mac_mask)
676 {
677 struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
678 int ret;
679
680 *secfilter=NULL;
681 ret = priv->secfeed->allocate_filter(priv->secfeed, secfilter);
682 if (ret<0) {
683 printk("%s: could not get filter\n", dev->name);
684 return ret;
685 }
686
687 (*secfilter)->priv=(void *) dev;
688
689 memset((*secfilter)->filter_value, 0x00, DMX_MAX_FILTER_SIZE);
690 memset((*secfilter)->filter_mask, 0x00, DMX_MAX_FILTER_SIZE);
691 memset((*secfilter)->filter_mode, 0xff, DMX_MAX_FILTER_SIZE);
692
693 (*secfilter)->filter_value[0]=0x3e;
694 (*secfilter)->filter_value[3]=mac[5];
695 (*secfilter)->filter_value[4]=mac[4];
696 (*secfilter)->filter_value[8]=mac[3];
697 (*secfilter)->filter_value[9]=mac[2];
698 (*secfilter)->filter_value[10]=mac[1];
699 (*secfilter)->filter_value[11]=mac[0];
700
701 (*secfilter)->filter_mask[0] = 0xff;
702 (*secfilter)->filter_mask[3] = mac_mask[5];
703 (*secfilter)->filter_mask[4] = mac_mask[4];
704 (*secfilter)->filter_mask[8] = mac_mask[3];
705 (*secfilter)->filter_mask[9] = mac_mask[2];
706 (*secfilter)->filter_mask[10] = mac_mask[1];
707 (*secfilter)->filter_mask[11]=mac_mask[0];
708
709 dprintk("%s: filter mac=%02x %02x %02x %02x %02x %02x\n",
710 dev->name, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
711 dprintk("%s: filter mask=%02x %02x %02x %02x %02x %02x\n",
712 dev->name, mac_mask[0], mac_mask[1], mac_mask[2],
713 mac_mask[3], mac_mask[4], mac_mask[5]);
714
715 return 0;
716 }
717
718 static int dvb_net_feed_start(struct net_device *dev)
719 {
720 int ret, i;
721 struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
722 struct dmx_demux *demux = priv->demux;
723 unsigned char *mac = (unsigned char *) dev->dev_addr;
724
725 dprintk("%s: rx_mode %i\n", __FUNCTION__, priv->rx_mode);
726 if (priv->secfeed || priv->secfilter || priv->multi_secfilter[0])
727 printk("%s: BUG %d\n", __FUNCTION__, __LINE__);
728
729 priv->secfeed=NULL;
730 priv->secfilter=NULL;
731 priv->tsfeed = NULL;
732
733 if (priv->feedtype == DVB_NET_FEEDTYPE_MPE) {
734 dprintk("%s: alloc secfeed\n", __FUNCTION__);
735 ret=demux->allocate_section_feed(demux, &priv->secfeed,
736 dvb_net_sec_callback);
737 if (ret<0) {
738 printk("%s: could not allocate section feed\n", dev->name);
739 return ret;
740 }
741
742 ret = priv->secfeed->set(priv->secfeed, priv->pid, 32768, 0, 1);
743
744 if (ret<0) {
745 printk("%s: could not set section feed\n", dev->name);
746 priv->demux->release_section_feed(priv->demux, priv->secfeed);
747 priv->secfeed=NULL;
748 return ret;
749 }
750
751 if (priv->rx_mode != RX_MODE_PROMISC) {
752 dprintk("%s: set secfilter\n", __FUNCTION__);
753 dvb_net_filter_sec_set(dev, &priv->secfilter, mac, mask_normal);
754 }
755
756 switch (priv->rx_mode) {
757 case RX_MODE_MULTI:
758 for (i = 0; i < priv->multi_num; i++) {
759 dprintk("%s: set multi_secfilter[%d]\n", __FUNCTION__, i);
760 dvb_net_filter_sec_set(dev, &priv->multi_secfilter[i],
761 priv->multi_macs[i], mask_normal);
762 }
763 break;
764 case RX_MODE_ALL_MULTI:
765 priv->multi_num=1;
766 dprintk("%s: set multi_secfilter[0]\n", __FUNCTION__);
767 dvb_net_filter_sec_set(dev, &priv->multi_secfilter[0],
768 mac_allmulti, mask_allmulti);
769 break;
770 case RX_MODE_PROMISC:
771 priv->multi_num=0;
772 dprintk("%s: set secfilter\n", __FUNCTION__);
773 dvb_net_filter_sec_set(dev, &priv->secfilter, mac, mask_promisc);
774 break;
775 }
776
777 dprintk("%s: start filtering\n", __FUNCTION__);
778 priv->secfeed->start_filtering(priv->secfeed);
779 } else if (priv->feedtype == DVB_NET_FEEDTYPE_ULE) {
780 struct timespec timeout = { 0, 30000000 }; // 30 msec
781
782 /* we have payloads encapsulated in TS */
783 dprintk("%s: alloc tsfeed\n", __FUNCTION__);
784 ret = demux->allocate_ts_feed(demux, &priv->tsfeed, dvb_net_ts_callback);
785 if (ret < 0) {
786 printk("%s: could not allocate ts feed\n", dev->name);
787 return ret;
788 }
789
790 /* Set netdevice pointer for ts decaps callback. */
791 priv->tsfeed->priv = (void *)dev;
792 ret = priv->tsfeed->set(priv->tsfeed, priv->pid,
793 TS_PACKET, DMX_TS_PES_OTHER,
794 188 * 100, /* nr. of bytes delivered per callback */
795 32768, /* circular buffer size */
796 0, /* descramble */
797 timeout);
798
799 if (ret < 0) {
800 printk("%s: could not set ts feed\n", dev->name);
801 priv->demux->release_ts_feed(priv->demux, priv->tsfeed);
802 priv->tsfeed = NULL;
803 return ret;
804 }
805
806 dprintk("%s: start filtering\n", __FUNCTION__);
807 priv->tsfeed->start_filtering(priv->tsfeed);
808 } else
809 return -EINVAL;
810
811 return 0;
812 }
813
814 static int dvb_net_feed_stop(struct net_device *dev)
815 {
816 struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
817 int i;
818
819 dprintk("%s\n", __FUNCTION__);
820 if (priv->feedtype == DVB_NET_FEEDTYPE_MPE) {
821 if (priv->secfeed) {
822 if (priv->secfeed->is_filtering) {
823 dprintk("%s: stop secfeed\n", __FUNCTION__);
824 priv->secfeed->stop_filtering(priv->secfeed);
825 }
826
827 if (priv->secfilter) {
828 dprintk("%s: release secfilter\n", __FUNCTION__);
829 priv->secfeed->release_filter(priv->secfeed,
830 priv->secfilter);
831 priv->secfilter=NULL;
832 }
833
834 for (i=0; i<priv->multi_num; i++) {
835 if (priv->multi_secfilter[i]) {
836 dprintk("%s: release multi_filter[%d]\n",
837 __FUNCTION__, i);
838 priv->secfeed->release_filter(priv->secfeed,
839 priv->multi_secfilter[i]);
840 priv->multi_secfilter[i]=NULL;
841 }
842 }
843
844 priv->demux->release_section_feed(priv->demux, priv->secfeed);
845 priv->secfeed=NULL;
846 } else
847 printk("%s: no feed to stop\n", dev->name);
848 } else if (priv->feedtype == DVB_NET_FEEDTYPE_ULE) {
849 if (priv->tsfeed) {
850 if (priv->tsfeed->is_filtering) {
851 dprintk("%s: stop tsfeed\n", __FUNCTION__);
852 priv->tsfeed->stop_filtering(priv->tsfeed);
853 }
854 priv->demux->release_ts_feed(priv->demux, priv->tsfeed);
855 priv->tsfeed = NULL;
856 }
857 else
858 printk("%s: no ts feed to stop\n", dev->name);
859 } else
860 return -EINVAL;
861 return 0;
862 }
863
864
865 static int dvb_set_mc_filter (struct net_device *dev, struct dev_mc_list *mc)
866 {
867 struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
868
869 if (priv->multi_num == DVB_NET_MULTICAST_MAX)
870 return -ENOMEM;
871
872 memcpy(priv->multi_macs[priv->multi_num], mc->dmi_addr, 6);
873
874 priv->multi_num++;
875 return 0;
876 }
877
878
879 static void wq_set_multicast_list (void *data)
880 {
881 struct net_device *dev = data;
882 struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
883
884 dvb_net_feed_stop(dev);
885
886 priv->rx_mode = RX_MODE_UNI;
887
888 if(dev->flags & IFF_PROMISC) {
889 dprintk("%s: promiscuous mode\n", dev->name);
890 priv->rx_mode = RX_MODE_PROMISC;
891 } else if ((dev->flags & IFF_ALLMULTI)) {
892 dprintk("%s: allmulti mode\n", dev->name);
893 priv->rx_mode = RX_MODE_ALL_MULTI;
894 } else if (dev->mc_count) {
895 int mci;
896 struct dev_mc_list *mc;
897
898 dprintk("%s: set_mc_list, %d entries\n",
899 dev->name, dev->mc_count);
900
901 priv->rx_mode = RX_MODE_MULTI;
902 priv->multi_num = 0;
903
904 for (mci = 0, mc=dev->mc_list;
905 mci < dev->mc_count;
906 mc = mc->next, mci++) {
907 dvb_set_mc_filter(dev, mc);
908 }
909 }
910
911 dvb_net_feed_start(dev);
912 }
913
914
915 static void dvb_net_set_multicast_list (struct net_device *dev)
916 {
917 struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
918 schedule_work(&priv->set_multicast_list_wq);
919 }
920
921
922 static int dvb_net_set_config(struct net_device *dev, struct ifmap *map)
923 {
924 if (netif_running(dev))
925 return -EBUSY;
926 return 0;
927 }
928
929
930 static void wq_restart_net_feed (void *data)
931 {
932 struct net_device *dev = data;
933
934 if (netif_running(dev)) {
935 dvb_net_feed_stop(dev);
936 dvb_net_feed_start(dev);
937 }
938 }
939
940
941 static int dvb_net_set_mac (struct net_device *dev, void *p)
942 {
943 struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
944 struct sockaddr *addr=p;
945
946 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
947
948 if (netif_running(dev))
949 schedule_work(&priv->restart_net_feed_wq);
950
951 return 0;
952 }
953
954
955 static int dvb_net_open(struct net_device *dev)
956 {
957 struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
958
959 priv->in_use++;
960 dvb_net_feed_start(dev);
961 return 0;
962 }
963
964
965 static int dvb_net_stop(struct net_device *dev)
966 {
967 struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
968
969 priv->in_use--;
970 return dvb_net_feed_stop(dev);
971 }
972
973 static struct net_device_stats * dvb_net_get_stats(struct net_device *dev)
974 {
975 return &((struct dvb_net_priv*) dev->priv)->stats;
976 }
977
978
979 static void dvb_net_setup(struct net_device *dev)
980 {
981 ether_setup(dev);
982
983 dev->open = dvb_net_open;
984 dev->stop = dvb_net_stop;
985 dev->hard_start_xmit = dvb_net_tx;
986 dev->get_stats = dvb_net_get_stats;
987 dev->set_multicast_list = dvb_net_set_multicast_list;
988 dev->set_config = dvb_net_set_config;
989 dev->set_mac_address = dvb_net_set_mac;
990 dev->mtu = 4096;
991 dev->mc_count = 0;
992 dev->hard_header_cache = NULL;
993
994 dev->flags |= IFF_NOARP;
995 }
996
997 static int get_if(struct dvb_net *dvbnet)
998 {
999 int i;
1000
1001 for (i=0; i<DVB_NET_DEVICES_MAX; i++)
1002 if (!dvbnet->state[i])
1003 break;
1004
1005 if (i == DVB_NET_DEVICES_MAX)
1006 return -1;
1007
1008 dvbnet->state[i]=1;
1009 return i;
1010 }
1011
1012 static int dvb_net_add_if(struct dvb_net *dvbnet, u16 pid, u8 feedtype)
1013 {
1014 struct net_device *net;
1015 struct dvb_net_priv *priv;
1016 int result;
1017 int if_num;
1018
1019 if (feedtype != DVB_NET_FEEDTYPE_MPE && feedtype != DVB_NET_FEEDTYPE_ULE)
1020 return -EINVAL;
1021 if ((if_num = get_if(dvbnet)) < 0)
1022 return -EINVAL;
1023
1024 net = alloc_netdev(sizeof(struct dvb_net_priv), "dvb",
1025 dvb_net_setup);
1026 if (!net)
1027 return -ENOMEM;
1028
1029 sprintf(net->name, "dvb%d_%d", dvbnet->dvbdev->adapter->num, if_num);
1030
1031 net->addr_len = 6;
1032 memcpy(net->dev_addr, dvbnet->dvbdev->adapter->proposed_mac, 6);
1033
1034 dvbnet->device[if_num] = net;
1035
1036 priv = net->priv;
1037 priv->demux = dvbnet->demux;
1038 priv->pid = pid;
1039 priv->rx_mode = RX_MODE_UNI;
1040 priv->need_pusi = 1;
1041 priv->tscc = 0;
1042 priv->feedtype = feedtype;
1043 reset_ule(priv);
1044
1045 INIT_WORK(&priv->set_multicast_list_wq, wq_set_multicast_list, net);
1046 INIT_WORK(&priv->restart_net_feed_wq, wq_restart_net_feed, net);
1047
1048 net->base_addr = pid;
1049
1050 if ((result = register_netdev(net)) < 0) {
1051 dvbnet->device[if_num] = NULL;
1052 free_netdev(net);
1053 return result;
1054 }
1055
1056 return if_num;
1057 }
1058
1059
1060 static int dvb_net_remove_if(struct dvb_net *dvbnet, int num)
1061 {
1062 struct net_device *net = dvbnet->device[num];
1063 struct dvb_net_priv *priv = net->priv;
1064
1065 if (!dvbnet->state[num])
1066 return -EINVAL;
1067 if (priv->in_use)
1068 return -EBUSY;
1069
1070 dvb_net_stop(net);
1071 flush_scheduled_work();
1072 unregister_netdev(net);
1073 dvbnet->state[num]=0;
1074 dvbnet->device[num] = NULL;
1075 free_netdev(net);
1076
1077 return 0;
1078 }
1079
1080
1081 static int dvb_net_do_ioctl(struct inode *inode, struct file *file,
1082 unsigned int cmd, void *parg)
1083 {
1084 struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
1085 struct dvb_net *dvbnet = (struct dvb_net *) dvbdev->priv;
1086
1087 if (((file->f_flags&O_ACCMODE)==O_RDONLY))
1088 return -EPERM;
1089
1090 switch (cmd) {
1091 case NET_ADD_IF:
1092 {
1093 struct dvb_net_if *dvbnetif=(struct dvb_net_if *)parg;
1094 int result;
1095
1096 if (!capable(CAP_SYS_ADMIN))
1097 return -EPERM;
1098
1099 if (!try_module_get(dvbdev->adapter->module))
1100 return -EPERM;
1101
1102 result=dvb_net_add_if(dvbnet, dvbnetif->pid, dvbnetif->feedtype);
1103 if (result<0) {
1104 module_put(dvbdev->adapter->module);
1105 return result;
1106 }
1107 dvbnetif->if_num=result;
1108 break;
1109 }
1110 case NET_GET_IF:
1111 {
1112 struct net_device *netdev;
1113 struct dvb_net_priv *priv_data;
1114 struct dvb_net_if *dvbnetif=(struct dvb_net_if *)parg;
1115
1116 if (dvbnetif->if_num >= DVB_NET_DEVICES_MAX ||
1117 !dvbnet->state[dvbnetif->if_num])
1118 return -EINVAL;
1119
1120 netdev = dvbnet->device[dvbnetif->if_num];
1121 priv_data=(struct dvb_net_priv*)netdev->priv;
1122 dvbnetif->pid=priv_data->pid;
1123 dvbnetif->feedtype=priv_data->feedtype;
1124 break;
1125 }
1126 case NET_REMOVE_IF:
1127 if (!capable(CAP_SYS_ADMIN))
1128 return -EPERM;
1129 module_put(dvbdev->adapter->module);
1130 return dvb_net_remove_if(dvbnet, (int) (long) parg);
1131
1132 /* binary compatiblity cruft */
1133 case __NET_ADD_IF_OLD:
1134 {
1135 struct __dvb_net_if_old *dvbnetif=(struct __dvb_net_if_old *)parg;
1136 int result;
1137
1138 if (!capable(CAP_SYS_ADMIN))
1139 return -EPERM;
1140
1141 if (!try_module_get(dvbdev->adapter->module))
1142 return -EPERM;
1143
1144 result=dvb_net_add_if(dvbnet, dvbnetif->pid, DVB_NET_FEEDTYPE_MPE);
1145 if (result<0) {
1146 module_put(dvbdev->adapter->module);
1147 return result;
1148 }
1149 dvbnetif->if_num=result;
1150 break;
1151 }
1152 case __NET_GET_IF_OLD:
1153 {
1154 struct net_device *netdev;
1155 struct dvb_net_priv *priv_data;
1156 struct __dvb_net_if_old *dvbnetif=(struct __dvb_net_if_old *)parg;
1157
1158 if (dvbnetif->if_num >= DVB_NET_DEVICES_MAX ||
1159 !dvbnet->state[dvbnetif->if_num])
1160 return -EINVAL;
1161
1162 netdev = dvbnet->device[dvbnetif->if_num];
1163 priv_data=(struct dvb_net_priv*)netdev->priv;
1164 dvbnetif->pid=priv_data->pid;
1165 break;
1166 }
1167 default:
1168 return -ENOTTY;
1169 }
1170 return 0;
1171 }
1172
1173 static int dvb_net_ioctl(struct inode *inode, struct file *file,
1174 unsigned int cmd, unsigned long arg)
1175 {
1176 return dvb_usercopy(inode, file, cmd, arg, dvb_net_do_ioctl);
1177 }
1178
1179 static struct file_operations dvb_net_fops = {
1180 .owner = THIS_MODULE,
1181 .ioctl = dvb_net_ioctl,
1182 .open = dvb_generic_open,
1183 .release = dvb_generic_release,
1184 };
1185
1186 static struct dvb_device dvbdev_net = {
1187 .priv = NULL,
1188 .users = 1,
1189 .writers = 1,
1190 .fops = &dvb_net_fops,
1191 };
1192
1193
1194 void dvb_net_release (struct dvb_net *dvbnet)
1195 {
1196 int i;
1197
1198 dvb_unregister_device(dvbnet->dvbdev);
1199
1200 for (i=0; i<DVB_NET_DEVICES_MAX; i++) {
1201 if (!dvbnet->state[i])
1202 continue;
1203 dvb_net_remove_if(dvbnet, i);
1204 }
1205 }
1206
1207
1208 int dvb_net_init (struct dvb_adapter *adap, struct dvb_net *dvbnet,
1209 struct dmx_demux *dmx)
1210 {
1211 int i;
1212
1213 dvbnet->demux = dmx;
1214
1215 for (i=0; i<DVB_NET_DEVICES_MAX; i++)
1216 dvbnet->state[i] = 0;
1217
1218 dvb_register_device (adap, &dvbnet->dvbdev, &dvbdev_net,
1219 dvbnet, DVB_DEVICE_NET);
1220
1221 return 0;
1222 }
1223
MOXA 2.6.9 from sdlinux-moxaart.tgz