Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5adef66a authored by Larry Finger's avatar Larry Finger Committed by Greg Kroah-Hartman
Browse files

staging: r8188eu: Add files for new driver - part 19 



This commit adds files os_dep/os_intfs.c, os_dep/recv_linux.c,
and os_dep/rtw_android.c.

Signed-off-by: default avatarLarry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent d3f4b828

drivers/staging/rtl8188eu/os_dep/os_intfs.c

0 → 100644
+1251 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/staging/rtl8188eu/os_dep/recv_linux.c

0 → 100644
+261 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of version 2 of the GNU General Public License as

 * published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

 *

 *

 ******************************************************************************/

#define _RECV_OSDEP_C_



#include <osdep_service.h>

#include <drv_types.h>



#include <wifi.h>

#include <recv_osdep.h>



#include <osdep_intf.h>

#include <ethernet.h>

#include <usb_ops.h>



/* init os related resource in struct recv_priv */

int rtw_os_recv_resource_init(struct recv_priv *precvpriv,

			      struct adapter *padapter)

{

	return _SUCCESS;

}



/* alloc os related resource in union recv_frame */

int rtw_os_recv_resource_alloc(struct adapter *padapter,

			       union recv_frame *precvframe)

{

	precvframe->u.hdr.pkt_newalloc = NULL;

	precvframe->u.hdr.pkt = NULL;

	return _SUCCESS;

}



/* free os related resource in union recv_frame */

void rtw_os_recv_resource_free(struct recv_priv *precvpriv)

{

}



/* alloc os related resource in struct recv_buf */

int rtw_os_recvbuf_resource_alloc(struct adapter *padapter,

				  struct recv_buf *precvbuf)

{

	int res = _SUCCESS;



	precvbuf->irp_pending = false;

	precvbuf->purb = usb_alloc_urb(0, GFP_KERNEL);

	if (precvbuf->purb == NULL)

		res = _FAIL;

	precvbuf->pskb = NULL;

	precvbuf->reuse = false;

	precvbuf->pallocated_buf = NULL;

	precvbuf->pbuf = NULL;

	precvbuf->pdata = NULL;

	precvbuf->phead = NULL;

	precvbuf->ptail = NULL;

	precvbuf->pend = NULL;

	precvbuf->transfer_len = 0;

	precvbuf->len = 0;

	return res;

}



/* free os related resource in struct recv_buf */

int rtw_os_recvbuf_resource_free(struct adapter *padapter,

				 struct recv_buf *precvbuf)

{

	if (precvbuf->purb)

		usb_free_urb(precvbuf->purb);

	return _SUCCESS;

}



void rtw_handle_tkip_mic_err(struct adapter *padapter, u8 bgroup)

{

	union iwreq_data wrqu;

	struct iw_michaelmicfailure    ev;

	struct mlme_priv *pmlmepriv  = &padapter->mlmepriv;

	struct security_priv	*psecuritypriv = &padapter->securitypriv;

	u32 cur_time = 0;



	if (psecuritypriv->last_mic_err_time == 0) {

		psecuritypriv->last_mic_err_time = rtw_get_current_time();

	} else {

		cur_time = rtw_get_current_time();



		if (cur_time - psecuritypriv->last_mic_err_time < 60*HZ) {

			psecuritypriv->btkip_countermeasure = true;

			psecuritypriv->last_mic_err_time = 0;

			psecuritypriv->btkip_countermeasure_time = cur_time;

		} else {

			psecuritypriv->last_mic_err_time = rtw_get_current_time();

		}

	}



	_rtw_memset(&ev, 0x00, sizeof(ev));

	if (bgroup)

		ev.flags |= IW_MICFAILURE_GROUP;

	else

		ev.flags |= IW_MICFAILURE_PAIRWISE;



	ev.src_addr.sa_family = ARPHRD_ETHER;

	memcpy(ev.src_addr.sa_data, &pmlmepriv->assoc_bssid[0], ETH_ALEN);

	_rtw_memset(&wrqu, 0x00, sizeof(wrqu));

	wrqu.data.length = sizeof(ev);

	wireless_send_event(padapter->pnetdev, IWEVMICHAELMICFAILURE,

			    &wrqu, (char *)&ev);

}



void rtw_hostapd_mlme_rx(struct adapter *padapter,

			 union recv_frame *precv_frame)

{

}



int rtw_recv_indicatepkt(struct adapter *padapter,

			 union recv_frame *precv_frame)

{

	struct recv_priv *precvpriv;

	struct __queue *pfree_recv_queue;

	struct sk_buff *skb;

	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;



_func_enter_;



	precvpriv = &(padapter->recvpriv);

	pfree_recv_queue = &(precvpriv->free_recv_queue);



	skb = precv_frame->u.hdr.pkt;

	if (skb == NULL) {

		RT_TRACE(_module_recv_osdep_c_, _drv_err_,

			 ("rtw_recv_indicatepkt():skb == NULL something wrong!!!!\n"));

		goto _recv_indicatepkt_drop;

	}



	RT_TRACE(_module_recv_osdep_c_, _drv_info_,

		 ("rtw_recv_indicatepkt():skb != NULL !!!\n"));

	RT_TRACE(_module_recv_osdep_c_, _drv_info_,

		 ("rtw_recv_indicatepkt():precv_frame->u.hdr.rx_head =%p  precv_frame->hdr.rx_data =%p\n",

		 precv_frame->u.hdr.rx_head, precv_frame->u.hdr.rx_data));

	RT_TRACE(_module_recv_osdep_c_, _drv_info_,

		 ("precv_frame->hdr.rx_tail =%p precv_frame->u.hdr.rx_end =%p precv_frame->hdr.len =%d\n",

		 precv_frame->u.hdr.rx_tail, precv_frame->u.hdr.rx_end,

		 precv_frame->u.hdr.len));



	skb->data = precv_frame->u.hdr.rx_data;



	skb_set_tail_pointer(skb, precv_frame->u.hdr.len);



	skb->len = precv_frame->u.hdr.len;



	RT_TRACE(_module_recv_osdep_c_, _drv_info_,

		 ("skb->head =%p skb->data =%p skb->tail =%p skb->end =%p skb->len =%d\n",

		 skb->head, skb->data, skb_tail_pointer(skb),

		 skb_end_pointer(skb), skb->len));



	if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {

		struct sk_buff *pskb2 = NULL;

		struct sta_info *psta = NULL;

		struct sta_priv *pstapriv = &padapter->stapriv;

		struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;

		int bmcast = IS_MCAST(pattrib->dst);



		if (!_rtw_memcmp(pattrib->dst, myid(&padapter->eeprompriv),

				 ETH_ALEN)) {

			if (bmcast) {

				psta = rtw_get_bcmc_stainfo(padapter);

				pskb2 = skb_clone(skb, GFP_ATOMIC);

			} else {

				psta = rtw_get_stainfo(pstapriv, pattrib->dst);

			}



			if (psta) {

				struct net_device *pnetdev;



				pnetdev = (struct net_device *)padapter->pnetdev;

				skb->dev = pnetdev;

				skb_set_queue_mapping(skb, rtw_recv_select_queue(skb));



				rtw_xmit_entry(skb, pnetdev);



				if (bmcast)

					skb = pskb2;

				else

					goto _recv_indicatepkt_end;

			}

		}

	}



	rcu_read_lock();

	rcu_dereference(padapter->pnetdev->rx_handler_data);

	rcu_read_unlock();



	skb->ip_summed = CHECKSUM_NONE;

	skb->dev = padapter->pnetdev;

	skb->protocol = eth_type_trans(skb, padapter->pnetdev);



	netif_rx(skb);



_recv_indicatepkt_end:



	/*  pointers to NULL before rtw_free_recvframe() */

	precv_frame->u.hdr.pkt = NULL;



	rtw_free_recvframe(precv_frame, pfree_recv_queue);



	RT_TRACE(_module_recv_osdep_c_, _drv_info_,

		 ("\n rtw_recv_indicatepkt :after netif_rx!!!!\n"));



_func_exit_;



	return _SUCCESS;



_recv_indicatepkt_drop:



	 /* enqueue back to free_recv_queue */

	if (precv_frame)

		rtw_free_recvframe(precv_frame, pfree_recv_queue);



_func_exit_;

	 return _FAIL;

}



void rtw_os_read_port(struct adapter *padapter, struct recv_buf *precvbuf)

{

	struct recv_priv *precvpriv = &padapter->recvpriv;



	precvbuf->ref_cnt--;

	/* free skb in recv_buf */

	dev_kfree_skb_any(precvbuf->pskb);

	precvbuf->pskb = NULL;

	precvbuf->reuse = false;

	if (!precvbuf->irp_pending)

		rtw_read_port(padapter, precvpriv->ff_hwaddr, 0,

			      (unsigned char *)precvbuf);

}



static void _rtw_reordering_ctrl_timeout_handler(void *func_context)

{

	struct recv_reorder_ctrl *preorder_ctrl;



	preorder_ctrl = (struct recv_reorder_ctrl *)func_context;

	rtw_reordering_ctrl_timeout_handler(preorder_ctrl);

}



void rtw_init_recv_timer(struct recv_reorder_ctrl *preorder_ctrl)

{

	struct adapter *padapter = preorder_ctrl->padapter;



	_init_timer(&(preorder_ctrl->reordering_ctrl_timer), padapter->pnetdev, _rtw_reordering_ctrl_timeout_handler, preorder_ctrl);

}

drivers/staging/rtl8188eu/os_dep/rtw_android.c

0 → 100644
+293 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of version 2 of the GNU General Public License as

 * published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

 *

 *

 ******************************************************************************/



#include <linux/module.h>

#include <linux/netdevice.h>



#include <rtw_android.h>

#include <osdep_service.h>

#include <rtw_debug.h>

#include <ioctl_cfg80211.h>

#include <rtw_ioctl_set.h>



static const char *android_wifi_cmd_str[ANDROID_WIFI_CMD_MAX] = {

	"START",

	"STOP",

	"SCAN-ACTIVE",

	"SCAN-PASSIVE",

	"RSSI",

	"LINKSPEED",

	"RXFILTER-START",

	"RXFILTER-STOP",

	"RXFILTER-ADD",

	"RXFILTER-REMOVE",

	"BTCOEXSCAN-START",

	"BTCOEXSCAN-STOP",

	"BTCOEXMODE",

	"SETSUSPENDOPT",

	"P2P_DEV_ADDR",

	"SETFWPATH",

	"SETBAND",

	"GETBAND",

	"COUNTRY",

	"P2P_SET_NOA",

	"P2P_GET_NOA",

	"P2P_SET_PS",

	"SET_AP_WPS_P2P_IE",

	"MACADDR",

	"BLOCK",

	"WFD-ENABLE",

	"WFD-DISABLE",

	"WFD-SET-TCPPORT",

	"WFD-SET-MAXTPUT",

	"WFD-SET-DEVTYPE",

};



struct android_wifi_priv_cmd {

	const char __user *buf;

	int used_len;

	int total_len;

};



/**

 * Local (static) functions and variables

 */



/* Initialize g_wifi_on to 1 so dhd_bus_start will be called for the first

 * time (only) in dhd_open, subsequential wifi on will be handled by

 * wl_android_wifi_on

 */

static int g_wifi_on = true;



int rtw_android_cmdstr_to_num(char *cmdstr)

{

	int cmd_num;

	for (cmd_num = 0; cmd_num < ANDROID_WIFI_CMD_MAX; cmd_num++)

		if (0 == strnicmp(cmdstr , android_wifi_cmd_str[cmd_num],

				  strlen(android_wifi_cmd_str[cmd_num])))

			break;

	return cmd_num;

}



static int rtw_android_get_rssi(struct net_device *net, char *command,

				int total_len)

{

	struct adapter *padapter = (struct adapter *)rtw_netdev_priv(net);

	struct	mlme_priv	*pmlmepriv = &(padapter->mlmepriv);

	struct	wlan_network	*pcur_network = &pmlmepriv->cur_network;

	int bytes_written = 0;



	if (check_fwstate(pmlmepriv, _FW_LINKED)) {

		bytes_written += snprintf(&command[bytes_written], total_len,

					  "%s rssi %d",

					  pcur_network->network.Ssid.Ssid,

					  padapter->recvpriv.rssi);

	}

	return bytes_written;

}



static int rtw_android_get_link_speed(struct net_device *net, char *command,

				      int total_len)

{

	struct adapter *padapter = (struct adapter *)rtw_netdev_priv(net);

	int bytes_written;

	u16 link_speed;



	link_speed = rtw_get_cur_max_rate(padapter) / 10;

	bytes_written = snprintf(command, total_len, "LinkSpeed %d",

				 link_speed);

	return bytes_written;

}



static int rtw_android_get_macaddr(struct net_device *net, char *command,

				   int total_len)

{

	int bytes_written;



	bytes_written = snprintf(command, total_len, "Macaddr = %pM",

				 net->dev_addr);

	return bytes_written;

}



static int android_set_cntry(struct net_device *net, char *command,

			     int total_len)

{

	struct adapter *adapter = (struct adapter *)rtw_netdev_priv(net);

	char *country_code = command + strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_COUNTRY]) + 1;

	int ret;



	ret = rtw_set_country(adapter, country_code);

	return (ret == _SUCCESS) ? 0 : -1;

}



static int android_get_p2p_addr(struct net_device *net, char *command,

					int total_len)

{

	/* We use the same address as our HW MAC address */

	memcpy(command, net->dev_addr, ETH_ALEN);

	return ETH_ALEN;

}



static int rtw_android_set_block(struct net_device *net, char *command,

				 int total_len)

{

	return 0;

}



int rtw_android_priv_cmd(struct net_device *net, struct ifreq *ifr, int cmd)

{

	int ret = 0;

	char *command = NULL;

	int cmd_num;

	int bytes_written = 0;

	struct android_wifi_priv_cmd priv_cmd;



	rtw_lock_suspend();

	if (!ifr->ifr_data) {

		ret = -EINVAL;

		goto exit;

	}

	if (copy_from_user(&priv_cmd, ifr->ifr_data,

			   sizeof(struct android_wifi_priv_cmd))) {

		ret = -EFAULT;

		goto exit;

	}

	command = kmalloc(priv_cmd.total_len, GFP_KERNEL);

	if (!command) {

		DBG_88E("%s: failed to allocate memory\n", __func__);

		ret = -ENOMEM;

		goto exit;

	}

	if (!access_ok(VERIFY_READ, priv_cmd.buf, priv_cmd.total_len)) {

		DBG_88E("%s: failed to access memory\n", __func__);

		ret = -EFAULT;

		goto exit;

	}

	if (copy_from_user(command, (char __user *)priv_cmd.buf,

			   priv_cmd.total_len)) {

		ret = -EFAULT;

		goto exit;

	}

	DBG_88E("%s: Android private cmd \"%s\" on %s\n",

		__func__, command, ifr->ifr_name);

	cmd_num = rtw_android_cmdstr_to_num(command);

	switch (cmd_num) {

	case ANDROID_WIFI_CMD_START:

		goto response;

	case ANDROID_WIFI_CMD_SETFWPATH:

		goto response;

	}

	if (!g_wifi_on) {

		DBG_88E("%s: Ignore private cmd \"%s\" - iface %s is down\n",

			__func__, command, ifr->ifr_name);

		ret = 0;

		goto exit;

	}

	switch (cmd_num) {

	case ANDROID_WIFI_CMD_STOP:

		break;

	case ANDROID_WIFI_CMD_SCAN_ACTIVE:

		break;

	case ANDROID_WIFI_CMD_SCAN_PASSIVE:

		break;

	case ANDROID_WIFI_CMD_RSSI:

		bytes_written = rtw_android_get_rssi(net, command,

						     priv_cmd.total_len);

		break;

	case ANDROID_WIFI_CMD_LINKSPEED:

		bytes_written = rtw_android_get_link_speed(net, command,

							   priv_cmd.total_len);

		break;

	case ANDROID_WIFI_CMD_MACADDR:

		bytes_written = rtw_android_get_macaddr(net, command,

							priv_cmd.total_len);

		break;

	case ANDROID_WIFI_CMD_BLOCK:

		bytes_written = rtw_android_set_block(net, command,

						      priv_cmd.total_len);

		break;

	case ANDROID_WIFI_CMD_RXFILTER_START:

		break;

	case ANDROID_WIFI_CMD_RXFILTER_STOP:

		break;

	case ANDROID_WIFI_CMD_RXFILTER_ADD:

		break;

	case ANDROID_WIFI_CMD_RXFILTER_REMOVE:

		break;

	case ANDROID_WIFI_CMD_BTCOEXSCAN_START:

		/* TBD: BTCOEXSCAN-START */

		break;

	case ANDROID_WIFI_CMD_BTCOEXSCAN_STOP:

		/* TBD: BTCOEXSCAN-STOP */

		break;

	case ANDROID_WIFI_CMD_BTCOEXMODE:

		break;

	case ANDROID_WIFI_CMD_SETSUSPENDOPT:

		break;

	case ANDROID_WIFI_CMD_SETBAND:

		break;

	case ANDROID_WIFI_CMD_GETBAND:

		break;

	case ANDROID_WIFI_CMD_COUNTRY:

		bytes_written = android_set_cntry(net, command,

						  priv_cmd.total_len);

		break;

	case ANDROID_WIFI_CMD_P2P_DEV_ADDR:

		bytes_written = android_get_p2p_addr(net, command,

						     priv_cmd.total_len);

		break;

	case ANDROID_WIFI_CMD_P2P_SET_NOA:

		break;

	case ANDROID_WIFI_CMD_P2P_GET_NOA:

		break;

	case ANDROID_WIFI_CMD_P2P_SET_PS:

		break;

	default:

		DBG_88E("Unknown PRIVATE command %s - ignored\n", command);

		snprintf(command, 3, "OK");

		bytes_written = strlen("OK");

	}



response:

	if (bytes_written >= 0) {

		if ((bytes_written == 0) && (priv_cmd.total_len > 0))

			command[0] = '\0';

		if (bytes_written >= priv_cmd.total_len) {

			DBG_88E("%s: bytes_written = %d\n", __func__,

				bytes_written);

			bytes_written = priv_cmd.total_len;

		} else {

			bytes_written++;

		}

		priv_cmd.used_len = bytes_written;

		if (copy_to_user((char __user *)priv_cmd.buf, command,

				 bytes_written)) {

			DBG_88E("%s: failed to copy data to user buffer\n",

				__func__);

			ret = -EFAULT;

		}

	} else {

		ret = bytes_written;

	}

exit:

	rtw_unlock_suspend();

	kfree(command);

	return ret;

}