sched: s/sched_latency/sched_min_granularity

[usb.git] / net / irda / irlmp_event.c

/*********************************************************************
 *
 * Filename:      irlmp_event.c
 * Version:       0.8
 * Description:   An IrDA LMP event driver for Linux
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Mon Aug  4 20:40:53 1997
 * Modified at:   Tue Dec 14 23:04:16 1999
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 *
 *     Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
 *     All Rights Reserved.
 *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
 *
 *     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.
 *
 *     Neither Dag Brattli nor University of Tromsø admit liability nor
 *     provide warranty for any of this software. This material is
 *     provided "AS-IS" and at no charge.
 *
 ********************************************************************/

#include <linux/kernel.h>

#include <net/irda/irda.h>
#include <net/irda/timer.h>
#include <net/irda/irlap.h>
#include <net/irda/irlmp.h>
#include <net/irda/irlmp_frame.h>
#include <net/irda/irlmp_event.h>

const char *irlmp_state[] = {
        "LAP_STANDBY",
        "LAP_U_CONNECT",
        "LAP_ACTIVE",
};

const char *irlsap_state[] = {
        "LSAP_DISCONNECTED",
        "LSAP_CONNECT",
        "LSAP_CONNECT_PEND",
        "LSAP_DATA_TRANSFER_READY",
        "LSAP_SETUP",
        "LSAP_SETUP_PEND",
};

#ifdef CONFIG_IRDA_DEBUG
static const char *irlmp_event[] = {
        "LM_CONNECT_REQUEST",
        "LM_CONNECT_CONFIRM",
        "LM_CONNECT_RESPONSE",
        "LM_CONNECT_INDICATION",

        "LM_DISCONNECT_INDICATION",
        "LM_DISCONNECT_REQUEST",

        "LM_DATA_REQUEST",
        "LM_UDATA_REQUEST",
        "LM_DATA_INDICATION",
        "LM_UDATA_INDICATION",

        "LM_WATCHDOG_TIMEOUT",

        /* IrLAP events */
        "LM_LAP_CONNECT_REQUEST",
        "LM_LAP_CONNECT_INDICATION",
        "LM_LAP_CONNECT_CONFIRM",
        "LM_LAP_DISCONNECT_INDICATION",
        "LM_LAP_DISCONNECT_REQUEST",
        "LM_LAP_DISCOVERY_REQUEST",
        "LM_LAP_DISCOVERY_CONFIRM",
        "LM_LAP_IDLE_TIMEOUT",
};
#endif  /* CONFIG_IRDA_DEBUG */

/* LAP Connection control proto declarations */
static void irlmp_state_standby  (struct lap_cb *, IRLMP_EVENT,
                                  struct sk_buff *);
static void irlmp_state_u_connect(struct lap_cb *, IRLMP_EVENT,
                                  struct sk_buff *);
static void irlmp_state_active   (struct lap_cb *, IRLMP_EVENT,
                                  struct sk_buff *);

/* LSAP Connection control proto declarations */
static int irlmp_state_disconnected(struct lsap_cb *, IRLMP_EVENT,
                                    struct sk_buff *);
static int irlmp_state_connect     (struct lsap_cb *, IRLMP_EVENT,
                                    struct sk_buff *);
static int irlmp_state_connect_pend(struct lsap_cb *, IRLMP_EVENT,
                                    struct sk_buff *);
static int irlmp_state_dtr         (struct lsap_cb *, IRLMP_EVENT,
                                    struct sk_buff *);
static int irlmp_state_setup       (struct lsap_cb *, IRLMP_EVENT,
                                    struct sk_buff *);
static int irlmp_state_setup_pend  (struct lsap_cb *, IRLMP_EVENT,
                                    struct sk_buff *);

static void (*lap_state[]) (struct lap_cb *, IRLMP_EVENT, struct sk_buff *) =
{
        irlmp_state_standby,
        irlmp_state_u_connect,
        irlmp_state_active,
};

static int (*lsap_state[])( struct lsap_cb *, IRLMP_EVENT, struct sk_buff *) =
{
        irlmp_state_disconnected,
        irlmp_state_connect,
        irlmp_state_connect_pend,
        irlmp_state_dtr,
        irlmp_state_setup,
        irlmp_state_setup_pend
};

static inline void irlmp_next_lap_state(struct lap_cb *self,
                                        IRLMP_STATE state)
{
        /*
        IRDA_DEBUG(4, "%s(), LMP LAP = %s\n", __FUNCTION__, irlmp_state[state]);
        */
        self->lap_state = state;
}

static inline void irlmp_next_lsap_state(struct lsap_cb *self,
                                         LSAP_STATE state)
{
        /*
        IRDA_ASSERT(self != NULL, return;);
        IRDA_DEBUG(4, "%s(), LMP LSAP = %s\n", __FUNCTION__, irlsap_state[state]);
        */
        self->lsap_state = state;
}

/* Do connection control events */
int irlmp_do_lsap_event(struct lsap_cb *self, IRLMP_EVENT event,
                        struct sk_buff *skb)
{
        IRDA_ASSERT(self != NULL, return -1;);
        IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);

        IRDA_DEBUG(4, "%s(), EVENT = %s, STATE = %s\n",
                __FUNCTION__, irlmp_event[event], irlsap_state[ self->lsap_state]);

        return (*lsap_state[self->lsap_state]) (self, event, skb);
}

/*
 * Function do_lap_event (event, skb, info)
 *
 *    Do IrLAP control events
 *
 */
void irlmp_do_lap_event(struct lap_cb *self, IRLMP_EVENT event,
                        struct sk_buff *skb)
{
        IRDA_ASSERT(self != NULL, return;);
        IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);

        IRDA_DEBUG(4, "%s(), EVENT = %s, STATE = %s\n", __FUNCTION__,
                   irlmp_event[event],
                   irlmp_state[self->lap_state]);

        (*lap_state[self->lap_state]) (self, event, skb);
}

void irlmp_discovery_timer_expired(void *data)
{
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);

        /* We always cleanup the log (active & passive discovery) */
        irlmp_do_expiry();

        /* Active discovery is conditional */
        if (sysctl_discovery)
                irlmp_do_discovery(sysctl_discovery_slots);

        /* Restart timer */
        irlmp_start_discovery_timer(irlmp, sysctl_discovery_timeout * HZ);
}

void irlmp_watchdog_timer_expired(void *data)
{
        struct lsap_cb *self = (struct lsap_cb *) data;

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

        IRDA_ASSERT(self != NULL, return;);
        IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);

        irlmp_do_lsap_event(self, LM_WATCHDOG_TIMEOUT, NULL);
}

void irlmp_idle_timer_expired(void *data)
{
        struct lap_cb *self = (struct lap_cb *) data;

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

        IRDA_ASSERT(self != NULL, return;);
        IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);

        irlmp_do_lap_event(self, LM_LAP_IDLE_TIMEOUT, NULL);
}

/*
 * Send an event on all LSAPs attached to this LAP.
 */
static inline void
irlmp_do_all_lsap_event(hashbin_t *     lsap_hashbin,
                        IRLMP_EVENT     event)
{
        struct lsap_cb *lsap;
        struct lsap_cb *lsap_next;

        /* Note : this function use the new hashbin_find_next()
         * function, instead of the old hashbin_get_next().
         * This make sure that we are always pointing one lsap
         * ahead, so that if the current lsap is removed as the
         * result of sending the event, we don't care.
         * Also, as we store the context ourselves, if an enumeration
         * of the same lsap hashbin happens as the result of sending the
         * event, we don't care.
         * The only problem is if the next lsap is removed. In that case,
         * hashbin_find_next() will return NULL and we will abort the
         * enumeration. - Jean II */

        /* Also : we don't accept any skb in input. We can *NOT* pass
         * the same skb to multiple clients safely, we would need to
         * skb_clone() it. - Jean II */

        lsap = (struct lsap_cb *) hashbin_get_first(lsap_hashbin);

        while (NULL != hashbin_find_next(lsap_hashbin,
                                         (long) lsap,
                                         NULL,
                                         (void *) &lsap_next) ) {
                irlmp_do_lsap_event(lsap, event, NULL);
                lsap = lsap_next;
        }
}

/*********************************************************************
 *
 *    LAP connection control states
 *
 ********************************************************************/

/*
 * Function irlmp_state_standby (event, skb, info)
 *
 *    STANDBY, The IrLAP connection does not exist.
 *
 */
static void irlmp_state_standby(struct lap_cb *self, IRLMP_EVENT event,
                                struct sk_buff *skb)
{
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
        IRDA_ASSERT(self->irlap != NULL, return;);

        switch (event) {
        case LM_LAP_DISCOVERY_REQUEST:
                /* irlmp_next_station_state( LMP_DISCOVER); */

                irlap_discovery_request(self->irlap, &irlmp->discovery_cmd);
                break;
        case LM_LAP_CONNECT_INDICATION:
                /*  It's important to switch state first, to avoid IrLMP to
                 *  think that the link is free since IrLMP may then start
                 *  discovery before the connection is properly set up. DB.
                 */
                irlmp_next_lap_state(self, LAP_ACTIVE);

                /* Just accept connection TODO, this should be fixed */
                irlap_connect_response(self->irlap, skb);
                break;
        case LM_LAP_CONNECT_REQUEST:
                IRDA_DEBUG(4, "%s() LS_CONNECT_REQUEST\n", __FUNCTION__);

                irlmp_next_lap_state(self, LAP_U_CONNECT);

                /* FIXME: need to set users requested QoS */
                irlap_connect_request(self->irlap, self->daddr, NULL, 0);
                break;
        case LM_LAP_DISCONNECT_INDICATION:
                IRDA_DEBUG(4, "%s(), Error LM_LAP_DISCONNECT_INDICATION\n",
                           __FUNCTION__);

                irlmp_next_lap_state(self, LAP_STANDBY);
                break;
        default:
                IRDA_DEBUG(0, "%s(), Unknown event %s\n",
                           __FUNCTION__, irlmp_event[event]);
                break;
        }
}

/*
 * Function irlmp_state_u_connect (event, skb, info)
 *
 *    U_CONNECT, The layer above has tried to open an LSAP connection but
 *    since the IrLAP connection does not exist, we must first start an
 *    IrLAP connection. We are now waiting response from IrLAP.
 * */
static void irlmp_state_u_connect(struct lap_cb *self, IRLMP_EVENT event,
                                  struct sk_buff *skb)
{
        IRDA_DEBUG(2, "%s(), event=%s\n", __FUNCTION__, irlmp_event[event]);

        switch (event) {
        case LM_LAP_CONNECT_INDICATION:
                /*  It's important to switch state first, to avoid IrLMP to
                 *  think that the link is free since IrLMP may then start
                 *  discovery before the connection is properly set up. DB.
                 */
                irlmp_next_lap_state(self, LAP_ACTIVE);

                /* Just accept connection TODO, this should be fixed */
                irlap_connect_response(self->irlap, skb);

                /* Tell LSAPs that they can start sending data */
                irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM);

                /* Note : by the time we get there (LAP retries and co),
                 * the lsaps may already have gone. This avoid getting stuck
                 * forever in LAP_ACTIVE state - Jean II */
                if (HASHBIN_GET_SIZE(self->lsaps) == 0) {
                        IRDA_DEBUG(0, "%s() NO LSAPs !\n",  __FUNCTION__);
                        irlmp_start_idle_timer(self, LM_IDLE_TIMEOUT);
                }
                break;
        case LM_LAP_CONNECT_REQUEST:
                /* Already trying to connect */
                break;
        case LM_LAP_CONNECT_CONFIRM:
                /* For all lsap_ce E Associated do LS_Connect_confirm */
                irlmp_next_lap_state(self, LAP_ACTIVE);

                /* Tell LSAPs that they can start sending data */
                irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM);

                /* Note : by the time we get there (LAP retries and co),
                 * the lsaps may already have gone. This avoid getting stuck
                 * forever in LAP_ACTIVE state - Jean II */
                if (HASHBIN_GET_SIZE(self->lsaps) == 0) {
                        IRDA_DEBUG(0, "%s() NO LSAPs !\n",  __FUNCTION__);
                        irlmp_start_idle_timer(self, LM_IDLE_TIMEOUT);
                }
                break;
        case LM_LAP_DISCONNECT_INDICATION:
                IRDA_DEBUG(4, "%s(), LM_LAP_DISCONNECT_INDICATION\n",  __FUNCTION__);
                irlmp_next_lap_state(self, LAP_STANDBY);

                /* Send disconnect event to all LSAPs using this link */
                irlmp_do_all_lsap_event(self->lsaps,
                                        LM_LAP_DISCONNECT_INDICATION);
                break;
        case LM_LAP_DISCONNECT_REQUEST:
                IRDA_DEBUG(4, "%s(), LM_LAP_DISCONNECT_REQUEST\n",  __FUNCTION__);

                /* One of the LSAP did timeout or was closed, if it was
                 * the last one, try to get out of here - Jean II */
                if (HASHBIN_GET_SIZE(self->lsaps) <= 1) {
                        irlap_disconnect_request(self->irlap);
                }
                break;
        default:
                IRDA_DEBUG(0, "%s(), Unknown event %s\n",
                         __FUNCTION__, irlmp_event[event]);
                break;
        }
}

/*
 * Function irlmp_state_active (event, skb, info)
 *
 *    ACTIVE, IrLAP connection is active
 *
 */
static void irlmp_state_active(struct lap_cb *self, IRLMP_EVENT event,
                               struct sk_buff *skb)
{
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);

        switch (event) {
        case LM_LAP_CONNECT_REQUEST:
                IRDA_DEBUG(4, "%s(), LS_CONNECT_REQUEST\n", __FUNCTION__);

                /*
                 * IrLAP may have a pending disconnect. We tried to close
                 * IrLAP, but it was postponed because the link was
                 * busy or we were still sending packets. As we now
                 * need it, make sure it stays on. Jean II
                 */
                irlap_clear_disconnect(self->irlap);

                /*
                 *  LAP connection already active, just bounce back! Since we
                 *  don't know which LSAP that tried to do this, we have to
                 *  notify all LSAPs using this LAP, but that should be safe to
                 *  do anyway.
                 */
                irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM);

                /* Needed by connect indication */
                irlmp_do_all_lsap_event(irlmp->unconnected_lsaps,
                                        LM_LAP_CONNECT_CONFIRM);
                /* Keep state */
                break;
        case LM_LAP_DISCONNECT_REQUEST:
                /*
                 *  Need to find out if we should close IrLAP or not. If there
                 *  is only one LSAP connection left on this link, that LSAP
                 *  must be the one that tries to close IrLAP. It will be
                 *  removed later and moved to the list of unconnected LSAPs
                 */
                if (HASHBIN_GET_SIZE(self->lsaps) > 0) {
                        /* Timer value is checked in irsysctl - Jean II */
                        irlmp_start_idle_timer(self, sysctl_lap_keepalive_time * HZ / 1000);
                } else {
                        /* No more connections, so close IrLAP */

                        /* We don't want to change state just yet, because
                         * we want to reflect accurately the real state of
                         * the LAP, not the state we wish it was in,
                         * so that we don't lose LM_LAP_CONNECT_REQUEST.
                         * In some cases, IrLAP won't close the LAP
                         * immediately. For example, it might still be
                         * retrying packets or waiting for the pf bit.
                         * As the LAP always send a DISCONNECT_INDICATION
                         * in PCLOSE or SCLOSE, just change state on that.
                         * Jean II */
                        irlap_disconnect_request(self->irlap);
                }
                break;
        case LM_LAP_IDLE_TIMEOUT:
                if (HASHBIN_GET_SIZE(self->lsaps) == 0) {
                        /* Same reasoning as above - keep state */
                        irlap_disconnect_request(self->irlap);
                }
                break;
        case LM_LAP_DISCONNECT_INDICATION:
                irlmp_next_lap_state(self, LAP_STANDBY);

                /* In some case, at this point our side has already closed
                 * all lsaps, and we are waiting for the idle_timer to
                 * expire. If another device reconnect immediately, the
                 * idle timer will expire in the midle of the connection
                 * initialisation, screwing up things a lot...
                 * Therefore, we must stop the timer... */
                irlmp_stop_idle_timer(self);

                /*
                 *  Inform all connected LSAP's using this link
                 */
                irlmp_do_all_lsap_event(self->lsaps,
                                        LM_LAP_DISCONNECT_INDICATION);

                /* Force an expiry of the discovery log.
                 * Now that the LAP is free, the system may attempt to
                 * connect to another device. Unfortunately, our entries
                 * are stale. There is a small window (<3s) before the
                 * normal discovery will run and where irlmp_connect_request()
                 * can get the wrong info, so make sure things get
                 * cleaned *NOW* ;-) - Jean II */
                irlmp_do_expiry();
                break;
        default:
                IRDA_DEBUG(0, "%s(), Unknown event %s\n",
                         __FUNCTION__, irlmp_event[event]);
                break;
        }
}

/*********************************************************************
 *
 *    LSAP connection control states
 *
 ********************************************************************/

/*
 * Function irlmp_state_disconnected (event, skb, info)
 *
 *    DISCONNECTED
 *
 */
static int irlmp_state_disconnected(struct lsap_cb *self, IRLMP_EVENT event,
                                    struct sk_buff *skb)
{
        int ret = 0;

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

        IRDA_ASSERT(self != NULL, return -1;);
        IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);

        switch (event) {
#ifdef CONFIG_IRDA_ULTRA
        case LM_UDATA_INDICATION:
                /* This is most bizzare. Those packets are  aka unreliable
                 * connected, aka IrLPT or SOCK_DGRAM/IRDAPROTO_UNITDATA.
                 * Why do we pass them as Ultra ??? Jean II */
                irlmp_connless_data_indication(self, skb);
                break;
#endif /* CONFIG_IRDA_ULTRA */
        case LM_CONNECT_REQUEST:
                IRDA_DEBUG(4, "%s(), LM_CONNECT_REQUEST\n", __FUNCTION__);

                if (self->conn_skb) {
                        IRDA_WARNING("%s: busy with another request!\n",
                                     __FUNCTION__);
                        return -EBUSY;
                }
                /* Don't forget to refcount it (see irlmp_connect_request()) */
                skb_get(skb);
                self->conn_skb = skb;

                irlmp_next_lsap_state(self, LSAP_SETUP_PEND);

                /* Start watchdog timer (5 secs for now) */
                irlmp_start_watchdog_timer(self, 5*HZ);

                irlmp_do_lap_event(self->lap, LM_LAP_CONNECT_REQUEST, NULL);
                break;
        case LM_CONNECT_INDICATION:
                if (self->conn_skb) {
                        IRDA_WARNING("%s: busy with another request!\n",
                                     __FUNCTION__);
                        return -EBUSY;
                }
                /* Don't forget to refcount it (see irlap_driver_rcv()) */
                skb_get(skb);
                self->conn_skb = skb;

                irlmp_next_lsap_state(self, LSAP_CONNECT_PEND);

                /* Start watchdog timer
                 * This is not mentionned in the spec, but there is a rare
                 * race condition that can get the socket stuck.
                 * If we receive this event while our LAP is closing down,
                 * the LM_LAP_CONNECT_REQUEST get lost and we get stuck in
                 * CONNECT_PEND state forever.
                 * The other cause of getting stuck down there is if the
                 * higher layer never reply to the CONNECT_INDICATION.
                 * Anyway, it make sense to make sure that we always have
                 * a backup plan. 1 second is plenty (should be immediate).
                 * Jean II */
                irlmp_start_watchdog_timer(self, 1*HZ);

                irlmp_do_lap_event(self->lap, LM_LAP_CONNECT_REQUEST, NULL);
                break;
        default:
                IRDA_DEBUG(1, "%s(), Unknown event %s on LSAP %#02x\n",
                           __FUNCTION__, irlmp_event[event], self->slsap_sel);
                break;
        }
        return ret;
}

/*
 * Function irlmp_state_connect (self, event, skb)
 *
 *    CONNECT
 *
 */
static int irlmp_state_connect(struct lsap_cb *self, IRLMP_EVENT event,
                                struct sk_buff *skb)
{
        struct lsap_cb *lsap;
        int ret = 0;

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

        IRDA_ASSERT(self != NULL, return -1;);
        IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);

        switch (event) {
        case LM_CONNECT_RESPONSE:
                /*
                 *  Bind this LSAP to the IrLAP link where the connect was
                 *  received
                 */
                lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self,
                                      NULL);

                IRDA_ASSERT(lsap == self, return -1;);
                IRDA_ASSERT(self->lap != NULL, return -1;);
                IRDA_ASSERT(self->lap->lsaps != NULL, return -1;);

                hashbin_insert(self->lap->lsaps, (irda_queue_t *) self,
                               (long) self, NULL);

                set_bit(0, &self->connected);   /* TRUE */

                irlmp_send_lcf_pdu(self->lap, self->dlsap_sel,
                                   self->slsap_sel, CONNECT_CNF, skb);

                del_timer(&self->watchdog_timer);

                irlmp_next_lsap_state(self, LSAP_DATA_TRANSFER_READY);
                break;
        case LM_WATCHDOG_TIMEOUT:
                /* May happen, who knows...
                 * Jean II */
                IRDA_DEBUG(0, "%s() WATCHDOG_TIMEOUT!\n",  __FUNCTION__);

                /* Disconnect, get out... - Jean II */
                self->lap = NULL;
                self->dlsap_sel = LSAP_ANY;
                irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
                break;
        default:
                /* LM_LAP_DISCONNECT_INDICATION : Should never happen, we
                 * are *not* yet bound to the IrLAP link. Jean II */
                IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n",
                           __FUNCTION__, irlmp_event[event], self->slsap_sel);
                break;
        }
        return ret;
}

/*
 * Function irlmp_state_connect_pend (event, skb, info)
 *
 *    CONNECT_PEND
 *
 */
static int irlmp_state_connect_pend(struct lsap_cb *self, IRLMP_EVENT event,
                                    struct sk_buff *skb)
{
        struct sk_buff *tx_skb;
        int ret = 0;

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

        IRDA_ASSERT(self != NULL, return -1;);
        IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);

        switch (event) {
        case LM_CONNECT_REQUEST:
                /* Keep state */
                break;
        case LM_CONNECT_RESPONSE:
                IRDA_DEBUG(0, "%s(), LM_CONNECT_RESPONSE, "
                           "no indication issued yet\n",  __FUNCTION__);
                /* Keep state */
                break;
        case LM_DISCONNECT_REQUEST:
                IRDA_DEBUG(0, "%s(), LM_DISCONNECT_REQUEST, "
                           "not yet bound to IrLAP connection\n",  __FUNCTION__);
                /* Keep state */
                break;
        case LM_LAP_CONNECT_CONFIRM:
                IRDA_DEBUG(4, "%s(), LS_CONNECT_CONFIRM\n",  __FUNCTION__);
                irlmp_next_lsap_state(self, LSAP_CONNECT);

                tx_skb = self->conn_skb;
                self->conn_skb = NULL;

                irlmp_connect_indication(self, tx_skb);
                /* Drop reference count - see irlmp_connect_indication(). */
                dev_kfree_skb(tx_skb);
                break;
        case LM_WATCHDOG_TIMEOUT:
                /* Will happen in some rare cases because of a race condition.
                 * Just make sure we don't stay there forever...
                 * Jean II */
                IRDA_DEBUG(0, "%s() WATCHDOG_TIMEOUT!\n",  __FUNCTION__);

                /* Go back to disconnected mode, keep the socket waiting */
                self->lap = NULL;
                self->dlsap_sel = LSAP_ANY;
                if(self->conn_skb)
                        dev_kfree_skb(self->conn_skb);
                self->conn_skb = NULL;
                irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
                break;
        default:
                /* LM_LAP_DISCONNECT_INDICATION : Should never happen, we
                 * are *not* yet bound to the IrLAP link. Jean II */
                IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n",
                           __FUNCTION__, irlmp_event[event], self->slsap_sel);
                break;
        }
        return ret;
}

/*
 * Function irlmp_state_dtr (self, event, skb)
 *
 *    DATA_TRANSFER_READY
 *
 */
static int irlmp_state_dtr(struct lsap_cb *self, IRLMP_EVENT event,
                           struct sk_buff *skb)
{
        LM_REASON reason;
        int ret = 0;

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

        IRDA_ASSERT(self != NULL, return -1;);
        IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
        IRDA_ASSERT(self->lap != NULL, return -1;);

        switch (event) {
        case LM_DATA_REQUEST: /* Optimize for the common case */
                irlmp_send_data_pdu(self->lap, self->dlsap_sel,
                                    self->slsap_sel, FALSE, skb);
                break;
        case LM_DATA_INDICATION: /* Optimize for the common case */
                irlmp_data_indication(self, skb);
                break;
        case LM_UDATA_REQUEST:
                IRDA_ASSERT(skb != NULL, return -1;);
                irlmp_send_data_pdu(self->lap, self->dlsap_sel,
                                    self->slsap_sel, TRUE, skb);
                break;
        case LM_UDATA_INDICATION:
                irlmp_udata_indication(self, skb);
                break;
        case LM_CONNECT_REQUEST:
                IRDA_DEBUG(0, "%s(), LM_CONNECT_REQUEST, "
                           "error, LSAP already connected\n", __FUNCTION__);
                /* Keep state */
                break;
        case LM_CONNECT_RESPONSE:
                IRDA_DEBUG(0, "%s(), LM_CONNECT_RESPONSE, "
                           "error, LSAP already connected\n", __FUNCTION__);
                /* Keep state */
                break;
        case LM_DISCONNECT_REQUEST:
                irlmp_send_lcf_pdu(self->lap, self->dlsap_sel, self->slsap_sel,
                                   DISCONNECT, skb);
                irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
                /* Called only from irlmp_disconnect_request(), will
                 * unbind from LAP over there. Jean II */

                /* Try to close the LAP connection if its still there */
                if (self->lap) {
                        IRDA_DEBUG(4, "%s(), trying to close IrLAP\n",
                                   __FUNCTION__);
                        irlmp_do_lap_event(self->lap,
                                           LM_LAP_DISCONNECT_REQUEST,
                                           NULL);
                }
                break;
        case LM_LAP_DISCONNECT_INDICATION:
                irlmp_next_lsap_state(self, LSAP_DISCONNECTED);

                reason = irlmp_convert_lap_reason(self->lap->reason);

                irlmp_disconnect_indication(self, reason, NULL);
                break;
        case LM_DISCONNECT_INDICATION:
                irlmp_next_lsap_state(self, LSAP_DISCONNECTED);

                IRDA_ASSERT(self->lap != NULL, return -1;);
                IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);

                IRDA_ASSERT(skb != NULL, return -1;);
                IRDA_ASSERT(skb->len > 3, return -1;);
                reason = skb->data[3];

                 /* Try to close the LAP connection */
                IRDA_DEBUG(4, "%s(), trying to close IrLAP\n", __FUNCTION__);
                irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);

                irlmp_disconnect_indication(self, reason, skb);
                break;
        default:
                IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n",
                           __FUNCTION__, irlmp_event[event], self->slsap_sel);
                break;
        }
        return ret;
}

/*
 * Function irlmp_state_setup (event, skb, info)
 *
 *    SETUP, Station Control has set up the underlying IrLAP connection.
 *    An LSAP connection request has been transmitted to the peer
 *    LSAP-Connection Control FSM and we are awaiting reply.
 */
static int irlmp_state_setup(struct lsap_cb *self, IRLMP_EVENT event,
                             struct sk_buff *skb)
{
        LM_REASON reason;
        int ret = 0;

        IRDA_ASSERT(self != NULL, return -1;);
        IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);

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

        switch (event) {
        case LM_CONNECT_CONFIRM:
                irlmp_next_lsap_state(self, LSAP_DATA_TRANSFER_READY);

                del_timer(&self->watchdog_timer);

                irlmp_connect_confirm(self, skb);
                break;
        case LM_DISCONNECT_INDICATION:
                irlmp_next_lsap_state(self, LSAP_DISCONNECTED);

                IRDA_ASSERT(self->lap != NULL, return -1;);
                IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);

                IRDA_ASSERT(skb != NULL, return -1;);
                IRDA_ASSERT(skb->len > 3, return -1;);
                reason = skb->data[3];

                 /* Try to close the LAP connection */
                IRDA_DEBUG(4, "%s(), trying to close IrLAP\n",  __FUNCTION__);
                irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);

                irlmp_disconnect_indication(self, reason, skb);
                break;
        case LM_LAP_DISCONNECT_INDICATION:
                irlmp_next_lsap_state(self, LSAP_DISCONNECTED);

                del_timer(&self->watchdog_timer);

                IRDA_ASSERT(self->lap != NULL, return -1;);
                IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);

                reason = irlmp_convert_lap_reason(self->lap->reason);

                irlmp_disconnect_indication(self, reason, skb);
                break;
        case LM_WATCHDOG_TIMEOUT:
                IRDA_DEBUG(0, "%s() WATCHDOG_TIMEOUT!\n", __FUNCTION__);

                IRDA_ASSERT(self->lap != NULL, return -1;);
                irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);
                irlmp_next_lsap_state(self, LSAP_DISCONNECTED);

                irlmp_disconnect_indication(self, LM_CONNECT_FAILURE, NULL);
                break;
        default:
                IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n",
                           __FUNCTION__, irlmp_event[event], self->slsap_sel);
                break;
        }
        return ret;
}

/*
 * Function irlmp_state_setup_pend (event, skb, info)
 *
 *    SETUP_PEND, An LM_CONNECT_REQUEST has been received from the service
 *    user to set up an LSAP connection. A request has been sent to the
 *    LAP FSM to set up the underlying IrLAP connection, and we
 *    are awaiting confirm.
 */
static int irlmp_state_setup_pend(struct lsap_cb *self, IRLMP_EVENT event,
                                  struct sk_buff *skb)
{
        struct sk_buff *tx_skb;
        LM_REASON reason;
        int ret = 0;

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

        IRDA_ASSERT(self != NULL, return -1;);
        IRDA_ASSERT(irlmp != NULL, return -1;);

        switch (event) {
        case LM_LAP_CONNECT_CONFIRM:
                IRDA_ASSERT(self->conn_skb != NULL, return -1;);

                tx_skb = self->conn_skb;
                self->conn_skb = NULL;

                irlmp_send_lcf_pdu(self->lap, self->dlsap_sel,
                                   self->slsap_sel, CONNECT_CMD, tx_skb);
                /* Drop reference count - see irlap_data_request(). */
                dev_kfree_skb(tx_skb);

                irlmp_next_lsap_state(self, LSAP_SETUP);
                break;
        case LM_WATCHDOG_TIMEOUT:
                IRDA_DEBUG(0, "%s() : WATCHDOG_TIMEOUT !\n",  __FUNCTION__);

                IRDA_ASSERT(self->lap != NULL, return -1;);
                irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);
                irlmp_next_lsap_state(self, LSAP_DISCONNECTED);

                irlmp_disconnect_indication(self, LM_CONNECT_FAILURE, NULL);
                break;
        case LM_LAP_DISCONNECT_INDICATION: /* LS_Disconnect.indication */
                del_timer( &self->watchdog_timer);

                irlmp_next_lsap_state(self, LSAP_DISCONNECTED);

                reason = irlmp_convert_lap_reason(self->lap->reason);

                irlmp_disconnect_indication(self, reason, NULL);
                break;
        default:
                IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n",
                           __FUNCTION__, irlmp_event[event], self->slsap_sel);
                break;
        }
        return ret;
}