[deliverable/linux.git] / drivers / net / irda / sir_dev.c

/*********************************************************************
 *
 *	sir_dev.c:	irda sir network device
 * 
 *	Copyright (c) 2002 Martin Diehl
 * 
 *	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.
 *
 ********************************************************************/    

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/smp_lock.h>
#include <linux/delay.h>

#include <net/irda/irda.h>
#include <net/irda/wrapper.h>
#include <net/irda/irda_device.h>

#include "sir-dev.h"

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

void sirdev_enable_rx(struct sir_dev *dev)
{
	if (unlikely(atomic_read(&dev->enable_rx)))
		return;

	/* flush rx-buffer - should also help in case of problems with echo cancelation */
	dev->rx_buff.data = dev->rx_buff.head;
	dev->rx_buff.len = 0;
	dev->rx_buff.in_frame = FALSE;
	dev->rx_buff.state = OUTSIDE_FRAME;
	atomic_set(&dev->enable_rx, 1);
}

static int sirdev_is_receiving(struct sir_dev *dev)
{
	if (!atomic_read(&dev->enable_rx))
		return 0;

	return (dev->rx_buff.state != OUTSIDE_FRAME);
}

int sirdev_set_dongle(struct sir_dev *dev, IRDA_DONGLE type)
{
	int err;

	IRDA_DEBUG(3, "%s : requesting dongle %d.\n", __FUNCTION__, type);

	err = sirdev_schedule_dongle_open(dev, type);
	if (unlikely(err))
		return err;
	down(&dev->fsm.sem);		/* block until config change completed */
	err = dev->fsm.result;
	up(&dev->fsm.sem);
	return err;
}
EXPORT_SYMBOL(sirdev_set_dongle);

/* used by dongle drivers for dongle programming */

int sirdev_raw_write(struct sir_dev *dev, const char *buf, int len)
{
	unsigned long flags;
	int ret;

	if (unlikely(len > dev->tx_buff.truesize))
		return -ENOSPC;

	spin_lock_irqsave(&dev->tx_lock, flags);	/* serialize with other tx operations */
	while (dev->tx_buff.len > 0) {			/* wait until tx idle */
		spin_unlock_irqrestore(&dev->tx_lock, flags);
		msleep(10);
		spin_lock_irqsave(&dev->tx_lock, flags);
	}

	dev->tx_buff.data = dev->tx_buff.head;
	memcpy(dev->tx_buff.data, buf, len);	
	dev->tx_buff.len = len;

	ret = dev->drv->do_write(dev, dev->tx_buff.data, dev->tx_buff.len);
	if (ret > 0) {
		IRDA_DEBUG(3, "%s(), raw-tx started\n", __FUNCTION__);

		dev->tx_buff.data += ret;
		dev->tx_buff.len -= ret;
		dev->raw_tx = 1;
		ret = len;		/* all data is going to be sent */
	}
	spin_unlock_irqrestore(&dev->tx_lock, flags);
	return ret;
}
EXPORT_SYMBOL(sirdev_raw_write);

/* seems some dongle drivers may need this */

int sirdev_raw_read(struct sir_dev *dev, char *buf, int len)
{
	int count;

	if (atomic_read(&dev->enable_rx))
		return -EIO;		/* fail if we expect irda-frames */

	count = (len < dev->rx_buff.len) ? len : dev->rx_buff.len;

	if (count > 0) {
		memcpy(buf, dev->rx_buff.data, count);
		dev->rx_buff.data += count;
		dev->rx_buff.len -= count;
	}

	/* remaining stuff gets flushed when re-enabling normal rx */

	return count;
}
EXPORT_SYMBOL(sirdev_raw_read);

int sirdev_set_dtr_rts(struct sir_dev *dev, int dtr, int rts)
{
	int ret = -ENXIO;
	if (dev->drv->set_dtr_rts != 0)
		ret =  dev->drv->set_dtr_rts(dev, dtr, rts);
	return ret;
}
EXPORT_SYMBOL(sirdev_set_dtr_rts);

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

/* called from client driver - likely with bh-context - to indicate
 * it made some progress with transmission. Hence we send the next
 * chunk, if any, or complete the skb otherwise
 */

void sirdev_write_complete(struct sir_dev *dev)
{
	unsigned long flags;
	struct sk_buff *skb;
	int actual = 0;
	int err;
	
	spin_lock_irqsave(&dev->tx_lock, flags);

	IRDA_DEBUG(3, "%s() - dev->tx_buff.len = %d\n",
		   __FUNCTION__, dev->tx_buff.len);

	if (likely(dev->tx_buff.len > 0))  {
		/* Write data left in transmit buffer */
		actual = dev->drv->do_write(dev, dev->tx_buff.data, dev->tx_buff.len);

		if (likely(actual>0)) {
			dev->tx_buff.data += actual;
			dev->tx_buff.len  -= actual;
		}
		else if (unlikely(actual<0)) {
			/* could be dropped later when we have tx_timeout to recover */
			IRDA_ERROR("%s: drv->do_write failed (%d)\n",
				   __FUNCTION__, actual);
			if ((skb=dev->tx_skb) != NULL) {
				dev->tx_skb = NULL;
				dev_kfree_skb_any(skb);
				dev->stats.tx_errors++;		      
				dev->stats.tx_dropped++;		      
			}
			dev->tx_buff.len = 0;
		}
		if (dev->tx_buff.len > 0)
			goto done;	/* more data to send later */
	}

	if (unlikely(dev->raw_tx != 0)) {
		/* in raw mode we are just done now after the buffer was sent
		 * completely. Since this was requested by some dongle driver
		 * running under the control of the irda-thread we must take
		 * care here not to re-enable the queue. The queue will be
		 * restarted when the irda-thread has completed the request.
		 */

		IRDA_DEBUG(3, "%s(), raw-tx done\n", __FUNCTION__);
		dev->raw_tx = 0;
		goto done;	/* no post-frame handling in raw mode */
	}

	/* we have finished now sending this skb.
	 * update statistics and free the skb.
	 * finally we check and trigger a pending speed change, if any.
	 * if not we switch to rx mode and wake the queue for further
	 * packets.
	 * note the scheduled speed request blocks until the lower
	 * client driver and the corresponding hardware has really
	 * finished sending all data (xmit fifo drained f.e.)
	 * before the speed change gets finally done and the queue
	 * re-activated.
	 */

	IRDA_DEBUG(5, "%s(), finished with frame!\n", __FUNCTION__);
		
	if ((skb=dev->tx_skb) != NULL) {
		dev->tx_skb = NULL;
		dev->stats.tx_packets++;		      
		dev->stats.tx_bytes += skb->len;
		dev_kfree_skb_any(skb);
	}

	if (unlikely(dev->new_speed > 0)) {
		IRDA_DEBUG(5, "%s(), Changing speed!\n", __FUNCTION__);
		err = sirdev_schedule_speed(dev, dev->new_speed);
		if (unlikely(err)) {
			/* should never happen
			 * forget the speed change and hope the stack recovers
			 */
			IRDA_ERROR("%s - schedule speed change failed: %d\n",
				   __FUNCTION__, err);
			netif_wake_queue(dev->netdev);
		}
		/* else: success
		 *	speed change in progress now
		 *	on completion dev->new_speed gets cleared,
		 *	rx-reenabled and the queue restarted
		 */
	}
	else {
		sirdev_enable_rx(dev);
		netif_wake_queue(dev->netdev);
	}

done:
	spin_unlock_irqrestore(&dev->tx_lock, flags);
}
EXPORT_SYMBOL(sirdev_write_complete);

/* called from client driver - likely with bh-context - to give us
 * some more received bytes. We put them into the rx-buffer,
 * normally unwrapping and building LAP-skb's (unless rx disabled)
 */

int sirdev_receive(struct sir_dev *dev, const unsigned char *cp, size_t count) 
{
	if (!dev || !dev->netdev) {
		IRDA_WARNING("%s(), not ready yet!\n", __FUNCTION__);
		return -1;
	}

	if (!dev->irlap) {
		IRDA_WARNING("%s - too early: %p / %zd!\n",
			     __FUNCTION__, cp, count);
		return -1;
	}

	if (cp==NULL) {
		/* error already at lower level receive
		 * just update stats and set media busy
		 */
		irda_device_set_media_busy(dev->netdev, TRUE);
		dev->stats.rx_dropped++;
		IRDA_DEBUG(0, "%s; rx-drop: %zd\n", __FUNCTION__, count);
		return 0;
	}

	/* Read the characters into the buffer */
	if (likely(atomic_read(&dev->enable_rx))) {
		while (count--)
			/* Unwrap and destuff one byte */
			async_unwrap_char(dev->netdev, &dev->stats, 
					  &dev->rx_buff, *cp++);
	} else {
		while (count--) {
			/* rx not enabled: save the raw bytes and never
			 * trigger any netif_rx. The received bytes are flushed
			 * later when we re-enable rx but might be read meanwhile
			 * by the dongle driver.
			 */
			dev->rx_buff.data[dev->rx_buff.len++] = *cp++;

			/* What should we do when the buffer is full? */
			if (unlikely(dev->rx_buff.len == dev->rx_buff.truesize))
				dev->rx_buff.len = 0;
		}
	}

	return 0;
}
EXPORT_SYMBOL(sirdev_receive);

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

/* callbacks from network layer */

static struct net_device_stats *sirdev_get_stats(struct net_device *ndev)
{
	struct sir_dev *dev = ndev->priv;

	return (dev) ? &dev->stats : NULL;
}

static int sirdev_hard_xmit(struct sk_buff *skb, struct net_device *ndev)
{
	struct sir_dev *dev = ndev->priv;
	unsigned long flags;
	int actual = 0;
	int err;
	s32 speed;

	IRDA_ASSERT(dev != NULL, return 0;);

	netif_stop_queue(ndev);

	IRDA_DEBUG(3, "%s(), skb->len = %d\n", __FUNCTION__, skb->len);

	speed = irda_get_next_speed(skb);
	if ((speed != dev->speed) && (speed != -1)) {
		if (!skb->len) {
			err = sirdev_schedule_speed(dev, speed);
			if (unlikely(err == -EWOULDBLOCK)) {
				/* Failed to initiate the speed change, likely the fsm
				 * is still busy (pretty unlikely, but...)
				 * We refuse to accept the skb and return with the queue
				 * stopped so the network layer will retry after the
				 * fsm completes and wakes the queue.
				 */
				 return 1;
			}
			else if (unlikely(err)) {
				/* other fatal error - forget the speed change and
				 * hope the stack will recover somehow
				 */
				 netif_start_queue(ndev);
			}
			/* else: success
			 *	speed change in progress now
			 *	on completion the queue gets restarted
			 */

			dev_kfree_skb_any(skb);
			return 0;
		} else
			dev->new_speed = speed;
	}

	/* Init tx buffer*/
	dev->tx_buff.data = dev->tx_buff.head;

	/* Check problems */
	if(spin_is_locked(&dev->tx_lock)) {
		IRDA_DEBUG(3, "%s(), write not completed\n", __FUNCTION__);
	}

	/* serialize with write completion */
	spin_lock_irqsave(&dev->tx_lock, flags);

        /* Copy skb to tx_buff while wrapping, stuffing and making CRC */
	dev->tx_buff.len = async_wrap_skb(skb, dev->tx_buff.data, dev->tx_buff.truesize); 

	/* transmission will start now - disable receive.
	 * if we are just in the middle of an incoming frame,
	 * treat it as collision. probably it's a good idea to
	 * reset the rx_buf OUTSIDE_FRAME in this case too?
	 */
	atomic_set(&dev->enable_rx, 0);
	if (unlikely(sirdev_is_receiving(dev)))
		dev->stats.collisions++;

	actual = dev->drv->do_write(dev, dev->tx_buff.data, dev->tx_buff.len);

	if (likely(actual > 0)) {
		dev->tx_skb = skb;
		ndev->trans_start = jiffies;
		dev->tx_buff.data += actual;
		dev->tx_buff.len -= actual;
	}
	else if (unlikely(actual < 0)) {
		/* could be dropped later when we have tx_timeout to recover */
		IRDA_ERROR("%s: drv->do_write failed (%d)\n",
			   __FUNCTION__, actual);
		dev_kfree_skb_any(skb);
		dev->stats.tx_errors++;		      
		dev->stats.tx_dropped++;		      
		netif_wake_queue(ndev);
	}
	spin_unlock_irqrestore(&dev->tx_lock, flags);

	return 0;
}

/* called from network layer with rtnl hold */

static int sirdev_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
{
	struct if_irda_req *irq = (struct if_irda_req *) rq;
	struct sir_dev *dev = ndev->priv;
	int ret = 0;

	IRDA_ASSERT(dev != NULL, return -1;);

	IRDA_DEBUG(3, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__, ndev->name, cmd);
	
	switch (cmd) {
	case SIOCSBANDWIDTH: /* Set bandwidth */
		if (!capable(CAP_NET_ADMIN))
			ret = -EPERM;
		else
			ret = sirdev_schedule_speed(dev, irq->ifr_baudrate);
		/* cannot sleep here for completion
		 * we are called from network layer with rtnl hold
		 */
		break;

	case SIOCSDONGLE: /* Set dongle */
		if (!capable(CAP_NET_ADMIN))
			ret = -EPERM;
		else
			ret = sirdev_schedule_dongle_open(dev, irq->ifr_dongle);
		/* cannot sleep here for completion
		 * we are called from network layer with rtnl hold
		 */
		break;

	case SIOCSMEDIABUSY: /* Set media busy */
		if (!capable(CAP_NET_ADMIN))
			ret = -EPERM;
		else
			irda_device_set_media_busy(dev->netdev, TRUE);
		break;

	case SIOCGRECEIVING: /* Check if we are receiving right now */
		irq->ifr_receiving = sirdev_is_receiving(dev);
		break;

	case SIOCSDTRRTS:
		if (!capable(CAP_NET_ADMIN))
			ret = -EPERM;
		else
			ret = sirdev_schedule_dtr_rts(dev, irq->ifr_dtr, irq->ifr_rts);
		/* cannot sleep here for completion
		 * we are called from network layer with rtnl hold
		 */
		break;

	case SIOCSMODE:
#if 0
		if (!capable(CAP_NET_ADMIN))
			ret = -EPERM;
		else
			ret = sirdev_schedule_mode(dev, irq->ifr_mode);
		/* cannot sleep here for completion
		 * we are called from network layer with rtnl hold
		 */
		break;
#endif
	default:
		ret = -EOPNOTSUPP;
	}
	
	return ret;
}

/* ----------------------------------------------------------------------------- */

#define SIRBUF_ALLOCSIZE 4269	/* worst case size of a wrapped IrLAP frame */

static int sirdev_alloc_buffers(struct sir_dev *dev)
{
	dev->tx_buff.truesize = SIRBUF_ALLOCSIZE;
	dev->rx_buff.truesize = IRDA_SKB_MAX_MTU; 

	/* Bootstrap ZeroCopy Rx */
	dev->rx_buff.skb = __dev_alloc_skb(dev->rx_buff.truesize, GFP_KERNEL);
	if (dev->rx_buff.skb == NULL)
		return -ENOMEM;
	skb_reserve(dev->rx_buff.skb, 1);
	dev->rx_buff.head = dev->rx_buff.skb->data;

	dev->tx_buff.head = kmalloc(dev->tx_buff.truesize, GFP_KERNEL);
	if (dev->tx_buff.head == NULL) {
		kfree_skb(dev->rx_buff.skb);
		dev->rx_buff.skb = NULL;
		dev->rx_buff.head = NULL;
		return -ENOMEM;
	}

	dev->tx_buff.data = dev->tx_buff.head;
	dev->rx_buff.data = dev->rx_buff.head;
	dev->tx_buff.len = 0;
	dev->rx_buff.len = 0;

	dev->rx_buff.in_frame = FALSE;
	dev->rx_buff.state = OUTSIDE_FRAME;
	return 0;
};

static void sirdev_free_buffers(struct sir_dev *dev)
{
	if (dev->rx_buff.skb)
		kfree_skb(dev->rx_buff.skb);
	kfree(dev->tx_buff.head);
	dev->rx_buff.head = dev->tx_buff.head = NULL;
	dev->rx_buff.skb = NULL;
}

static int sirdev_open(struct net_device *ndev)
{
	struct sir_dev *dev = ndev->priv;
	const struct sir_driver *drv = dev->drv;

	if (!drv)
		return -ENODEV;

	/* increase the reference count of the driver module before doing serious stuff */
	if (!try_module_get(drv->owner))
		return -ESTALE;

	IRDA_DEBUG(2, "%s()\n", __FUNCTION__);

	if (sirdev_alloc_buffers(dev))
		goto errout_dec;

	if (!dev->drv->start_dev  ||  dev->drv->start_dev(dev))
		goto errout_free;

	sirdev_enable_rx(dev);
	dev->raw_tx = 0;

	netif_start_queue(ndev);
	dev->irlap = irlap_open(ndev, &dev->qos, dev->hwname);
	if (!dev->irlap)
		goto errout_stop;

	netif_wake_queue(ndev);

	IRDA_DEBUG(2, "%s - done, speed = %d\n", __FUNCTION__, dev->speed);

	return 0;

errout_stop:
	atomic_set(&dev->enable_rx, 0);
	if (dev->drv->stop_dev)
		dev->drv->stop_dev(dev);
errout_free:
	sirdev_free_buffers(dev);
errout_dec:
	module_put(drv->owner);
	return -EAGAIN;
}

static int sirdev_close(struct net_device *ndev)
{
	struct sir_dev *dev = ndev->priv;
	const struct sir_driver *drv;

//	IRDA_DEBUG(0, "%s\n", __FUNCTION__);

	netif_stop_queue(ndev);

	down(&dev->fsm.sem);		/* block on pending config completion */

	atomic_set(&dev->enable_rx, 0);

	if (unlikely(!dev->irlap))
		goto out;
	irlap_close(dev->irlap);
	dev->irlap = NULL;

	drv = dev->drv;
	if (unlikely(!drv  ||  !dev->priv))
		goto out;

	if (drv->stop_dev)
		drv->stop_dev(dev);

	sirdev_free_buffers(dev);
	module_put(drv->owner);

out:
	dev->speed = 0;
	up(&dev->fsm.sem);
	return 0;
}

/* ----------------------------------------------------------------------------- */

struct sir_dev * sirdev_get_instance(const struct sir_driver *drv, const char *name)
{
	struct net_device *ndev;
	struct sir_dev *dev;

	IRDA_DEBUG(0, "%s - %s\n", __FUNCTION__, name);

	/* instead of adding tests to protect against drv->do_write==NULL
	 * at several places we refuse to create a sir_dev instance for
	 * drivers which don't implement do_write.
	 */
	if (!drv ||  !drv->do_write)
		return NULL;

	/*
	 *  Allocate new instance of the device
	 */
	ndev = alloc_irdadev(sizeof(*dev));
	if (ndev == NULL) {
		IRDA_ERROR("%s - Can't allocate memory for IrDA control block!\n", __FUNCTION__);
		goto out;
	}
	dev = ndev->priv;

	irda_init_max_qos_capabilies(&dev->qos);
	dev->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
	dev->qos.min_turn_time.bits = drv->qos_mtt_bits;
	irda_qos_bits_to_value(&dev->qos);

	strncpy(dev->hwname, name, sizeof(dev->hwname)-1);

	atomic_set(&dev->enable_rx, 0);
	dev->tx_skb = NULL;

	spin_lock_init(&dev->tx_lock);
	init_MUTEX(&dev->fsm.sem);

	INIT_LIST_HEAD(&dev->fsm.rq.lh_request);
	dev->fsm.rq.pending = 0;
	init_timer(&dev->fsm.rq.timer);

	dev->drv = drv;
	dev->netdev = ndev;

	SET_MODULE_OWNER(ndev);

	/* Override the network functions we need to use */
	ndev->hard_start_xmit = sirdev_hard_xmit;
	ndev->open = sirdev_open;
	ndev->stop = sirdev_close;
	ndev->get_stats = sirdev_get_stats;
	ndev->do_ioctl = sirdev_ioctl;

	if (register_netdev(ndev)) {
		IRDA_ERROR("%s(), register_netdev() failed!\n", __FUNCTION__);
		goto out_freenetdev;
	}

	return dev;

out_freenetdev:
	free_netdev(ndev);
out:
	return NULL;
}
EXPORT_SYMBOL(sirdev_get_instance);

int sirdev_put_instance(struct sir_dev *dev)
{
	int err = 0;

	IRDA_DEBUG(0, "%s\n", __FUNCTION__);

	atomic_set(&dev->enable_rx, 0);

	netif_carrier_off(dev->netdev);
	netif_device_detach(dev->netdev);

	if (dev->dongle_drv)
		err = sirdev_schedule_dongle_close(dev);
	if (err)
		IRDA_ERROR("%s - error %d\n", __FUNCTION__, err);

	sirdev_close(dev->netdev);

	down(&dev->fsm.sem);
	dev->fsm.state = SIRDEV_STATE_DEAD;	/* mark staled */
	dev->dongle_drv = NULL;
	dev->priv = NULL;
	up(&dev->fsm.sem);

	/* Remove netdevice */
	unregister_netdev(dev->netdev);

	free_netdev(dev->netdev);

	return 0;
}
EXPORT_SYMBOL(sirdev_put_instance);
Commit	Line	Data
1da177e4 LT	1	/*********************************************************************
	2	*
	3	* sir_dev.c: irda sir network device
	4	*
	5	* Copyright (c) 2002 Martin Diehl
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License as
	9	* published by the Free Software Foundation; either version 2 of
	10	* the License, or (at your option) any later version.
	11	*
	12	********************************************************************/
	13
	14	#include <linux/module.h>
	15	#include <linux/kernel.h>
	16	#include <linux/init.h>
	17	#include <linux/smp_lock.h>
	18	#include <linux/delay.h>
	19
	20	#include <net/irda/irda.h>
	21	#include <net/irda/wrapper.h>
	22	#include <net/irda/irda_device.h>
	23
	24	#include "sir-dev.h"
	25
	26	/***************************************************************************/
	27
	28	void sirdev_enable_rx(struct sir_dev *dev)
	29	{
	30	if (unlikely(atomic_read(&dev->enable_rx)))
	31	return;
	32
	33	/* flush rx-buffer - should also help in case of problems with echo cancelation */
	34	dev->rx_buff.data = dev->rx_buff.head;
	35	dev->rx_buff.len = 0;
	36	dev->rx_buff.in_frame = FALSE;
	37	dev->rx_buff.state = OUTSIDE_FRAME;
	38	atomic_set(&dev->enable_rx, 1);
	39	}
	40
	41	static int sirdev_is_receiving(struct sir_dev *dev)
	42	{
	43	if (!atomic_read(&dev->enable_rx))
	44	return 0;
	45
	46	return (dev->rx_buff.state != OUTSIDE_FRAME);
	47	}
	48
	49	int sirdev_set_dongle(struct sir_dev *dev, IRDA_DONGLE type)
	50	{
	51	int err;
	52
	53	IRDA_DEBUG(3, "%s : requesting dongle %d.\n", __FUNCTION__, type);
	54
	55	err = sirdev_schedule_dongle_open(dev, type);
	56	if (unlikely(err))
	57	return err;
	58	down(&dev->fsm.sem); /* block until config change completed */
	59	err = dev->fsm.result;
	60	up(&dev->fsm.sem);
	61	return err;
	62	}
214ad784	63	EXPORT_SYMBOL(sirdev_set_dongle);
1da177e4 LT	64
	65	/* used by dongle drivers for dongle programming */
	66
	67	int sirdev_raw_write(struct sir_dev dev, const char buf, int len)
	68	{
	69	unsigned long flags;
	70	int ret;
	71
	72	if (unlikely(len > dev->tx_buff.truesize))
	73	return -ENOSPC;
	74
	75	spin_lock_irqsave(&dev->tx_lock, flags); /* serialize with other tx operations */
	76	while (dev->tx_buff.len > 0) { /* wait until tx idle */
	77	spin_unlock_irqrestore(&dev->tx_lock, flags);
	78	msleep(10);
	79	spin_lock_irqsave(&dev->tx_lock, flags);
	80	}
	81
	82	dev->tx_buff.data = dev->tx_buff.head;
	83	memcpy(dev->tx_buff.data, buf, len);
	84	dev->tx_buff.len = len;
	85
	86	ret = dev->drv->do_write(dev, dev->tx_buff.data, dev->tx_buff.len);
	87	if (ret > 0) {
	88	IRDA_DEBUG(3, "%s(), raw-tx started\n", __FUNCTION__);
	89
	90	dev->tx_buff.data += ret;
	91	dev->tx_buff.len -= ret;
	92	dev->raw_tx = 1;
	93	ret = len; /* all data is going to be sent */
	94	}
	95	spin_unlock_irqrestore(&dev->tx_lock, flags);
	96	return ret;
	97	}
214ad784	98	EXPORT_SYMBOL(sirdev_raw_write);
1da177e4 LT	99
	100	/* seems some dongle drivers may need this */
	101
	102	int sirdev_raw_read(struct sir_dev dev, char buf, int len)
	103	{
	104	int count;
	105
	106	if (atomic_read(&dev->enable_rx))
	107	return -EIO; /* fail if we expect irda-frames */
	108
	109	count = (len < dev->rx_buff.len) ? len : dev->rx_buff.len;
	110
	111	if (count > 0) {
	112	memcpy(buf, dev->rx_buff.data, count);
	113	dev->rx_buff.data += count;
	114	dev->rx_buff.len -= count;
	115	}
	116
	117	/* remaining stuff gets flushed when re-enabling normal rx */
	118
	119	return count;
	120	}
214ad784	121	EXPORT_SYMBOL(sirdev_raw_read);
1da177e4 LT	122
	123	int sirdev_set_dtr_rts(struct sir_dev *dev, int dtr, int rts)
	124	{
	125	int ret = -ENXIO;
	126	if (dev->drv->set_dtr_rts != 0)
	127	ret = dev->drv->set_dtr_rts(dev, dtr, rts);
	128	return ret;
	129	}
214ad784 AB	130	EXPORT_SYMBOL(sirdev_set_dtr_rts);
214ad784 AB	131
1da177e4 LT	132	/**********************************************************************/
	133
	134	/* called from client driver - likely with bh-context - to indicate
	135	* it made some progress with transmission. Hence we send the next
	136	* chunk, if any, or complete the skb otherwise
	137	*/
	138
	139	void sirdev_write_complete(struct sir_dev *dev)
	140	{
	141	unsigned long flags;
	142	struct sk_buff *skb;
	143	int actual = 0;
	144	int err;
	145
	146	spin_lock_irqsave(&dev->tx_lock, flags);
	147
	148	IRDA_DEBUG(3, "%s() - dev->tx_buff.len = %d\n",
	149	__FUNCTION__, dev->tx_buff.len);
	150
	151	if (likely(dev->tx_buff.len > 0)) {
	152	/* Write data left in transmit buffer */
	153	actual = dev->drv->do_write(dev, dev->tx_buff.data, dev->tx_buff.len);
	154
	155	if (likely(actual>0)) {
	156	dev->tx_buff.data += actual;
	157	dev->tx_buff.len -= actual;
	158	}
	159	else if (unlikely(actual<0)) {
	160	/* could be dropped later when we have tx_timeout to recover */
	161	IRDA_ERROR("%s: drv->do_write failed (%d)\n",
	162	__FUNCTION__, actual);
	163	if ((skb=dev->tx_skb) != NULL) {
	164	dev->tx_skb = NULL;
	165	dev_kfree_skb_any(skb);
	166	dev->stats.tx_errors++;
	167	dev->stats.tx_dropped++;
	168	}
	169	dev->tx_buff.len = 0;
	170	}
	171	if (dev->tx_buff.len > 0)
	172	goto done; /* more data to send later */
	173	}
	174
	175	if (unlikely(dev->raw_tx != 0)) {
	176	/* in raw mode we are just done now after the buffer was sent
	177	* completely. Since this was requested by some dongle driver
	178	* running under the control of the irda-thread we must take
	179	* care here not to re-enable the queue. The queue will be
	180	* restarted when the irda-thread has completed the request.
	181	*/
	182
	183	IRDA_DEBUG(3, "%s(), raw-tx done\n", __FUNCTION__);
	184	dev->raw_tx = 0;
	185	goto done; /* no post-frame handling in raw mode */
	186	}
	187
	188	/* we have finished now sending this skb.
	189	* update statistics and free the skb.
	190	* finally we check and trigger a pending speed change, if any.
	191	* if not we switch to rx mode and wake the queue for further
	192	* packets.
	193	* note the scheduled speed request blocks until the lower
	194	* client driver and the corresponding hardware has really
	195	* finished sending all data (xmit fifo drained f.e.)
196	* before the speed change gets finally done and the queue
197	* re-activated.
198	*/
199
200	IRDA_DEBUG(5, "%s(), finished with frame!\n", __FUNCTION__);
201
202	if ((skb=dev->tx_skb) != NULL) {
203	dev->tx_skb = NULL;
204	dev->stats.tx_packets++;
205	dev->stats.tx_bytes += skb->len;
206	dev_kfree_skb_any(skb);
207	}
208
209	if (unlikely(dev->new_speed > 0)) {
210	IRDA_DEBUG(5, "%s(), Changing speed!\n", __FUNCTION__);
211	err = sirdev_schedule_speed(dev, dev->new_speed);
212	if (unlikely(err)) {
213	/* should never happen
214	* forget the speed change and hope the stack recovers
215	*/
216	IRDA_ERROR("%s - schedule speed change failed: %d\n",
217	__FUNCTION__, err);
218	netif_wake_queue(dev->netdev);
219	}
220	/* else: success
221	* speed change in progress now
222	* on completion dev->new_speed gets cleared,
223	* rx-reenabled and the queue restarted
224	*/
225	}
226	else {
227	sirdev_enable_rx(dev);
228	netif_wake_queue(dev->netdev);
229	}
230
231	done:
232	spin_unlock_irqrestore(&dev->tx_lock, flags);
233	}
214ad784	234	EXPORT_SYMBOL(sirdev_write_complete);
1da177e4 LT	235
	236	/* called from client driver - likely with bh-context - to give us
	237	* some more received bytes. We put them into the rx-buffer,
	238	* normally unwrapping and building LAP-skb's (unless rx disabled)
	239	*/
	240
	241	int sirdev_receive(struct sir_dev dev, const unsigned char cp, size_t count)
	242	{
	243	if (!dev \|\| !dev->netdev) {
	244	IRDA_WARNING("%s(), not ready yet!\n", __FUNCTION__);
	245	return -1;
	246	}
	247
	248	if (!dev->irlap) {
	249	IRDA_WARNING("%s - too early: %p / %zd!\n",
	250	__FUNCTION__, cp, count);
	251	return -1;
	252	}
	253
	254	if (cp==NULL) {
	255	/* error already at lower level receive
	256	* just update stats and set media busy
	257	*/
	258	irda_device_set_media_busy(dev->netdev, TRUE);
	259	dev->stats.rx_dropped++;
	260	IRDA_DEBUG(0, "%s; rx-drop: %zd\n", __FUNCTION__, count);
	261	return 0;
	262	}
	263
	264	/* Read the characters into the buffer */
	265	if (likely(atomic_read(&dev->enable_rx))) {
	266	while (count--)
	267	/* Unwrap and destuff one byte */
	268	async_unwrap_char(dev->netdev, &dev->stats,
	269	&dev->rx_buff, *cp++);
	270	} else {
	271	while (count--) {
	272	/* rx not enabled: save the raw bytes and never
	273	* trigger any netif_rx. The received bytes are flushed
	274	* later when we re-enable rx but might be read meanwhile
	275	* by the dongle driver.
	276	*/
	277	dev->rx_buff.data[dev->rx_buff.len++] = *cp++;
	278
	279	/* What should we do when the buffer is full? */
	280	if (unlikely(dev->rx_buff.len == dev->rx_buff.truesize))
	281	dev->rx_buff.len = 0;
	282	}
	283	}
	284
	285	return 0;
	286	}
214ad784	287	EXPORT_SYMBOL(sirdev_receive);
1da177e4 LT	288
	289	/**********************************************************************/
	290
	291	/* callbacks from network layer */
	292
	293	static struct net_device_stats sirdev_get_stats(struct net_device ndev)
	294	{
	295	struct sir_dev *dev = ndev->priv;
	296
	297	return (dev) ? &dev->stats : NULL;
	298	}
	299
	300	static int sirdev_hard_xmit(struct sk_buff skb, struct net_device ndev)
	301	{
	302	struct sir_dev *dev = ndev->priv;
	303	unsigned long flags;
	304	int actual = 0;
	305	int err;
	306	s32 speed;
	307
	308	IRDA_ASSERT(dev != NULL, return 0;);
	309
	310	netif_stop_queue(ndev);
	311
	312	IRDA_DEBUG(3, "%s(), skb->len = %d\n", __FUNCTION__, skb->len);
	313
	314	speed = irda_get_next_speed(skb);
	315	if ((speed != dev->speed) && (speed != -1)) {
	316	if (!skb->len) {
	317	err = sirdev_schedule_speed(dev, speed);
	318	if (unlikely(err == -EWOULDBLOCK)) {
	319	/* Failed to initiate the speed change, likely the fsm
	320	* is still busy (pretty unlikely, but...)
	321	* We refuse to accept the skb and return with the queue
	322	* stopped so the network layer will retry after the
	323	* fsm completes and wakes the queue.
	324	*/
	325	return 1;
	326	}
	327	else if (unlikely(err)) {
	328	/* other fatal error - forget the speed change and
	329	* hope the stack will recover somehow
	330	*/
	331	netif_start_queue(ndev);
	332	}
	333	/* else: success
	334	* speed change in progress now
	335	* on completion the queue gets restarted
	336	*/
	337
	338	dev_kfree_skb_any(skb);
	339	return 0;
	340	} else
	341	dev->new_speed = speed;
	342	}
	343
	344	/* Init tx buffer*/
	345	dev->tx_buff.data = dev->tx_buff.head;
	346
	347	/* Check problems */
	348	if(spin_is_locked(&dev->tx_lock)) {
	349	IRDA_DEBUG(3, "%s(), write not completed\n", __FUNCTION__);
	350	}
	351
352	/* serialize with write completion */
353	spin_lock_irqsave(&dev->tx_lock, flags);
354
355	/* Copy skb to tx_buff while wrapping, stuffing and making CRC */
356	dev->tx_buff.len = async_wrap_skb(skb, dev->tx_buff.data, dev->tx_buff.truesize);
357
358	/* transmission will start now - disable receive.
359	* if we are just in the middle of an incoming frame,
360	* treat it as collision. probably it's a good idea to
361	* reset the rx_buf OUTSIDE_FRAME in this case too?
362	*/
363	atomic_set(&dev->enable_rx, 0);
364	if (unlikely(sirdev_is_receiving(dev)))
365	dev->stats.collisions++;
366
367	actual = dev->drv->do_write(dev, dev->tx_buff.data, dev->tx_buff.len);
368
369	if (likely(actual > 0)) {
370	dev->tx_skb = skb;
371	ndev->trans_start = jiffies;
372	dev->tx_buff.data += actual;
373	dev->tx_buff.len -= actual;
374	}
375	else if (unlikely(actual < 0)) {
376	/* could be dropped later when we have tx_timeout to recover */
377	IRDA_ERROR("%s: drv->do_write failed (%d)\n",
378	__FUNCTION__, actual);
379	dev_kfree_skb_any(skb);
380	dev->stats.tx_errors++;
381	dev->stats.tx_dropped++;
382	netif_wake_queue(ndev);
383	}
384	spin_unlock_irqrestore(&dev->tx_lock, flags);
385
386	return 0;
387	}
388
389	/* called from network layer with rtnl hold */
390
391	static int sirdev_ioctl(struct net_device ndev, struct ifreq rq, int cmd)
392	{
393	struct if_irda_req irq = (struct if_irda_req ) rq;
394	struct sir_dev *dev = ndev->priv;
395	int ret = 0;
396
397	IRDA_ASSERT(dev != NULL, return -1;);
398
399	IRDA_DEBUG(3, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__, ndev->name, cmd);
400
401	switch (cmd) {
402	case SIOCSBANDWIDTH: /* Set bandwidth */
403	if (!capable(CAP_NET_ADMIN))
404	ret = -EPERM;
405	else
406	ret = sirdev_schedule_speed(dev, irq->ifr_baudrate);
407	/* cannot sleep here for completion
408	* we are called from network layer with rtnl hold
409	*/
410	break;
411
412	case SIOCSDONGLE: /* Set dongle */
413	if (!capable(CAP_NET_ADMIN))
414	ret = -EPERM;
415	else
416	ret = sirdev_schedule_dongle_open(dev, irq->ifr_dongle);
417	/* cannot sleep here for completion
418	* we are called from network layer with rtnl hold
419	*/
420	break;
421
422	case SIOCSMEDIABUSY: /* Set media busy */
423	if (!capable(CAP_NET_ADMIN))
424	ret = -EPERM;
425	else
426	irda_device_set_media_busy(dev->netdev, TRUE);
427	break;
428
429	case SIOCGRECEIVING: /* Check if we are receiving right now */
430	irq->ifr_receiving = sirdev_is_receiving(dev);
431	break;
432
433	case SIOCSDTRRTS:
434	if (!capable(CAP_NET_ADMIN))
435	ret = -EPERM;
436	else
437	ret = sirdev_schedule_dtr_rts(dev, irq->ifr_dtr, irq->ifr_rts);
438	/* cannot sleep here for completion
439	* we are called from network layer with rtnl hold
440	*/
441	break;
442
443	case SIOCSMODE:
444	#if 0
445	if (!capable(CAP_NET_ADMIN))
446	ret = -EPERM;
447	else
448	ret = sirdev_schedule_mode(dev, irq->ifr_mode);
449	/* cannot sleep here for completion
450	* we are called from network layer with rtnl hold
451	*/
452	break;
453	#endif
454	default:
455	ret = -EOPNOTSUPP;
456	}
457
458	return ret;
459	}
460
461	/* ----------------------------------------------------------------------------- */
462
463	#define SIRBUF_ALLOCSIZE 4269 /* worst case size of a wrapped IrLAP frame */
464
465	static int sirdev_alloc_buffers(struct sir_dev *dev)
466	{
467	dev->tx_buff.truesize = SIRBUF_ALLOCSIZE;
468	dev->rx_buff.truesize = IRDA_SKB_MAX_MTU;
469
470	/* Bootstrap ZeroCopy Rx */
471	dev->rx_buff.skb = __dev_alloc_skb(dev->rx_buff.truesize, GFP_KERNEL);
472	if (dev->rx_buff.skb == NULL)
473	return -ENOMEM;
474	skb_reserve(dev->rx_buff.skb, 1);
475	dev->rx_buff.head = dev->rx_buff.skb->data;
476
477	dev->tx_buff.head = kmalloc(dev->tx_buff.truesize, GFP_KERNEL);
478	if (dev->tx_buff.head == NULL) {
479	kfree_skb(dev->rx_buff.skb);
480	dev->rx_buff.skb = NULL;
481	dev->rx_buff.head = NULL;
482	return -ENOMEM;
483	}
484
485	dev->tx_buff.data = dev->tx_buff.head;
486	dev->rx_buff.data = dev->rx_buff.head;
487	dev->tx_buff.len = 0;
488	dev->rx_buff.len = 0;
489
490	dev->rx_buff.in_frame = FALSE;
491	dev->rx_buff.state = OUTSIDE_FRAME;
492	return 0;
493	};
494
495	static void sirdev_free_buffers(struct sir_dev *dev)
496	{
497	if (dev->rx_buff.skb)
498	kfree_skb(dev->rx_buff.skb);
b4558ea9	499	kfree(dev->tx_buff.head);
1da177e4 LT	500	dev->rx_buff.head = dev->tx_buff.head = NULL;
	501	dev->rx_buff.skb = NULL;
	502	}
	503
	504	static int sirdev_open(struct net_device *ndev)
	505	{
	506	struct sir_dev *dev = ndev->priv;
	507	const struct sir_driver *drv = dev->drv;
	508
	509	if (!drv)
	510	return -ENODEV;
	511
	512	/* increase the reference count of the driver module before doing serious stuff */
	513	if (!try_module_get(drv->owner))
	514	return -ESTALE;
	515
	516	IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
	517
	518	if (sirdev_alloc_buffers(dev))
	519	goto errout_dec;
	520
	521	if (!dev->drv->start_dev \|\| dev->drv->start_dev(dev))
	522	goto errout_free;
	523
	524	sirdev_enable_rx(dev);
	525	dev->raw_tx = 0;
	526
	527	netif_start_queue(ndev);
	528	dev->irlap = irlap_open(ndev, &dev->qos, dev->hwname);
	529	if (!dev->irlap)
	530	goto errout_stop;
	531
	532	netif_wake_queue(ndev);
	533
	534	IRDA_DEBUG(2, "%s - done, speed = %d\n", __FUNCTION__, dev->speed);
	535
	536	return 0;
	537
	538	errout_stop:
	539	atomic_set(&dev->enable_rx, 0);
	540	if (dev->drv->stop_dev)
	541	dev->drv->stop_dev(dev);
	542	errout_free:
	543	sirdev_free_buffers(dev);
	544	errout_dec:
	545	module_put(drv->owner);
	546	return -EAGAIN;
	547	}
	548
	549	static int sirdev_close(struct net_device *ndev)
	550	{
	551	struct sir_dev *dev = ndev->priv;
	552	const struct sir_driver *drv;
	553
	554	// IRDA_DEBUG(0, "%s\n", __FUNCTION__);
	555
	556	netif_stop_queue(ndev);
	557
	558	down(&dev->fsm.sem); /* block on pending config completion */
	559
	560	atomic_set(&dev->enable_rx, 0);
	561
	562	if (unlikely(!dev->irlap))
	563	goto out;
564	irlap_close(dev->irlap);
565	dev->irlap = NULL;
566
567	drv = dev->drv;
568	if (unlikely(!drv \|\| !dev->priv))
569	goto out;
570
571	if (drv->stop_dev)
572	drv->stop_dev(dev);
573
574	sirdev_free_buffers(dev);
575	module_put(drv->owner);
576
577	out:
578	dev->speed = 0;
579	up(&dev->fsm.sem);
580	return 0;
581	}
582
583	/* ----------------------------------------------------------------------------- */
584
585	struct sir_dev * sirdev_get_instance(const struct sir_driver drv, const char name)
586	{
587	struct net_device *ndev;
588	struct sir_dev *dev;
589
590	IRDA_DEBUG(0, "%s - %s\n", __FUNCTION__, name);
591
592	/* instead of adding tests to protect against drv->do_write==NULL
593	* at several places we refuse to create a sir_dev instance for
594	* drivers which don't implement do_write.
595	*/
596	if (!drv \|\| !drv->do_write)
597	return NULL;
598
599	/*
600	* Allocate new instance of the device
601	*/
602	ndev = alloc_irdadev(sizeof(*dev));
603	if (ndev == NULL) {
604	IRDA_ERROR("%s - Can't allocate memory for IrDA control block!\n", __FUNCTION__);
605	goto out;
606	}
607	dev = ndev->priv;
608
609	irda_init_max_qos_capabilies(&dev->qos);
610	dev->qos.baud_rate.bits = IR_9600\|IR_19200\|IR_38400\|IR_57600\|IR_115200;
611	dev->qos.min_turn_time.bits = drv->qos_mtt_bits;
612	irda_qos_bits_to_value(&dev->qos);
613
614	strncpy(dev->hwname, name, sizeof(dev->hwname)-1);
615
616	atomic_set(&dev->enable_rx, 0);
617	dev->tx_skb = NULL;
618
619	spin_lock_init(&dev->tx_lock);
620	init_MUTEX(&dev->fsm.sem);
621
622	INIT_LIST_HEAD(&dev->fsm.rq.lh_request);
623	dev->fsm.rq.pending = 0;
624	init_timer(&dev->fsm.rq.timer);
625
626	dev->drv = drv;
627	dev->netdev = ndev;
628
629	SET_MODULE_OWNER(ndev);
630
631	/* Override the network functions we need to use */
632	ndev->hard_start_xmit = sirdev_hard_xmit;
633	ndev->open = sirdev_open;
634	ndev->stop = sirdev_close;
635	ndev->get_stats = sirdev_get_stats;
636	ndev->do_ioctl = sirdev_ioctl;
637
638	if (register_netdev(ndev)) {
639	IRDA_ERROR("%s(), register_netdev() failed!\n", __FUNCTION__);
640	goto out_freenetdev;
641	}
642
643	return dev;
644
645	out_freenetdev:
646	free_netdev(ndev);
647	out:
648	return NULL;
649	}
214ad784	650	EXPORT_SYMBOL(sirdev_get_instance);
1da177e4 LT	651
	652	int sirdev_put_instance(struct sir_dev *dev)
	653	{
	654	int err = 0;
	655
	656	IRDA_DEBUG(0, "%s\n", __FUNCTION__);
	657
	658	atomic_set(&dev->enable_rx, 0);
	659
	660	netif_carrier_off(dev->netdev);
	661	netif_device_detach(dev->netdev);
	662
	663	if (dev->dongle_drv)
	664	err = sirdev_schedule_dongle_close(dev);
	665	if (err)
	666	IRDA_ERROR("%s - error %d\n", __FUNCTION__, err);
	667
	668	sirdev_close(dev->netdev);
	669
	670	down(&dev->fsm.sem);
	671	dev->fsm.state = SIRDEV_STATE_DEAD; /* mark staled */
	672	dev->dongle_drv = NULL;
	673	dev->priv = NULL;
	674	up(&dev->fsm.sem);
	675
	676	/* Remove netdevice */
	677	unregister_netdev(dev->netdev);
	678
	679	free_netdev(dev->netdev);
	680
	681	return 0;
	682	}
214ad784	683	EXPORT_SYMBOL(sirdev_put_instance);
1da177e4	684