drivers/media/dvb/dvb-core/dvb_net.c

   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