Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6

1. Introduction

Linux distinguishes between administrative and operational state of an

interface. Admininstrative state is the result of "ip link set dev

<dev> up or down" and reflects whether the administrator wants to use

the device for traffic.

However, an interface is not usable just because the admin enabled it

- ethernet requires to be plugged into the switch and, depending on

a site's networking policy and configuration, an 802.1X authentication

to be performed before user data can be transferred. Operational state

shows the ability of an interface to transmit this user data.

Thanks to 802.1X, userspace must be granted the possibility to

influence operational state. To accommodate this, operational state is

split into two parts: Two flags that can be set by the driver only, and

a RFC2863 compatible state that is derived from these flags, a policy,

and changeable from userspace under certain rules.

2. Querying from userspace

Both admin and operational state can be queried via the netlink

operation RTM_GETLINK. It is also possible to subscribe to RTMGRP_LINK

to be notified of updates. This is important for setting from userspace.

These values contain interface state:

ifinfomsg::if_flags & IFF_UP:

 Interface is admin up

ifinfomsg::if_flags & IFF_RUNNING:

 Interface is in RFC2863 operational state UP or UNKNOWN. This is for

 backward compatibility, routing daemons, dhcp clients can use this

 flag to determine whether they should use the interface.

ifinfomsg::if_flags & IFF_LOWER_UP:

 Driver has signaled netif_carrier_on()

ifinfomsg::if_flags & IFF_DORMANT:

 Driver has signaled netif_dormant_on()

These interface flags can also be queried without netlink using the

SIOCGIFFLAGS ioctl.

TLV IFLA_OPERSTATE

contains RFC2863 state of the interface in numeric representation:

IF_OPER_UNKNOWN (0):

 Interface is in unknown state, neither driver nor userspace has set

 operational state. Interface must be considered for user data as

 setting operational state has not been implemented in every driver.

IF_OPER_NOTPRESENT (1):

 Unused in current kernel (notpresent interfaces normally disappear),

 just a numerical placeholder.

IF_OPER_DOWN (2):

 Interface is unable to transfer data on L1, f.e. ethernet is not

 plugged or interface is ADMIN down.

IF_OPER_LOWERLAYERDOWN (3):

 Interfaces stacked on an interface that is IF_OPER_DOWN show this

 state (f.e. VLAN).

IF_OPER_TESTING (4):

 Unused in current kernel.

IF_OPER_DORMANT (5):

 Interface is L1 up, but waiting for an external event, f.e. for a

 protocol to establish. (802.1X)

IF_OPER_UP (6):

 Interface is operational up and can be used.

This TLV can also be queried via sysfs.

TLV IFLA_LINKMODE

contains link policy. This is needed for userspace interaction

described below.

This TLV can also be queried via sysfs.

3. Kernel driver API

Kernel drivers have access to two flags that map to IFF_LOWER_UP and

IFF_DORMANT. These flags can be set from everywhere, even from

interrupts. It is guaranteed that only the driver has write access,

however, if different layers of the driver manipulate the same flag,

the driver has to provide the synchronisation needed.

__LINK_STATE_NOCARRIER, maps to !IFF_LOWER_UP:

The driver uses netif_carrier_on() to clear and netif_carrier_off() to

set this flag. On netif_carrier_off(), the scheduler stops sending

packets. The name 'carrier' and the inversion are historical, think of

it as lower layer.

netif_carrier_ok() can be used to query that bit.

__LINK_STATE_DORMANT, maps to IFF_DORMANT:

Set by the driver to express that the device cannot yet be used

because some driver controlled protocol establishment has to

complete. Corresponding functions are netif_dormant_on() to set the

flag, netif_dormant_off() to clear it and netif_dormant() to query.

On device allocation, networking core sets the flags equivalent to

netif_carrier_ok() and !netif_dormant().

Whenever the driver CHANGES one of these flags, a workqueue event is

scheduled to translate the flag combination to IFLA_OPERSTATE as

follows:

!netif_carrier_ok():

 IF_OPER_LOWERLAYERDOWN if the interface is stacked, IF_OPER_DOWN

 otherwise. Kernel can recognise stacked interfaces because their

 ifindex != iflink.

netif_carrier_ok() && netif_dormant():

 IF_OPER_DORMANT

netif_carrier_ok() && !netif_dormant():

 IF_OPER_UP if userspace interaction is disabled. Otherwise

 IF_OPER_DORMANT with the possibility for userspace to initiate the

 IF_OPER_UP transition afterwards.

4. Setting from userspace

Applications have to use the netlink interface to influence the

RFC2863 operational state of an interface. Setting IFLA_LINKMODE to 1

via RTM_SETLINK instructs the kernel that an interface should go to

IF_OPER_DORMANT instead of IF_OPER_UP when the combination

netif_carrier_ok() && !netif_dormant() is set by the

driver. Afterwards, the userspace application can set IFLA_OPERSTATE

to IF_OPER_DORMANT or IF_OPER_UP as long as the driver does not set

netif_carrier_off() or netif_dormant_on(). Changes made by userspace

are multicasted on the netlink group RTMGRP_LINK.

So basically a 802.1X supplicant interacts with the kernel like this:

-subscribe to RTMGRP_LINK

-set IFLA_LINKMODE to 1 via RTM_SETLINK

-query RTM_GETLINK once to get initial state

-if initial flags are not (IFF_LOWER_UP && !IFF_DORMANT), wait until

 netlink multicast signals this state

-do 802.1X, eventually abort if flags go down again

-send RTM_SETLINK to set operstate to IF_OPER_UP if authentication

 succeeds, IF_OPER_DORMANT otherwise

-see how operstate and IFF_RUNNING is echoed via netlink multicast

-set interface back to IF_OPER_DORMANT if 802.1X reauthentication

 fails

-restart if kernel changes IFF_LOWER_UP or IFF_DORMANT flag

if supplicant goes down, bring back IFLA_LINKMODE to 0 and

IFLA_OPERSTATE to a sane value.

A routing daemon or dhcp client just needs to care for IFF_RUNNING or

waiting for operstate to go IF_OPER_UP/IF_OPER_UNKNOWN before

considering the interface / querying a DHCP address.

For technical questions and/or comments please e-mail to Stefan Rompf

(stefan at loplof.de).

S:	Maintained

IRDA SUBSYSTEM

P:	Jean Tourrilhes

P:	Samuel Ortiz

M:	samuel@sortiz.org

L:	irda-users@lists.sourceforge.net (subscribers-only)

W:	http://irda.sourceforge.net/

S:	Odd Fixes

S:	Maintained

ISAPNP

P:	Jaroslav Kysela

obj-$(CONFIG_TOIM3232_DONGLE)	+= toim3232-sir.o

# The SIR helper module

sir-dev-objs := sir_dev.o sir_dongle.o sir_kthread.o

sir-dev-objs := sir_dev.o sir_dongle.o

#define IRDA_SIR_H

#include <linux/netdevice.h>

#include <linux/workqueue.h>

#include <net/irda/irda.h>

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

/* FIXME: unify irda_request with sir_fsm! */

struct irda_request {

	struct list_head lh_request;

	unsigned long pending;

	void (*func)(void *);

	void *data;

	struct timer_list timer;

};

struct sir_fsm {

	struct semaphore	sem;

	struct irda_request	rq;

	struct work_struct      work;

	unsigned		state, substate;

	int			param;

	int			result;

#include "sir-dev.h"

static struct workqueue_struct *irda_sir_wq;

/* STATE MACHINE */

/* substate handler of the config-fsm to handle the cases where we want

 * to wait for transmit completion before changing the port configuration

 */

static int sirdev_tx_complete_fsm(struct sir_dev *dev)

{

	struct sir_fsm *fsm = &dev->fsm;

	unsigned next_state, delay;

	unsigned bytes_left;

	do {

		next_state = fsm->substate;	/* default: stay in current substate */

		delay = 0;

		switch(fsm->substate) {

		case SIRDEV_STATE_WAIT_XMIT:

			if (dev->drv->chars_in_buffer)

				bytes_left = dev->drv->chars_in_buffer(dev);

			else

				bytes_left = 0;

			if (!bytes_left) {

				next_state = SIRDEV_STATE_WAIT_UNTIL_SENT;

				break;

			}

			if (dev->speed > 115200)

				delay = (bytes_left*8*10000) / (dev->speed/100);

			else if (dev->speed > 0)

				delay = (bytes_left*10*10000) / (dev->speed/100);

			else

				delay = 0;

			/* expected delay (usec) until remaining bytes are sent */

			if (delay < 100) {

				udelay(delay);

				delay = 0;

				break;

			}

			/* sleep some longer delay (msec) */

			delay = (delay+999) / 1000;

			break;

		case SIRDEV_STATE_WAIT_UNTIL_SENT:

			/* block until underlaying hardware buffer are empty */

			if (dev->drv->wait_until_sent)

				dev->drv->wait_until_sent(dev);

			next_state = SIRDEV_STATE_TX_DONE;

			break;

		case SIRDEV_STATE_TX_DONE:

			return 0;

		default:

			IRDA_ERROR("%s - undefined state\n", __FUNCTION__);

			return -EINVAL;

		}

		fsm->substate = next_state;

	} while (delay == 0);

	return delay;

}

/*

 * Function sirdev_config_fsm

 *

 * State machine to handle the configuration of the device (and attached dongle, if any).

 * This handler is scheduled for execution in kIrDAd context, so we can sleep.

 * however, kIrDAd is shared by all sir_dev devices so we better don't sleep there too

 * long. Instead, for longer delays we start a timer to reschedule us later.

 * On entry, fsm->sem is always locked and the netdev xmit queue stopped.

 * Both must be unlocked/restarted on completion - but only on final exit.

 */

static void sirdev_config_fsm(void *data)

{

	struct sir_dev *dev = data;

	struct sir_fsm *fsm = &dev->fsm;

	int next_state;

	int ret = -1;

	unsigned delay;

	IRDA_DEBUG(2, "%s(), <%ld>\n", __FUNCTION__, jiffies);

	do {

		IRDA_DEBUG(3, "%s - state=0x%04x / substate=0x%04x\n",

			__FUNCTION__, fsm->state, fsm->substate);

		next_state = fsm->state;

		delay = 0;

		switch(fsm->state) {

		case SIRDEV_STATE_DONGLE_OPEN:

			if (dev->dongle_drv != NULL) {

				ret = sirdev_put_dongle(dev);

				if (ret) {

					fsm->result = -EINVAL;

					next_state = SIRDEV_STATE_ERROR;

					break;

				}

			}

			/* Initialize dongle */

			ret = sirdev_get_dongle(dev, fsm->param);

			if (ret) {

				fsm->result = ret;

				next_state = SIRDEV_STATE_ERROR;

				break;

			}

			/* Dongles are powered through the modem control lines which

			 * were just set during open. Before resetting, let's wait for

			 * the power to stabilize. This is what some dongle drivers did

			 * in open before, while others didn't - should be safe anyway.

			 */

			delay = 50;

			fsm->substate = SIRDEV_STATE_DONGLE_RESET;

			next_state = SIRDEV_STATE_DONGLE_RESET;

			fsm->param = 9600;

			break;

		case SIRDEV_STATE_DONGLE_CLOSE:

			/* shouldn't we just treat this as success=? */

			if (dev->dongle_drv == NULL) {

				fsm->result = -EINVAL;

				next_state = SIRDEV_STATE_ERROR;

				break;

			}

			ret = sirdev_put_dongle(dev);

			if (ret) {

				fsm->result = ret;

				next_state = SIRDEV_STATE_ERROR;

				break;

			}

			next_state = SIRDEV_STATE_DONE;

			break;

		case SIRDEV_STATE_SET_DTR_RTS:

			ret = sirdev_set_dtr_rts(dev,

				(fsm->param&0x02) ? TRUE : FALSE,

				(fsm->param&0x01) ? TRUE : FALSE);

			next_state = SIRDEV_STATE_DONE;

			break;

		case SIRDEV_STATE_SET_SPEED:

			fsm->substate = SIRDEV_STATE_WAIT_XMIT;

			next_state = SIRDEV_STATE_DONGLE_CHECK;

			break;

		case SIRDEV_STATE_DONGLE_CHECK:

			ret = sirdev_tx_complete_fsm(dev);

			if (ret < 0) {

				fsm->result = ret;

				next_state = SIRDEV_STATE_ERROR;

				break;

			}

			if ((delay=ret) != 0)

				break;

			if (dev->dongle_drv) {

				fsm->substate = SIRDEV_STATE_DONGLE_RESET;

				next_state = SIRDEV_STATE_DONGLE_RESET;

			}

			else {

				dev->speed = fsm->param;

				next_state = SIRDEV_STATE_PORT_SPEED;

			}

			break;

		case SIRDEV_STATE_DONGLE_RESET:

			if (dev->dongle_drv->reset) {

				ret = dev->dongle_drv->reset(dev);

				if (ret < 0) {

					fsm->result = ret;

					next_state = SIRDEV_STATE_ERROR;

					break;

				}

			}

			else

				ret = 0;

			if ((delay=ret) == 0) {

				/* set serial port according to dongle default speed */

				if (dev->drv->set_speed)

					dev->drv->set_speed(dev, dev->speed);

				fsm->substate = SIRDEV_STATE_DONGLE_SPEED;

				next_state = SIRDEV_STATE_DONGLE_SPEED;

			}

			break;

		case SIRDEV_STATE_DONGLE_SPEED:

			if (dev->dongle_drv->reset) {

				ret = dev->dongle_drv->set_speed(dev, fsm->param);

				if (ret < 0) {

					fsm->result = ret;

					next_state = SIRDEV_STATE_ERROR;

					break;

				}

			}

			else

				ret = 0;

			if ((delay=ret) == 0)

				next_state = SIRDEV_STATE_PORT_SPEED;

			break;

		case SIRDEV_STATE_PORT_SPEED:

			/* Finally we are ready to change the serial port speed */

			if (dev->drv->set_speed)

				dev->drv->set_speed(dev, dev->speed);

			dev->new_speed = 0;

			next_state = SIRDEV_STATE_DONE;

			break;

		case SIRDEV_STATE_DONE:

			/* Signal network layer so it can send more frames */

			netif_wake_queue(dev->netdev);

			next_state = SIRDEV_STATE_COMPLETE;

			break;

		default:

			IRDA_ERROR("%s - undefined state\n", __FUNCTION__);

			fsm->result = -EINVAL;

			/* fall thru */

		case SIRDEV_STATE_ERROR:

			IRDA_ERROR("%s - error: %d\n", __FUNCTION__, fsm->result);

#if 0	/* don't enable this before we have netdev->tx_timeout to recover */

			netif_stop_queue(dev->netdev);

#else

			netif_wake_queue(dev->netdev);

#endif

			/* fall thru */

		case SIRDEV_STATE_COMPLETE:

			/* config change finished, so we are not busy any longer */

			sirdev_enable_rx(dev);

			up(&fsm->sem);

			return;

		}

		fsm->state = next_state;

	} while(!delay);

	queue_delayed_work(irda_sir_wq, &fsm->work, msecs_to_jiffies(delay));

}

/* schedule some device configuration task for execution by kIrDAd

 * on behalf of the above state machine.

 * can be called from process or interrupt/tasklet context.

 */

int sirdev_schedule_request(struct sir_dev *dev, int initial_state, unsigned param)

{

	struct sir_fsm *fsm = &dev->fsm;

	IRDA_DEBUG(2, "%s - state=0x%04x / param=%u\n", __FUNCTION__, initial_state, param);

	if (down_trylock(&fsm->sem)) {

		if (in_interrupt()  ||  in_atomic()  ||  irqs_disabled()) {

			IRDA_DEBUG(1, "%s(), state machine busy!\n", __FUNCTION__);

			return -EWOULDBLOCK;

		} else

			down(&fsm->sem);

	}

	if (fsm->state == SIRDEV_STATE_DEAD) {

		/* race with sirdev_close should never happen */

		IRDA_ERROR("%s(), instance staled!\n", __FUNCTION__);

		up(&fsm->sem);

		return -ESTALE;		/* or better EPIPE? */

	}

	netif_stop_queue(dev->netdev);

	atomic_set(&dev->enable_rx, 0);

	fsm->state = initial_state;

	fsm->param = param;

	fsm->result = 0;

	INIT_WORK(&fsm->work, sirdev_config_fsm, dev);

	queue_work(irda_sir_wq, &fsm->work);

	return 0;

}

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

void sirdev_enable_rx(struct sir_dev *dev)

	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;

}

EXPORT_SYMBOL(sirdev_put_instance);

static int __init sir_wq_init(void)

{

	irda_sir_wq = create_singlethread_workqueue("irda_sir_wq");

	if (!irda_sir_wq)

		return -ENOMEM;

	return 0;

}

static void __exit sir_wq_exit(void)

{

	destroy_workqueue(irda_sir_wq);

}

module_init(sir_wq_init);

module_exit(sir_wq_exit);

MODULE_AUTHOR("Martin Diehl <info@mdiehl.de>");

MODULE_DESCRIPTION("IrDA SIR core");

MODULE_LICENSE("GPL");