drivers/staging/otus/wrap_pkt.c

   1 /*
   2  * Copyright (c) 2007-2008 Atheros Communications Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 /*                                                                      */
  17 /*  Module Name : wrap_pkt.c                                            */
  18 /*                                                                      */
  19 /*  Abstract                                                            */
  20 /*     This module contains wrapper functions for packet handling       */
  21 /*                                                                      */
  22 /*  NOTES                                                               */
  23 /*     Platform dependent.                                              */
  24 /*                                                                      */
  25 /************************************************************************/
  26
  27 #include "oal_dt.h"
  28 #include "usbdrv.h"
  29
  30 #include <linux/netlink.h>
  31 #include <net/iw_handler.h>
  32
  33
  34 /* extern struct zsWdsStruct wds[ZM_WDS_PORT_NUMBER];   */
  35 extern struct zsVapStruct vap[ZM_VAP_PORT_NUMBER];
  36
  37
  38 /***** Rx *****/
  39 void zfLnxRecv80211(zdev_t *dev, zbuf_t *buf, struct zsAdditionInfo *addInfo)
  40 {
  41         u16_t frameType;
  42         u16_t frameCtrl;
  43         u16_t frameSubtype;
  44         zbuf_t *skb1;
  45         struct usbdrv_private *macp = dev->ml_priv;
  46
  47         /* frameCtrl = zmw_buf_readb(dev, buf, 0);      */
  48         frameCtrl = *(u8_t *)((u8_t *)buf->data);
  49         frameType = frameCtrl & 0xf;
  50         frameSubtype = frameCtrl & 0xf0;
  51
  52         if ((frameType == 0x0) && (macp->forwardMgmt)) {
  53                 switch (frameSubtype) {
  54                         /* Beacon */
  55                 case 0x80:
  56                         /* Probe response */
  57                 case 0x50:
  58                         skb1 = skb_copy(buf, GFP_ATOMIC);
  59                         if (skb1 != NULL) {
  60                                 skb1->dev = dev;
  61                                 skb1->mac_header = skb1->data;
  62                                 skb1->ip_summed = CHECKSUM_NONE;
  63                                 skb1->pkt_type = PACKET_OTHERHOST;
  64                                 /* ETH_P_80211_RAW */
  65                                 skb1->protocol = __constant_htons(0x0019);
  66                                 netif_rx(skb1);
  67                         }
  68                         break;
  69                 default:
  70                         break;
  71                 }
  72         }
  73
  74         zfiRecv80211(dev, buf, addInfo);
  75         return;
  76 }
  77
  78 #define ZM_AVOID_UDP_LARGE_PACKET_FAIL
  79 void zfLnxRecvEth(zdev_t *dev, zbuf_t *buf, u16_t port)
  80 {
  81         struct usbdrv_private *macp = dev->ml_priv;
  82 #ifdef ZM_AVOID_UDP_LARGE_PACKET_FAIL
  83         zbuf_t *new_buf;
  84
  85         /* new_buf = dev_alloc_skb(2048);       */
  86         new_buf = dev_alloc_skb(buf->len);
  87
  88 #ifdef NET_SKBUFF_DATA_USES_OFFSET
  89         new_buf->tail = 0;
  90         new_buf->len = 0;
  91 #else
  92         new_buf->tail = new_buf->data;
  93         new_buf->len = 0;
  94 #endif
  95
  96         skb_put(new_buf, buf->len);
  97         memcpy(new_buf->data, buf->data, buf->len);
  98
  99         /* Free buffer */
 100         dev_kfree_skb_any(buf);
 101
 102         if (port == 0) {
 103                 new_buf->dev = dev;
 104                 new_buf->protocol = eth_type_trans(new_buf, dev);
 105         } else {
 106                 /* VAP */
 107                 if (vap[0].dev != NULL) {
 108                         new_buf->dev = vap[0].dev;
 109                         new_buf->protocol = eth_type_trans(new_buf, vap[0].dev);
 110                 } else {
 111                         new_buf->dev = dev;
 112                         new_buf->protocol = eth_type_trans(new_buf, dev);
 113                 }
 114         }
 115
 116         new_buf->ip_summed = CHECKSUM_NONE;
 117         dev->last_rx = jiffies;
 118
 119         switch (netif_rx(new_buf))
 120 #else
 121         if (port == 0) {
 122                 buf->dev = dev;
 123                 buf->protocol = eth_type_trans(buf, dev);
 124         } else {
 125                 /* VAP */
 126                 if (vap[0].dev != NULL) {
 127                         buf->dev = vap[0].dev;
 128                         buf->protocol = eth_type_trans(buf, vap[0].dev);
 129                 } else {
 130                         buf->dev = dev;
 131                         buf->protocol = eth_type_trans(buf, dev);
 132                 }
 133         }
 134
 135         buf->ip_summed = CHECKSUM_NONE;
 136         dev->last_rx = jiffies;
 137
 138         switch (netif_rx(buf))
 139 #endif
 140         {
 141         case NET_RX_DROP:
 142                 break;
 143         default:
 144                         macp->drv_stats.net_stats.rx_packets++;
 145                         macp->drv_stats.net_stats.rx_bytes += buf->len;
 146                 break;
 147         }
 148
 149         return;
 150 }
 151
 152 /* Leave an empty line below to remove warning message on some compiler */