orinoco.c

linux 下的无限网卡驱动开发

#endif /* WIRELESS_EXT > 10 */

	if (copy_to_user(rrq->pointer, &range, sizeof(range)))
		return -EFAULT;

	TRACE_EXIT(dev->name);

	return 0;
}

static int dldwd_ioctl_setiwencode(struct net_device *dev, struct iw_point *erq)
{
	dldwd_priv_t *priv = dev->priv;
	int index = (erq->flags & IW_ENCODE_INDEX) - 1;
	int setindex = priv->tx_key;
	int enable = priv->wep_on;
	int restricted = priv->wep_restrict;
	uint16_t xlen = 0;
	int err = 0;
	char keybuf[MAX_KEY_SIZE];

	if (erq->pointer) {
		/* We actually have a key to set */
		
		if (copy_from_user(keybuf, erq->pointer, erq->length))
			return -EFAULT;
	}
	
	dldwd_lock(priv);
	
	if (erq->pointer) {
		if (erq->length > MAX_KEY_SIZE) {
			err = -E2BIG;
			goto out;
		}
		
		if ( (erq->length > LARGE_KEY_SIZE)
		     || ( ! priv->has_big_wep && (erq->length > SMALL_KEY_SIZE))  ) {
			err = -EINVAL;
			goto out;
		}
		
		if ((index < 0) || (index >= MAX_KEYS))
			index = priv->tx_key;
		
		if (erq->length > SMALL_KEY_SIZE) {
			xlen = LARGE_KEY_SIZE;
		} else if (erq->length > 0) {
			xlen = SMALL_KEY_SIZE;
		} else
			xlen = 0;
		
		/* Switch on WEP if off */
		if ((!enable) && (xlen > 0)) {
			setindex = index;
			enable = 1;
		}
	} else {
		/* Important note : if the user do "iwconfig eth0 enc off",
		 * we will arrive there with an index of -1. This is valid
		 * but need to be taken care off... Jean II */
		if ((index < 0) || (index >= MAX_KEYS)) {
			if((index != -1) || (erq->flags == 0)) {
				err = -EINVAL;
				goto out;
			}
		} else {
			/* Set the index : Check that the key is valid */
			if(priv->keys[index].len == 0) {
				err = -EINVAL;
				goto out;
			}
			setindex = index;
		}
	}
	
	if (erq->flags & IW_ENCODE_DISABLED)
		enable = 0;
	/* Only for Prism2 & Symbol cards (so far) - Jean II */
	if (erq->flags & IW_ENCODE_OPEN)
		restricted = 0;
	if (erq->flags & IW_ENCODE_RESTRICTED)
		restricted = 1;

	if (erq->pointer) {
		priv->keys[index].len = cpu_to_le16(xlen);
		memset(priv->keys[index].data, 0, sizeof(priv->keys[index].data));
		memcpy(priv->keys[index].data, keybuf, erq->length);
	}
	priv->tx_key = setindex;
	priv->wep_on = enable;
	priv->wep_restrict = restricted;
	
 out:
	dldwd_unlock(priv);

	return 0;
}

static int dldwd_ioctl_getiwencode(struct net_device *dev, struct iw_point *erq)
{
	dldwd_priv_t *priv = dev->priv;
	int index = (erq->flags & IW_ENCODE_INDEX) - 1;
	uint16_t xlen = 0;
	char keybuf[MAX_KEY_SIZE];

	
	dldwd_lock(priv);

	if ((index < 0) || (index >= MAX_KEYS))
		index = priv->tx_key;

	erq->flags = 0;
	if (! priv->wep_on)
		erq->flags |= IW_ENCODE_DISABLED;
	erq->flags |= index + 1;
	
	/* Only for symbol cards - Jean II */
	if (priv->firmware_type != FIRMWARE_TYPE_LUCENT) {
		if(priv->wep_restrict)
			erq->flags |= IW_ENCODE_RESTRICTED;
		else
			erq->flags |= IW_ENCODE_OPEN;
	}

	xlen = le16_to_cpu(priv->keys[index].len);

	erq->length = xlen;

	if (erq->pointer) {
		memcpy(keybuf, priv->keys[index].data, MAX_KEY_SIZE);
	}
	
	dldwd_unlock(priv);

	if (erq->pointer) {
		if (copy_to_user(erq->pointer, keybuf, xlen))
			return -EFAULT;
	}

	return 0;
}

static int dldwd_ioctl_setessid(struct net_device *dev, struct iw_point *erq)
{
	dldwd_priv_t *priv = dev->priv;
	char essidbuf[IW_ESSID_MAX_SIZE+1];

	/* Note : ESSID is ignored in Ad-Hoc demo mode, but we can set it
	 * anyway... - Jean II */

	memset(&essidbuf, 0, sizeof(essidbuf));

	if (erq->flags) { 
		if (erq->length > IW_ESSID_MAX_SIZE)
			return -E2BIG;
		
		if (copy_from_user(&essidbuf, erq->pointer, erq->length))
			return -EFAULT;

		essidbuf[erq->length] = '\0';
	}

	dldwd_lock(priv);

	memcpy(priv->desired_essid, essidbuf, IW_ESSID_MAX_SIZE+1);

	dldwd_unlock(priv);

	return 0;
}

static int dldwd_ioctl_getessid(struct net_device *dev, struct iw_point *erq)
{
	dldwd_priv_t *priv = dev->priv;
	char essidbuf[IW_ESSID_MAX_SIZE+1];
	int active;
	int err = 0;

	TRACE_ENTER(dev->name);

	err = dldwd_hw_get_essid(priv, &active, essidbuf);
	if (err)
		return err;

	erq->flags = 1;
	erq->length = strlen(essidbuf) + 1;
	if (erq->pointer)
		if ( copy_to_user(erq->pointer, essidbuf, erq->length) )
			return -EFAULT;

	TRACE_EXIT(dev->name);
	
	return 0;
}

static int dldwd_ioctl_setnick(struct net_device *dev, struct iw_point *nrq)
{
	dldwd_priv_t *priv = dev->priv;
	char nickbuf[IW_ESSID_MAX_SIZE+1];

	if (nrq->length > IW_ESSID_MAX_SIZE)
		return -E2BIG;

	memset(nickbuf, 0, sizeof(nickbuf));

	if (copy_from_user(nickbuf, nrq->pointer, nrq->length))
		return -EFAULT;

	nickbuf[nrq->length] = '\0';
	
	dldwd_lock(priv);

	memcpy(priv->nick, nickbuf, sizeof(priv->nick));

	dldwd_unlock(priv);

	return 0;
}

static int dldwd_ioctl_getnick(struct net_device *dev, struct iw_point *nrq)
{
	dldwd_priv_t *priv = dev->priv;
	char nickbuf[IW_ESSID_MAX_SIZE+1];

	dldwd_lock(priv);
	memcpy(nickbuf, priv->nick, IW_ESSID_MAX_SIZE+1);
	dldwd_unlock(priv);

	nrq->length = strlen(nickbuf)+1;

	if (copy_to_user(nrq->pointer, nickbuf, sizeof(nickbuf)))
		return -EFAULT;

	return 0;
}

static int dldwd_ioctl_setfreq(struct net_device *dev, struct iw_freq *frq)
{
	dldwd_priv_t *priv = dev->priv;
	int chan = -1;

	/* We can only use this in Ad-Hoc demo mode to set the operating
	 * frequency, or in IBSS mode to set the frequency where the IBSS
	 * will be created - Jean II */
	if (priv->iw_mode != IW_MODE_ADHOC)
		return -EOPNOTSUPP;

	if ( (frq->e == 0) && (frq->m <= 1000) ) {
		/* Setting by channel number */
		chan = frq->m;
	} else {
		/* Setting by frequency - search the table */
		int mult = 1;
		int i;

		for (i = 0; i < (6 - frq->e); i++)
			mult *= 10;

		for (i = 0; i < NUM_CHANNELS; i++)
			if (frq->m == (channel_frequency[i] * mult))
				chan = i+1;
	}

	if ( (chan < 1) || (chan > NUM_CHANNELS) ||
	     ! (priv->channel_mask & (1 << (chan-1)) ) )
		return -EINVAL;

	dldwd_lock(priv);
	priv->channel = chan;
	dldwd_unlock(priv);

	return 0;
}

static int dldwd_ioctl_getsens(struct net_device *dev, struct iw_param *srq)
{
	dldwd_priv_t *priv = dev->priv;
	hermes_t *hw = &priv->hw;
	uint16_t val;
	int err;

	dldwd_lock(priv);
	err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNF_SYSTEM_SCALE, &val);
	dldwd_unlock(priv);

	if (err)
		return err;

	srq->value = val;
	srq->fixed = 0; /* auto */

	return 0;
}

static int dldwd_ioctl_setsens(struct net_device *dev, struct iw_param *srq)
{
	dldwd_priv_t *priv = dev->priv;
	int val = srq->value;

	if ((val < 1) || (val > 3))
		return -EINVAL;
	
	dldwd_lock(priv);
	priv->ap_density = val;
	dldwd_unlock(priv);

	return 0;
}

static int dldwd_ioctl_setrts(struct net_device *dev, struct iw_param *rrq)
{
	dldwd_priv_t *priv = dev->priv;
	int val = rrq->value;

	if (rrq->disabled)
		val = 2347;

	if ( (val < 0) || (val > 2347) )
		return -EINVAL;

	dldwd_lock(priv);
	priv->rts_thresh = val;
	dldwd_unlock(priv);

	return 0;
}

static int dldwd_ioctl_setfrag(struct net_device *dev, struct iw_param *frq)
{
	dldwd_priv_t *priv = dev->priv;
	int err = 0;

	dldwd_lock(priv);

	if (priv->has_mwo) {
		if (frq->disabled)
			priv->mwo_robust = 0;
		else {
			if (frq->fixed)
				printk(KERN_WARNING "%s: Fixed fragmentation not \
supported on this firmware. Using MWO robust instead.\n", dev->name);
			priv->mwo_robust = 1;
		}
	} else {
		if (frq->disabled)
			priv->frag_thresh = 2346;
		else {
			if ( (frq->value < 256) || (frq->value > 2346) )
				err = -EINVAL;
			else
				priv->frag_thresh = frq->value & ~0x1; /* must be even */
		}
	}

	dldwd_unlock(priv);

	return err;
}

static int dldwd_ioctl_getfrag(struct net_device *dev, struct iw_param *frq)
{
	dldwd_priv_t *priv = dev->priv;
	hermes_t *hw = &priv->hw;
	int err = 0;
	uint16_t val;

	dldwd_lock(priv);
	
	if (priv->has_mwo) {
		err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNF_MWO_ROBUST, &val);
		if (err)
			val = 0;

		frq->value = val ? 2347 : 0;
		frq->disabled = ! val;
		frq->fixed = 0;
	} else {
		err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNF_FRAG_THRESH, &val);
		if (err)
			val = 0;

		frq->value = val;
		frq->disabled = (val >= 2346);
		frq->fixed = 1;
	}

	dldwd_unlock(priv);
	
	return err;
}

static int dldwd_ioctl_setrate(struct net_device *dev, struct iw_param *rrq)
{
	dldwd_priv_t *priv = dev->priv;
	int err = 0;
	int rate_ctrl = -1;
	int fixed, upto;
	int brate;
	int i;

	dldwd_lock(priv);

	/* Normalise value */
	brate = rrq->value / 500000;

	switch (priv->firmware_type) {
	case FIRMWARE_TYPE_LUCENT: /* Lucent style rate */
		if (! rrq->fixed) {
			if (brate > 0)
				brate = -brate;
			else
				brate = -22;
		}
	
		for (i = 0; i < NUM_RATES; i++)
			if (rate_list[i] == brate) {
				rate_ctrl = i;
				break;
			}
	
		if ( (rate_ctrl < 1) || (rate_ctrl >= NUM_RATES) )
			err = -EINVAL;
		else
			priv->tx_rate_ctrl = rate_ctrl;
		break;
	case FIRMWARE_TYPE_PRISM2: /* Prism II style rate */
	case FIRMWARE_TYPE_SYMBOL: /* Symbol style rate */
		switch(brate) {
		case 0:
			fixed = 0x0;
			upto = 0xF;
			break;
		case 2:
			fixed = 0x1;
			upto = 0x1;
			break;
		case 4:
			fixed = 0x2;
			upto = 0x3;
			break;
		case 11:
			fixed = 0x4;
			upto = 0x7;
			break;
		case 22:
			fixed = 0x8;
			upto = 0xF;
			break;
		default:
			fixed = 0x0;
			upto = 0x0;
		}
		if (rrq->fixed)
			rate_ctrl = fixed;
		else
			rate_ctrl = upto;
		if (rate_ctrl == 0)
			err = -EINVAL;
		else
			priv->tx_rate_ctrl = rate_ctrl;
		break;
	}

	dldwd_unlock(priv);

	return err;
}

static int dldwd_ioctl_getrate(struct net_device *dev, struct iw_param