[PATCH] 2.5.21 kill warnings 16/19

Martin Dalecki
2002-06-10T12:49:28Z

[-- Attachment #1: Type: text/plain, Size: 94 bytes --]

irlmp_event was abusing __FUCTION__ too.
And of course it appears all red in my gvim as well.

[-- Attachment #2: warn-2.5.21-16.diff --]
[-- Type: text/plain, Size: 22012 bytes --]

diff -urN linux-2.5.21/net/irda/irlmp_event.c linux/net/irda/irlmp_event.c
--- linux-2.5.21/net/irda/irlmp_event.c 2002-06-09 07:28:07.000000000 +0200
+++ linux/net/irda/irlmp_event.c 2002-06-09 21:37:58.000000000 +0200
@@ -1,5 +1,5 @@
/*********************************************************************
- *
+ *
* Filename: irlmp_event.c
* Version: 0.8
* Description: An IrDA LMP event driver for Linux
@@ -8,18 +8,18 @@
* 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>,
+ *
+ * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
* All Rights Reserved.
* Copyright (c) 2000-2001 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
+ *
+ * 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
+ * provide warranty for any of this software. This material is
* provided "AS-IS" and at no charge.
*
********************************************************************/
@@ -52,52 +52,52 @@
#ifdef CONFIG_IRDA_DEBUG
static const char *irlmp_event[] = {
"LM_CONNECT_REQUEST",
- "LM_CONNECT_CONFIRM",
+ "LM_CONNECT_CONFIRM",
"LM_CONNECT_RESPONSE",
- "LM_CONNECT_INDICATION",
-
+ "LM_CONNECT_INDICATION",
+
"LM_DISCONNECT_INDICATION",
"LM_DISCONNECT_REQUEST",

- "LM_DATA_REQUEST",
+ "LM_DATA_REQUEST",
"LM_UDATA_REQUEST",
- "LM_DATA_INDICATION",
+ "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_CONNECT_INDICATION",
+ "LM_LAP_CONNECT_CONFIRM",
+ "LM_LAP_DISCONNECT_INDICATION",
"LM_LAP_DISCONNECT_REQUEST",
"LM_LAP_DISCOVERY_REQUEST",
- "LM_LAP_DISCOVERY_CONFIRM",
+ "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,
+static void irlmp_state_standby (struct lap_cb *, IRLMP_EVENT,
struct sk_buff *);
-static void irlmp_state_u_connect(struct lap_cb *, IRLMP_EVENT,
+static void irlmp_state_u_connect(struct lap_cb *, IRLMP_EVENT,
struct sk_buff *);
-static void irlmp_state_active (struct lap_cb *, IRLMP_EVENT,
+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,
+static int irlmp_state_disconnected(struct lsap_cb *, IRLMP_EVENT,
struct sk_buff *);
-static int irlmp_state_connect (struct lsap_cb *, IRLMP_EVENT,
+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,
+static int irlmp_state_dtr (struct lsap_cb *, IRLMP_EVENT,
struct sk_buff *);
-static int irlmp_state_setup (struct lsap_cb *, IRLMP_EVENT,
+static int irlmp_state_setup (struct lsap_cb *, IRLMP_EVENT,
struct sk_buff *);
-static int irlmp_state_setup_pend (struct lsap_cb *, IRLMP_EVENT,
+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 *) =
@@ -118,7 +118,7 @@
};

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

static inline void irlmp_next_lsap_state(struct lsap_cb *self,
- LSAP_STATE state)
+ LSAP_STATE state)
{
/*
ASSERT(self != NULL, return;);
@@ -137,7 +137,7 @@
}

/* Do connection control events */
-int irlmp_do_lsap_event(struct lsap_cb *self, IRLMP_EVENT event,
+int irlmp_do_lsap_event(struct lsap_cb *self, IRLMP_EVENT event,
struct sk_buff *skb)
{
ASSERT(self != NULL, return -1;);
@@ -155,14 +155,14 @@
* Do IrLAP control events
*
*/
-void irlmp_do_lap_event(struct lap_cb *self, IRLMP_EVENT event,
- struct sk_buff *skb)
+void irlmp_do_lap_event(struct lap_cb *self, IRLMP_EVENT event,
+ struct sk_buff *skb)
{
ASSERT(self != NULL, return;);
ASSERT(self->magic == LMP_LAP_MAGIC, return;);
-
+
IRDA_DEBUG(4, __FUNCTION__ "(), EVENT = %s, STATE = %s\n",
- irlmp_event[event],
+ irlmp_event[event],
irlmp_state[self->lap_state]);

(*lap_state[self->lap_state]) (self, event, skb);
@@ -171,8 +171,8 @@
void irlmp_discovery_timer_expired(void *data)
{
IRDA_DEBUG(4, __FUNCTION__ "()\n");
-
- /* We always cleanup the log (active & passive discovery) */
+
+ /* We always cleanup the log (active & passive discovery) */
irlmp_do_expiry();

/* Active discovery is conditional */
@@ -186,7 +186,7 @@
void irlmp_watchdog_timer_expired(void *data)
{
struct lsap_cb *self = (struct lsap_cb *) data;
-
+
IRDA_DEBUG(2, __FUNCTION__ "()\n");

ASSERT(self != NULL, return;);
@@ -198,7 +198,7 @@
void irlmp_idle_timer_expired(void *data)
{
struct lap_cb *self = (struct lap_cb *) data;
-
+
IRDA_DEBUG(2, __FUNCTION__ "()\n");

ASSERT(self != NULL, return;);
@@ -219,20 +219,20 @@
* STANDBY, The IrLAP connection does not exist.
*
*/
-static void irlmp_state_standby(struct lap_cb *self, IRLMP_EVENT event,
+static void irlmp_state_standby(struct lap_cb *self, IRLMP_EVENT event,
struct sk_buff *skb)
-{
- IRDA_DEBUG(4, __FUNCTION__ "()\n");
+{
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");
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
+ /* 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.
*/
@@ -250,16 +250,16 @@
irlap_connect_request(self->irlap, self->daddr, NULL, 0);
break;
case LM_LAP_DISCONNECT_INDICATION:
- IRDA_DEBUG(4, __FUNCTION__
+ IRDA_DEBUG(4, __FUNCTION__
"(), Error LM_LAP_DISCONNECT_INDICATION\n");
-
+
irlmp_next_lap_state(self, LAP_STANDBY);
break;
default:
IRDA_DEBUG(0, __FUNCTION__ "(), Unknown event %s\n",
irlmp_event[event]);
if (skb)
- dev_kfree_skb(skb);
+ dev_kfree_skb(skb);
break;
}
}
@@ -271,17 +271,17 @@
* 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,
+static void irlmp_state_u_connect(struct lap_cb *self, IRLMP_EVENT event,
struct sk_buff *skb)
{
struct lsap_cb *lsap;
struct lsap_cb *lsap_current;
-
+
IRDA_DEBUG(2, __FUNCTION__ "(), event=%s\n", irlmp_event[event]);

switch (event) {
case LM_LAP_CONNECT_INDICATION:
- /* It's important to switch state first, to avoid IrLMP to
+ /* 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.
*/
@@ -331,12 +331,12 @@
lsap = (struct lsap_cb *) hashbin_get_first( self->lsaps);
while (lsap != NULL ) {
ASSERT(lsap->magic == LMP_LSAP_MAGIC, return;);
-
+
lsap_current = lsap;

/* Be sure to stay one item ahead */
lsap = (struct lsap_cb *) hashbin_get_next(self->lsaps);
- irlmp_do_lsap_event(lsap_current,
+ irlmp_do_lsap_event(lsap_current,
LM_LAP_DISCONNECT_INDICATION,
NULL);
}
@@ -354,9 +354,9 @@
IRDA_DEBUG(0, __FUNCTION__ "(), Unknown event %s\n",
irlmp_event[event]);
if (skb)
- dev_kfree_skb(skb);
+ dev_kfree_skb(skb);
break;
- }
+ }
}

/*
@@ -365,38 +365,38 @@
* ACTIVE, IrLAP connection is active
*
*/
-static void irlmp_state_active(struct lap_cb *self, IRLMP_EVENT event,
+static void irlmp_state_active(struct lap_cb *self, IRLMP_EVENT event,
struct sk_buff *skb)
{
struct lsap_cb *lsap;
struct lsap_cb *lsap_current;

- IRDA_DEBUG(4, __FUNCTION__ "()\n");
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");

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

/*
- * LAP connection allready active, just bounce back! Since we
- * don't know which LSAP that tried to do this, we have to
+ * LAP connection allready 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.
*/
lsap = (struct lsap_cb *) hashbin_get_first(self->lsaps);
while (lsap != NULL) {
irlmp_do_lsap_event(lsap, LM_LAP_CONNECT_CONFIRM, NULL);
- lsap = (struct lsap_cb*) hashbin_get_next(self->lsaps);
+ lsap = (struct lsap_cb*) hashbin_get_next(self->lsaps);
}
-
+
/* Needed by connect indication */
lsap = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps);
while (lsap != NULL) {
lsap_current = lsap;
-
+
/* Be sure to stay one item ahead */
- lsap = (struct lsap_cb*) hashbin_get_next(irlmp->unconnected_lsaps);
- irlmp_do_lsap_event(lsap_current,
+ lsap = (struct lsap_cb*) hashbin_get_next(irlmp->unconnected_lsaps);
+ irlmp_do_lsap_event(lsap_current,
LM_LAP_CONNECT_CONFIRM, NULL);
}
/* Keep state */
@@ -404,8 +404,8 @@
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
+ * 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) {
@@ -434,8 +434,8 @@
}
break;
case LM_LAP_DISCONNECT_INDICATION:
- irlmp_next_lap_state(self, LAP_STANDBY);
-
+ 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
@@ -444,18 +444,18 @@
* Therefore, we must stop the timer... */
irlmp_stop_idle_timer(self);

- /*
+ /*
* Inform all connected LSAP's using this link
*/
lsap = (struct lsap_cb *) hashbin_get_first(self->lsaps);
while (lsap != NULL ) {
ASSERT(lsap->magic == LMP_LSAP_MAGIC, return;);
-
+
lsap_current = lsap;

/* Be sure to stay one item ahead */
lsap = (struct lsap_cb *) hashbin_get_next(self->lsaps);
- irlmp_do_lsap_event(lsap_current,
+ irlmp_do_lsap_event(lsap_current,
LM_LAP_DISCONNECT_INDICATION,
NULL);
}
@@ -473,9 +473,9 @@
IRDA_DEBUG(0, __FUNCTION__ "(), Unknown event %s\n",
irlmp_event[event]);
if (skb)
- dev_kfree_skb(skb);
+ dev_kfree_skb(skb);
break;
- }
+ }
}

/*********************************************************************
@@ -491,7 +491,7 @@
*
*/
static int irlmp_state_disconnected(struct lsap_cb *self, IRLMP_EVENT event,
- struct sk_buff *skb)
+ struct sk_buff *skb)
{
int ret = 0;

@@ -503,15 +503,15 @@
switch (event) {
#ifdef CONFIG_IRDA_ULTRA
case LM_UDATA_INDICATION:
- irlmp_connless_data_indication(self, skb);
+ irlmp_connless_data_indication(self, skb);
break;
#endif /* CONFIG_IRDA_ULTRA */
case LM_CONNECT_REQUEST:
IRDA_DEBUG(4, __FUNCTION__ "(), LM_CONNECT_REQUEST\n");

if (self->conn_skb) {
- WARNING(__FUNCTION__
- "(), busy with another request!\n");
+ WARNING("%s: busy with another request!\n",
+ __FUNCTION__);
return -EBUSY;
}
self->conn_skb = skb;
@@ -525,8 +525,8 @@
break;
case LM_CONNECT_INDICATION:
if (self->conn_skb) {
- WARNING(__FUNCTION__
- "(), busy with another request!\n");
+ WARNING("%s: busy with another request!\n",
+ __FUNCTION__);
return -EBUSY;
}
self->conn_skb = skb;
@@ -549,10 +549,10 @@
irlmp_start_watchdog_timer(self, 1*HZ);
break;
default:
- IRDA_DEBUG(2, __FUNCTION__ "(), Unknown event %s\n",
+ IRDA_DEBUG(2, __FUNCTION__ "(), Unknown event %s\n",
irlmp_event[event]);
if (skb)
- dev_kfree_skb(skb);
+ dev_kfree_skb(skb);
break;
}
return ret;
@@ -564,34 +564,34 @@
* CONNECT
*
*/
-static int irlmp_state_connect(struct lsap_cb *self, IRLMP_EVENT event,
- struct sk_buff *skb)
+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, __FUNCTION__ "()\n");
-
+
ASSERT(self != NULL, return -1;);
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
+ * received
*/
- lsap = hashbin_remove(irlmp->unconnected_lsaps, (int) self,
+ lsap = hashbin_remove(irlmp->unconnected_lsaps, (int) self,
NULL);

- ASSERT(lsap == self, return -1;);
+ ASSERT(lsap == self, return -1;);
ASSERT(self->lap != NULL, return -1;);
ASSERT(self->lap->lsaps != NULL, return -1;);
-
- hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, (int) self,
+
+ hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, (int) self,
NULL);

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

del_timer(&self->watchdog_timer);
@@ -611,7 +611,7 @@
IRDA_DEBUG(0, __FUNCTION__ "(), Unknown event %s\n",
irlmp_event[event]);
if (skb)
- dev_kfree_skb(skb);
+ dev_kfree_skb(skb);
break;
}
return ret;
@@ -624,7 +624,7 @@
*
*/
static int irlmp_state_connect_pend(struct lsap_cb *self, IRLMP_EVENT event,
- struct sk_buff *skb)
+ struct sk_buff *skb)
{
int ret = 0;

@@ -665,16 +665,16 @@
/* Go back to disconnected mode, keep the socket waiting */
self->dlsap_sel = LSAP_ANY;
if(self->conn_skb)
- dev_kfree_skb(self->conn_skb);
+ dev_kfree_skb(self->conn_skb);
self->conn_skb = NULL;
irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
break;
default:
- IRDA_DEBUG(0, __FUNCTION__ "Unknown event %s\n",
+ IRDA_DEBUG(0, __FUNCTION__ "Unknown event %s\n",
irlmp_event[event]);
if (skb)
- dev_kfree_skb(skb);
- break;
+ dev_kfree_skb(skb);
+ break;
}
return ret;
}
@@ -685,13 +685,13 @@
* DATA_TRANSFER_READY
*
*/
-static int irlmp_state_dtr(struct lsap_cb *self, IRLMP_EVENT event,
- struct sk_buff *skb)
+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, __FUNCTION__ "()\n");
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");

ASSERT(self != NULL, return -1;);
ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
@@ -699,19 +699,19 @@

switch (event) {
case LM_DATA_REQUEST: /* Optimize for the common case */
- irlmp_send_data_pdu(self->lap, self->dlsap_sel,
+ 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);
+ irlmp_data_indication(self, skb);
break;
case LM_UDATA_REQUEST:
ASSERT(skb != NULL, return -1;);
- irlmp_send_data_pdu(self->lap, self->dlsap_sel,
+ irlmp_send_data_pdu(self->lap, self->dlsap_sel,
self->slsap_sel, TRUE, skb);
break;
case LM_UDATA_INDICATION:
- irlmp_udata_indication(self, skb);
+ irlmp_udata_indication(self, skb);
break;
case LM_CONNECT_REQUEST:
IRDA_DEBUG(0, __FUNCTION__ "(), LM_CONNECT_REQUEST, "
@@ -719,7 +719,7 @@
/* Keep state */
break;
case LM_CONNECT_RESPONSE:
- IRDA_DEBUG(0, __FUNCTION__ "(), LM_CONNECT_RESPONSE, "
+ IRDA_DEBUG(0, __FUNCTION__ "(), LM_CONNECT_RESPONSE, "
"error, LSAP allready connected\n");
/* Keep state */
break;
@@ -727,12 +727,12 @@
irlmp_send_lcf_pdu(self->lap, self->dlsap_sel, self->slsap_sel,
DISCONNECT, skb);
irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
-
+
/* Try to close the LAP connection if its still there */
if (self->lap) {
IRDA_DEBUG(4, __FUNCTION__ "(), trying to close IrLAP\n");
- irlmp_do_lap_event(self->lap,
- LM_LAP_DISCONNECT_REQUEST,
+ irlmp_do_lap_event(self->lap,
+ LM_LAP_DISCONNECT_REQUEST,
NULL);
}
break;
@@ -745,10 +745,10 @@
break;
case LM_DISCONNECT_INDICATION:
irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
-
+
ASSERT(self->lap != NULL, return -1;);
ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
-
+
ASSERT(skb != NULL, return -1;);
ASSERT(skb->len > 3, return -1;);
reason = skb->data[3];
@@ -760,11 +760,11 @@
irlmp_disconnect_indication(self, reason, skb);
break;
default:
- IRDA_DEBUG(0, __FUNCTION__ "(), Unknown event %s\n",
+ IRDA_DEBUG(0, __FUNCTION__ "(), Unknown event %s\n",
irlmp_event[event]);
if (skb)
- dev_kfree_skb(skb);
- break;
+ dev_kfree_skb(skb);
+ break;
}
return ret;
}
@@ -776,8 +776,8 @@
* 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)
+static int irlmp_state_setup(struct lsap_cb *self, IRLMP_EVENT event,
+ struct sk_buff *skb)
{
LM_REASON reason;
int ret = 0;
@@ -792,15 +792,15 @@
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);
-
+
ASSERT(self->lap != NULL, return -1;);
ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
-
+
ASSERT(skb != NULL, return -1;);
ASSERT(skb->len > 3, return -1;);
reason = skb->data[3];
@@ -818,26 +818,26 @@

ASSERT(self->lap != NULL, return -1;);
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, __FUNCTION__ "() WATCHDOG_TIMEOUT!\n");
-
+
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, __FUNCTION__ "(), Unknown event %s\n",
+ IRDA_DEBUG(0, __FUNCTION__ "(), Unknown event %s\n",
irlmp_event[event]);
if (skb)
- dev_kfree_skb(skb);
- break;
+ dev_kfree_skb(skb);
+ break;
}
return ret;
}
@@ -850,13 +850,13 @@
* 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)
+static int irlmp_state_setup_pend(struct lsap_cb *self, IRLMP_EVENT event,
+ struct sk_buff *skb)
{
LM_REASON reason;
int ret = 0;

- IRDA_DEBUG(4, __FUNCTION__ "()\n");
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");

ASSERT(self != NULL, return -1;);
ASSERT(irlmp != NULL, return -1;);
@@ -868,7 +868,7 @@
skb = self->conn_skb;
self->conn_skb = NULL;

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

irlmp_next_lsap_state(self, LSAP_SETUP);
@@ -886,17 +886,17 @@
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, __FUNCTION__ "(), Unknown event %s\n",
+ IRDA_DEBUG(0, __FUNCTION__ "(), Unknown event %s\n",
irlmp_event[event]);
if (skb)
- dev_kfree_skb(skb);
- break;
+ dev_kfree_skb(skb);
+ break;
}
return ret;
}