/* rtwlan.c
|
*
|
* rtwlan protocol stack
|
* Copyright (c) 2006, Daniel Gregorek <dxg@gmx.de>
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
*
|
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
*
|
*/
|
|
#include <linux/module.h>
|
|
#include <rtnet_port.h>
|
|
#include <rtwlan.h>
|
|
int rtwlan_rx(struct rtskb *rtskb, struct rtnet_device *rtnet_dev)
|
{
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rtskb->data;
|
u16 fc = le16_to_cpu(hdr->frame_ctl);
|
|
/* strip rtwlan header */
|
rtskb_pull(rtskb, ieee80211_get_hdrlen(fc));
|
rtskb->protocol = rt_eth_type_trans(rtskb, rtnet_dev);
|
|
/* forward rtskb to rtnet */
|
rtnetif_rx(rtskb);
|
|
return 0;
|
}
|
|
EXPORT_SYMBOL_GPL(rtwlan_rx);
|
|
int rtwlan_tx(struct rtskb *rtskb, struct rtnet_device *rtnet_dev)
|
{
|
struct rtwlan_device *rtwlan_dev = rtnetdev_priv(rtnet_dev);
|
struct ieee80211_hdr_3addr header = { /* Ensure zero initialized */
|
.duration_id = 0,
|
.seq_ctl = 0
|
};
|
int ret;
|
u8 dest[ETH_ALEN], src[ETH_ALEN];
|
|
/* Get source and destination addresses */
|
|
memcpy(src, rtskb->data + ETH_ALEN, ETH_ALEN);
|
|
if (rtwlan_dev->mode == RTWLAN_TXMODE_MCAST) {
|
memcpy(dest, rtnet_dev->dev_addr, ETH_ALEN);
|
dest[0] |= 0x01;
|
} else {
|
memcpy(dest, rtskb->data, ETH_ALEN);
|
}
|
|
/*
|
* Generate ieee80211 compatible header
|
*/
|
memcpy(header.addr3, src, ETH_ALEN); /* BSSID */
|
memcpy(header.addr2, src, ETH_ALEN); /* SA */
|
memcpy(header.addr1, dest, ETH_ALEN); /* DA */
|
|
/* Write frame control field */
|
header.frame_ctl =
|
cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
|
|
memcpy(rtskb_push(rtskb, IEEE80211_3ADDR_LEN), &header,
|
IEEE80211_3ADDR_LEN);
|
|
ret = (*rtwlan_dev->hard_start_xmit)(rtskb, rtnet_dev);
|
|
return ret;
|
}
|
|
EXPORT_SYMBOL_GPL(rtwlan_tx);
|
|
/**
|
* rtalloc_wlandev - Allocates and sets up a wlan device
|
* @sizeof_priv: size of additional driver-private structure to
|
* be allocated for this wlan device
|
*
|
* Fill in the fields of the device structure with wlan-generic
|
* values. Basically does everything except registering the device.
|
*
|
* A 32-byte alignment is enforced for the private data area.
|
*/
|
|
struct rtnet_device *rtwlan_alloc_dev(unsigned sizeof_priv,
|
unsigned dev_pool_size)
|
{
|
struct rtnet_device *rtnet_dev;
|
|
RTWLAN_DEBUG("Start.\n");
|
|
rtnet_dev = rt_alloc_etherdev(
|
sizeof(struct rtwlan_device) + sizeof_priv, dev_pool_size);
|
if (!rtnet_dev)
|
return NULL;
|
|
rtnet_dev->hard_start_xmit = rtwlan_tx;
|
|
rtdev_alloc_name(rtnet_dev, "rtwlan%d");
|
|
return rtnet_dev;
|
}
|
|
EXPORT_SYMBOL_GPL(rtwlan_alloc_dev);
|
|
int rtwlan_ioctl(struct rtnet_device *rtdev, unsigned int request,
|
unsigned long arg)
|
{
|
struct rtwlan_cmd cmd;
|
struct ifreq ifr;
|
int ret = 0;
|
|
if (copy_from_user(&cmd, (void *)arg, sizeof(cmd)) != 0)
|
return -EFAULT;
|
|
/*
|
* FIXME: proper do_ioctl() should expect a __user pointer
|
* arg. This only works with the existing WLAN support because the
|
* only driver currently providing this feature is broken, not
|
* doing the copy_to/from_user dance.
|
*/
|
memset(&ifr, 0, sizeof(ifr));
|
ifr.ifr_data = &cmd;
|
|
switch (request) {
|
case IOC_RTWLAN_IFINFO:
|
if (cmd.args.info.ifindex > 0)
|
rtdev = rtdev_get_by_index(cmd.args.info.ifindex);
|
else
|
rtdev = rtdev_get_by_name(cmd.head.if_name);
|
if (rtdev == NULL)
|
return -ENODEV;
|
|
if (mutex_lock_interruptible(&rtdev->nrt_lock)) {
|
rtdev_dereference(rtdev);
|
return -ERESTARTSYS;
|
}
|
|
if (rtdev->do_ioctl)
|
ret = rtdev->do_ioctl(rtdev, &ifr, request);
|
else
|
ret = -ENORTWLANDEV;
|
|
memcpy(cmd.head.if_name, rtdev->name, IFNAMSIZ);
|
cmd.args.info.ifindex = rtdev->ifindex;
|
cmd.args.info.flags = rtdev->flags;
|
|
mutex_unlock(&rtdev->nrt_lock);
|
|
rtdev_dereference(rtdev);
|
|
break;
|
|
case IOC_RTWLAN_TXMODE:
|
case IOC_RTWLAN_BITRATE:
|
case IOC_RTWLAN_CHANNEL:
|
case IOC_RTWLAN_RETRY:
|
case IOC_RTWLAN_TXPOWER:
|
case IOC_RTWLAN_AUTORESP:
|
case IOC_RTWLAN_DROPBCAST:
|
case IOC_RTWLAN_DROPMCAST:
|
case IOC_RTWLAN_REGREAD:
|
case IOC_RTWLAN_REGWRITE:
|
case IOC_RTWLAN_BBPWRITE:
|
case IOC_RTWLAN_BBPREAD:
|
case IOC_RTWLAN_BBPSENS:
|
if (mutex_lock_interruptible(&rtdev->nrt_lock))
|
return -ERESTARTSYS;
|
|
if (rtdev->do_ioctl)
|
ret = rtdev->do_ioctl(rtdev, &ifr, request);
|
else
|
ret = -ENORTWLANDEV;
|
|
mutex_unlock(&rtdev->nrt_lock);
|
|
break;
|
|
default:
|
ret = -ENOTTY;
|
}
|
|
if (copy_to_user((void *)arg, &cmd, sizeof(cmd)) != 0)
|
return -EFAULT;
|
|
return ret;
|
}
|
|
struct rtnet_ioctls rtnet_wlan_ioctls = {
|
service_name: "rtwlan ioctl",
|
ioctl_type: RTNET_IOC_TYPE_RTWLAN,
|
handler: rtwlan_ioctl
|
};
|
|
int __init rtwlan_init(void)
|
{
|
if (rtnet_register_ioctls(&rtnet_wlan_ioctls))
|
rtdm_printk(KERN_ERR "Failed to register rtnet_wlan_ioctl!\n");
|
|
return 0;
|
}
|
|
void rtwlan_exit(void)
|
{
|
rtnet_unregister_ioctls(&rtnet_wlan_ioctls);
|
}
|
