sk->sk_shutdown |= SEND_SHUTDOWN;
sk->sk_state_change(sk);
- sock_orphan(sk);
+ sock_orphan(sk);
release_sock(sk);
/* Close our TSAP.
irttp_close_tsap(self->tsap);
self->tsap = NULL;
}
- }
+ }
/* Note : once we are there, there is not much you want to do
* with the socket anymore, apart from closing it.
IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
- if (sk == NULL)
+ if (sk == NULL)
return 0;
lock_sock(sk);
* memory leak is now gone... - Jean II
*/
- return 0;
+ return 0;
}
/*
len = self->max_data_size;
}
- skb = sock_alloc_send_skb(sk, len + self->max_header_size + 16,
+ skb = sock_alloc_send_skb(sk, len + self->max_header_size + 16,
msg->msg_flags & MSG_DONTWAIT, &err);
if (!skb)
return -ENOBUFS;
self->daddr = DEV_ADDR_ANY; /* Until we get re-connected */
self->saddr = 0x0; /* so IrLMP assign us any link */
- return 0;
+ return 0;
}
/*
/*********************************************************************
- *
+ *
* Filename: discovery.c
* Version: 0.1
* Description: Routines for handling discoveries at the IrLMP layer
* Modified by: Dag Brattli <dagb@cs.uit.no>
* Modified at: Fri May 28 3:11 CST 1999
* Modified by: Horst von Brand <vonbrand@sleipnir.valparaiso.cl>
- *
+ *
* Copyright (c) 1999 Dag Brattli, All Rights Reserved.
- *
- * 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.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
+ *
********************************************************************/
#include <linux/string.h>
spin_lock_irqsave(&cachelog->hb_spinlock, flags);
- /*
- * Remove all discoveries of devices that has previously been
- * discovered on the same link with the same name (info), or the
+ /*
+ * Remove all discoveries of devices that has previously been
+ * discovered on the same link with the same name (info), or the
* same daddr. We do this since some devices (mostly PDAs) change
* their device address between every discovery.
*/
discovery = (discovery_t *) hashbin_get_next(cachelog);
if ((node->data.saddr == new->data.saddr) &&
- ((node->data.daddr == new->data.daddr) ||
+ ((node->data.daddr == new->data.daddr) ||
(strcmp(node->data.info, new->data.info) == 0)))
{
- /* This discovery is a previous discovery
+ /* This discovery is a previous discovery
* from the same device, so just remove it
*/
hashbin_remove_this(cachelog, (irda_queue_t *) node);
discovery = (discovery_t *) hashbin_remove_first(log);
}
-
+
/* Delete the now empty log */
hashbin_delete(log, (FREE_FUNC) kfree);
}
while (discovery != NULL) {
IRDA_DEBUG(0, "Discovery:\n");
IRDA_DEBUG(0, " daddr=%08x\n", discovery->data.daddr);
- IRDA_DEBUG(0, " saddr=%08x\n", discovery->data.saddr);
+ IRDA_DEBUG(0, " saddr=%08x\n", discovery->data.saddr);
IRDA_DEBUG(0, " nickname=%s\n", discovery->data.info);
discovery = (discovery_t *) hashbin_get_next(log);
{
discovery_t *discovery;
- for (discovery = (discovery_t *) hashbin_get_first(irlmp->cachelog);
+ for (discovery = (discovery_t *) hashbin_get_first(irlmp->cachelog);
discovery != NULL;
discovery = (discovery_t *) hashbin_get_next(irlmp->cachelog)) {
if (pos-- == 0)
break;
}
-
+
return discovery;
}
static void *discovery_seq_start(struct seq_file *seq, loff_t *pos)
{
spin_lock_irq(&irlmp->cachelog->hb_spinlock);
- return *pos ? discovery_seq_idx(*pos - 1) : SEQ_START_TOKEN;
+ return *pos ? discovery_seq_idx(*pos - 1) : SEQ_START_TOKEN;
}
static void *discovery_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
++*pos;
- return (v == SEQ_START_TOKEN)
+ return (v == SEQ_START_TOKEN)
? (void *) hashbin_get_first(irlmp->cachelog)
: (void *) hashbin_get_next(irlmp->cachelog);
}
else {
const discovery_t *discovery = v;
- seq_printf(seq, "nickname: %s, hint: 0x%02x%02x",
+ seq_printf(seq, "nickname: %s, hint: 0x%02x%02x",
discovery->data.info,
- discovery->data.hints[0],
+ discovery->data.hints[0],
discovery->data.hints[1]);
#if 0
if ( discovery->data.hints[0] & HINT_PNP)
seq_puts(seq, "Fax ");
if ( discovery->data.hints[0] & HINT_LAN)
seq_puts(seq, "LAN Access ");
-
+
if ( discovery->data.hints[1] & HINT_TELEPHONY)
seq_puts(seq, "Telephony ");
if ( discovery->data.hints[1] & HINT_FILE_SERVER)
- seq_puts(seq, "File Server ");
+ seq_puts(seq, "File Server ");
if ( discovery->data.hints[1] & HINT_COMM)
seq_puts(seq, "IrCOMM ");
if ( discovery->data.hints[1] & HINT_OBEX)
seq_puts(seq, "IrOBEX ");
-#endif
+#endif
seq_printf(seq,", saddr: 0x%08x, daddr: 0x%08x\n\n",
discovery->data.saddr,
discovery->data.daddr);
-
+
seq_putc(seq, '\n');
}
return 0;
/*********************************************************************
- *
+ *
* Filename: ircomm_core.c
* Version: 1.0
* Description: IrCOMM service interface
* Created at: Sun Jun 6 20:37:34 1999
* Modified at: Tue Dec 21 13:26:41 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1999 Dag Brattli, 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
+ *
+ * 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.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
+ *
********************************************************************/
#include <linux/module.h>
#include <net/irda/ircomm_core.h>
static int __ircomm_close(struct ircomm_cb *self);
-static void ircomm_control_indication(struct ircomm_cb *self,
+static void ircomm_control_indication(struct ircomm_cb *self,
struct sk_buff *skb, int clen);
#ifdef CONFIG_PROC_FS
static int __init ircomm_init(void)
{
- ircomm = hashbin_new(HB_LOCK);
+ ircomm = hashbin_new(HB_LOCK);
if (ircomm == NULL) {
IRDA_ERROR("%s(), can't allocate hashbin!\n", __FUNCTION__);
return -ENOMEM;
}
-
+
#ifdef CONFIG_PROC_FS
{ struct proc_dir_entry *ent;
ent = create_proc_entry("ircomm", 0, proc_irda);
- if (ent)
+ if (ent)
ent->proc_fops = &ircomm_proc_fops;
}
#endif /* CONFIG_PROC_FS */
-
+
IRDA_MESSAGE("IrCOMM protocol (Dag Brattli)\n");
-
+
return 0;
}
hashbin_insert(ircomm, (irda_queue_t *) self, line, NULL);
- ircomm_next_state(self, IRCOMM_IDLE);
+ ircomm_next_state(self, IRCOMM_IDLE);
return self;
}
entry = hashbin_remove(ircomm, self->line, NULL);
IRDA_ASSERT(entry == self, return -1;);
-
- return __ircomm_close(self);
+
+ return __ircomm_close(self);
}
EXPORT_SYMBOL(ircomm_close);
*
* Impl. of this function is differ from one of the reference. This
* function does discovery as well as sending connect request
- *
+ *
*/
-int ircomm_connect_request(struct ircomm_cb *self, __u8 dlsap_sel,
+int ircomm_connect_request(struct ircomm_cb *self, __u8 dlsap_sel,
__u32 saddr, __u32 daddr, struct sk_buff *skb,
__u8 service_type)
{
struct ircomm_info *info)
{
int clen = 0;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
/* Check if the packet contains data on the control channel */
if (skb->len > 0)
clen = skb->data[0];
-
- /*
- * If there are any data hiding in the control channel, we must
- * deliver it first. The side effect is that the control channel
+
+ /*
+ * If there are any data hiding in the control channel, we must
+ * deliver it first. The side effect is that the control channel
* will be removed from the skb
*/
if (self->notify.connect_indication)
- self->notify.connect_indication(self->notify.instance, self,
+ self->notify.connect_indication(self->notify.instance, self,
info->qos, info->max_data_size,
info->max_header_size, skb);
else {
ret = ircomm_do_event(self, IRCOMM_CONNECT_RESPONSE, userdata, NULL);
return ret;
-}
+}
EXPORT_SYMBOL(ircomm_connect_response);
if (self->notify.connect_confirm )
self->notify.connect_confirm(self->notify.instance,
- self, info->qos,
+ self, info->qos,
info->max_data_size,
info->max_header_size, skb);
else {
IRDA_ASSERT(self != NULL, return -EFAULT;);
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EFAULT;);
IRDA_ASSERT(skb != NULL, return -EFAULT;);
-
+
ret = ircomm_do_event(self, IRCOMM_DATA_REQUEST, skb, NULL);
return ret;
*
*/
void ircomm_data_indication(struct ircomm_cb *self, struct sk_buff *skb)
-{
+{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(skb->len > 0, return;);
clen = skb->data[0];
- /*
- * If there are any data hiding in the control channel, we must
- * deliver it first. The side effect is that the control channel
+ /*
+ * If there are any data hiding in the control channel, we must
+ * deliver it first. The side effect is that the control channel
* will be removed from the skb
*/
if (clen > 0)
skb_pull(skb, clen+1);
if (skb->len)
- ircomm_data_indication(self, skb);
+ ircomm_data_indication(self, skb);
else {
IRDA_DEBUG(4, "%s(), data was control info only!\n",
__FUNCTION__ );
int ircomm_control_request(struct ircomm_cb *self, struct sk_buff *skb)
{
int ret;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return -EFAULT;);
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EFAULT;);
IRDA_ASSERT(skb != NULL, return -EFAULT;);
-
+
ret = ircomm_do_event(self, IRCOMM_CONTROL_REQUEST, skb, NULL);
return ret;
* Data has arrived on the control channel
*
*/
-static void ircomm_control_indication(struct ircomm_cb *self,
+static void ircomm_control_indication(struct ircomm_cb *self,
struct sk_buff *skb, int clen)
{
- IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
+ IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
/* Use udata for delivering data on the control channel */
if (self->notify.udata_indication) {
/* Remove data channel from control channel */
skb_trim(ctrl_skb, clen+1);
-
- self->notify.udata_indication(self->notify.instance, self,
+
+ self->notify.udata_indication(self->notify.instance, self,
ctrl_skb);
/* Drop reference count -
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;);
- ret = ircomm_do_event(self, IRCOMM_DISCONNECT_REQUEST, userdata,
+ ret = ircomm_do_event(self, IRCOMM_DISCONNECT_REQUEST, userdata,
&info);
return ret;
}
struct ircomm_info *info)
{
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(info != NULL, return;);
if (self->notify.disconnect_indication) {
/*
* Function ircomm_flow_request (self, flow)
*
- *
+ *
*
*/
void ircomm_flow_request(struct ircomm_cb *self, LOCAL_FLOW flow)
self = (struct ircomm_cb *) hashbin_get_next(ircomm)) {
if (off++ == *pos)
break;
-
+
}
return self;
}
}
static int ircomm_seq_show(struct seq_file *seq, void *v)
-{
+{
const struct ircomm_cb *self = v;
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EINVAL; );
seq_printf(seq,
" state: %s, slsap_sel: %#02x, dlsap_sel: %#02x, mode:",
ircomm_state[ self->state],
- self->slsap_sel, self->dlsap_sel);
+ self->slsap_sel, self->dlsap_sel);
if(self->service_type & IRCOMM_3_WIRE_RAW)
seq_printf(seq, " 3-wire-raw");
/*********************************************************************
- *
+ *
* Filename: ircomm_event.c
* Version: 1.0
* Description: IrCOMM layer state machine
* Created at: Sun Jun 6 20:33:11 1999
* Modified at: Sun Dec 12 13:44:32 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1999 Dag Brattli, All Rights Reserved.
- *
- * 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.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
+ *
********************************************************************/
#include <linux/sched.h>
#include <net/irda/ircomm_core.h>
#include <net/irda/ircomm_event.h>
-static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event,
+static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event,
struct sk_buff *skb, struct ircomm_info *info);
-static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event,
+static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event,
struct sk_buff *skb, struct ircomm_info *info);
-static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
+static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
struct sk_buff *skb, struct ircomm_info *info);
-static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
+static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
struct sk_buff *skb, struct ircomm_info *info);
char *ircomm_state[] = {
#ifdef CONFIG_IRDA_DEBUG
static char *ircomm_event[] = {
"IRCOMM_CONNECT_REQUEST",
- "IRCOMM_CONNECT_RESPONSE",
- "IRCOMM_TTP_CONNECT_INDICATION",
+ "IRCOMM_CONNECT_RESPONSE",
+ "IRCOMM_TTP_CONNECT_INDICATION",
"IRCOMM_LMP_CONNECT_INDICATION",
- "IRCOMM_TTP_CONNECT_CONFIRM",
+ "IRCOMM_TTP_CONNECT_CONFIRM",
"IRCOMM_LMP_CONNECT_CONFIRM",
- "IRCOMM_LMP_DISCONNECT_INDICATION",
+ "IRCOMM_LMP_DISCONNECT_INDICATION",
"IRCOMM_TTP_DISCONNECT_INDICATION",
- "IRCOMM_DISCONNECT_REQUEST",
+ "IRCOMM_DISCONNECT_REQUEST",
- "IRCOMM_TTP_DATA_INDICATION",
+ "IRCOMM_TTP_DATA_INDICATION",
"IRCOMM_LMP_DATA_INDICATION",
- "IRCOMM_DATA_REQUEST",
- "IRCOMM_CONTROL_REQUEST",
- "IRCOMM_CONTROL_INDICATION",
+ "IRCOMM_DATA_REQUEST",
+ "IRCOMM_CONTROL_REQUEST",
+ "IRCOMM_CONTROL_INDICATION",
};
#endif /* CONFIG_IRDA_DEBUG */
static int (*state[])(struct ircomm_cb *self, IRCOMM_EVENT event,
- struct sk_buff *skb, struct ircomm_info *info) =
+ struct sk_buff *skb, struct ircomm_info *info) =
{
ircomm_state_idle,
ircomm_state_waiti,
* IrCOMM is currently idle
*
*/
-static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event,
+static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event,
struct sk_buff *skb, struct ircomm_info *info)
{
int ret = 0;
switch (event) {
case IRCOMM_CONNECT_REQUEST:
- ircomm_next_state(self, IRCOMM_WAITI);
+ ircomm_next_state(self, IRCOMM_WAITI);
ret = self->issue.connect_request(self, skb, info);
break;
case IRCOMM_TTP_CONNECT_INDICATION:
/*
* Function ircomm_state_waiti (self, event, skb)
*
- * The IrCOMM user has requested an IrCOMM connection to the remote
+ * The IrCOMM user has requested an IrCOMM connection to the remote
* device and is awaiting confirmation
*/
-static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event,
+static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event,
struct sk_buff *skb, struct ircomm_info *info)
{
int ret = 0;
* IrCOMM has received an incoming connection request and is awaiting
* response from the user
*/
-static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
- struct sk_buff *skb, struct ircomm_info *info)
+static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
+ struct sk_buff *skb, struct ircomm_info *info)
{
int ret = 0;
* IrCOMM is connected to the peer IrCOMM device
*
*/
-static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
+static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
struct sk_buff *skb, struct ircomm_info *info)
{
int ret = 0;
*
*/
int ircomm_do_event(struct ircomm_cb *self, IRCOMM_EVENT event,
- struct sk_buff *skb, struct ircomm_info *info)
+ struct sk_buff *skb, struct ircomm_info *info)
{
IRDA_DEBUG(4, "%s: state=%s, event=%s\n", __FUNCTION__ ,
ircomm_state[self->state], ircomm_event[event]);
void ircomm_next_state(struct ircomm_cb *self, IRCOMM_STATE state)
{
self->state = state;
-
- IRDA_DEBUG(4, "%s: next state=%s, service type=%d\n", __FUNCTION__ ,
+
+ IRDA_DEBUG(4, "%s: next state=%s, service type=%d\n", __FUNCTION__ ,
ircomm_state[self->state], self->service_type);
}
/*********************************************************************
- *
+ *
* Filename: ircomm_lmp.c
* Version: 1.0
* Description: Interface between IrCOMM and IrLMP
* Modified at: Sun Dec 12 13:44:17 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
* Sources: Previous IrLPT work by Thomas Davis
- *
+ *
* Copyright (c) 1999 Dag Brattli, 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
+ *
+ * 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.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
+ *
********************************************************************/
#include <linux/sched.h>
/*
* Function ircomm_lmp_connect_request (self, userdata)
*
- *
+ *
*
*/
-static int ircomm_lmp_connect_request(struct ircomm_cb *self,
- struct sk_buff *userdata,
+static int ircomm_lmp_connect_request(struct ircomm_cb *self,
+ struct sk_buff *userdata,
struct ircomm_info *info)
{
int ret = 0;
skb_get(userdata);
ret = irlmp_connect_request(self->lsap, info->dlsap_sel,
- info->saddr, info->daddr, NULL, userdata);
+ info->saddr, info->daddr, NULL, userdata);
return ret;
-}
+}
/*
* Function ircomm_lmp_connect_response (self, skb)
*
- *
+ *
*
*/
static int ircomm_lmp_connect_response(struct ircomm_cb *self,
int ret;
IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
-
+
/* Any userdata supplied? */
if (userdata == NULL) {
tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
/* Reserve space for MUX and LAP header */
skb_reserve(tx_skb, LMP_MAX_HEADER);
} else {
- /*
- * Check that the client has reserved enough space for
+ /*
+ * Check that the client has reserved enough space for
* headers
*/
IRDA_ASSERT(skb_headroom(userdata) >= LMP_MAX_HEADER,
return 0;
}
-static int ircomm_lmp_disconnect_request(struct ircomm_cb *self,
- struct sk_buff *userdata,
+static int ircomm_lmp_disconnect_request(struct ircomm_cb *self,
+ struct sk_buff *userdata,
struct ircomm_info *info)
{
- struct sk_buff *tx_skb;
+ struct sk_buff *tx_skb;
int ret;
IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
- if (!userdata) {
+ if (!userdata) {
tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
if (!tx_skb)
return -ENOMEM;
-
+
/* Reserve space for MUX and LAP header */
- skb_reserve(tx_skb, LMP_MAX_HEADER);
+ skb_reserve(tx_skb, LMP_MAX_HEADER);
userdata = tx_skb;
} else {
/* Don't forget to refcount it - should be NULL anyway */
* Function ircomm_lmp_flow_control (skb)
*
* This function is called when a data frame we have sent to IrLAP has
- * been deallocated. We do this to make sure we don't flood IrLAP with
+ * been deallocated. We do this to make sure we don't flood IrLAP with
* frames, since we are not using the IrTTP flow control mechanism
*/
static void ircomm_lmp_flow_control(struct sk_buff *skb)
cb = (struct irda_skb_cb *) skb->cb;
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
-
- line = cb->line;
+
+ line = cb->line;
self = (struct ircomm_cb *) hashbin_lock_find(ircomm, line, NULL);
- if (!self) {
+ if (!self) {
IRDA_DEBUG(2, "%s(), didn't find myself\n", __FUNCTION__ );
- return;
+ return;
}
- IRDA_ASSERT(self != NULL, return;);
+ IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;);
self->pkt_count--;
- if ((self->pkt_count < 2) && (self->flow_status == FLOW_STOP)) {
- IRDA_DEBUG(2, "%s(), asking TTY to start again!\n", __FUNCTION__ );
- self->flow_status = FLOW_START;
- if (self->notify.flow_indication)
- self->notify.flow_indication(self->notify.instance,
+ if ((self->pkt_count < 2) && (self->flow_status == FLOW_STOP)) {
+ IRDA_DEBUG(2, "%s(), asking TTY to start again!\n", __FUNCTION__ );
+ self->flow_status = FLOW_START;
+ if (self->notify.flow_indication)
+ self->notify.flow_indication(self->notify.instance,
self, FLOW_START);
- }
+ }
}
-
+
/*
* Function ircomm_lmp_data_request (self, userdata)
*
*
*/
static int ircomm_lmp_data_request(struct ircomm_cb *self,
- struct sk_buff *skb,
+ struct sk_buff *skb,
int not_used)
{
struct irda_skb_cb *cb;
IRDA_ASSERT(skb != NULL, return -1;);
cb = (struct irda_skb_cb *) skb->cb;
-
- cb->line = self->line;
+
+ cb->line = self->line;
IRDA_DEBUG(4, "%s(), sending frame\n", __FUNCTION__ );
skb->destructor = ircomm_lmp_flow_control;
- if ((self->pkt_count++ > 7) && (self->flow_status == FLOW_START)) {
+ if ((self->pkt_count++ > 7) && (self->flow_status == FLOW_START)) {
IRDA_DEBUG(2, "%s(), asking TTY to slow down!\n", __FUNCTION__ );
- self->flow_status = FLOW_STOP;
- if (self->notify.flow_indication)
- self->notify.flow_indication(self->notify.instance,
- self, FLOW_STOP);
- }
+ self->flow_status = FLOW_STOP;
+ if (self->notify.flow_indication)
+ self->notify.flow_indication(self->notify.instance,
+ self, FLOW_STOP);
+ }
ret = irlmp_data_request(self->lsap, skb);
if (ret) {
IRDA_ERROR("%s(), failed\n", __FUNCTION__);
struct ircomm_cb *self = (struct ircomm_cb *) instance;
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;);
IRDA_ASSERT(skb != NULL, return -1;);
-
+
ircomm_do_event(self, IRCOMM_LMP_DATA_INDICATION, skb, NULL);
/* Drop reference count - see ircomm_tty_data_indication(). */
}
/*
- * Function ircomm_lmp_connect_confirm (instance, sap, qos, max_sdu_size,
+ * Function ircomm_lmp_connect_confirm (instance, sap, qos, max_sdu_size,
* max_header_size, skb)
*
* Connection has been confirmed by peer device
*
*/
static void ircomm_lmp_connect_confirm(void *instance, void *sap,
- struct qos_info *qos,
- __u32 max_seg_size,
+ struct qos_info *qos,
+ __u32 max_seg_size,
__u8 max_header_size,
struct sk_buff *skb)
{
* Peer device has closed the connection, or the link went down for some
* other reason
*/
-static void ircomm_lmp_disconnect_indication(void *instance, void *sap,
+static void ircomm_lmp_disconnect_indication(void *instance, void *sap,
LM_REASON reason,
struct sk_buff *skb)
{
/*********************************************************************
- *
+ *
* Filename: ircomm_param.c
* Version: 1.0
* Description: Parameter handling for the IrCOMM protocol
* Created at: Mon Jun 7 10:25:11 1999
* Modified at: Sun Jan 30 14:32:03 2000
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
- *
- * 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.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
+ *
********************************************************************/
#include <linux/sched.h>
#include <net/irda/ircomm_param.h>
-static int ircomm_param_service_type(void *instance, irda_param_t *param,
+static int ircomm_param_service_type(void *instance, irda_param_t *param,
int get);
-static int ircomm_param_port_type(void *instance, irda_param_t *param,
+static int ircomm_param_port_type(void *instance, irda_param_t *param,
int get);
-static int ircomm_param_port_name(void *instance, irda_param_t *param,
+static int ircomm_param_port_name(void *instance, irda_param_t *param,
int get);
-static int ircomm_param_service_type(void *instance, irda_param_t *param,
+static int ircomm_param_service_type(void *instance, irda_param_t *param,
int get);
-static int ircomm_param_data_rate(void *instance, irda_param_t *param,
+static int ircomm_param_data_rate(void *instance, irda_param_t *param,
int get);
-static int ircomm_param_data_format(void *instance, irda_param_t *param,
+static int ircomm_param_data_format(void *instance, irda_param_t *param,
int get);
-static int ircomm_param_flow_control(void *instance, irda_param_t *param,
+static int ircomm_param_flow_control(void *instance, irda_param_t *param,
int get);
static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get);
static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get);
-static int ircomm_param_line_status(void *instance, irda_param_t *param,
+static int ircomm_param_line_status(void *instance, irda_param_t *param,
int get);
static int ircomm_param_dte(void *instance, irda_param_t *param, int get);
static int ircomm_param_dce(void *instance, irda_param_t *param, int get);
static pi_major_info_t pi_major_call_table[] = {
{ pi_minor_call_table_common, 3 },
{ pi_minor_call_table_non_raw, 6 },
- { pi_minor_call_table_9_wire, 3 }
+ { pi_minor_call_table_9_wire, 3 }
/* { pi_minor_call_table_centronics } */
};
spin_lock_irqsave(&self->spinlock, flags);
- skb = self->ctrl_skb;
+ skb = self->ctrl_skb;
if (!skb) {
skb = alloc_skb(256, GFP_ATOMIC);
if (!skb) {
spin_unlock_irqrestore(&self->spinlock, flags);
return -ENOMEM;
}
-
+
skb_reserve(skb, self->max_header_size);
self->ctrl_skb = skb;
}
- /*
+ /*
* Inserting is a little bit tricky since we don't know how much
- * room we will need. But this should hopefully work OK
+ * room we will need. But this should hopefully work OK
*/
count = irda_param_insert(self, pi, skb->tail, skb_tailroom(skb),
&ircomm_param_info);
* query and then the remote device sends its initial parameters
*
*/
-static int ircomm_param_service_type(void *instance, irda_param_t *param,
+static int ircomm_param_service_type(void *instance, irda_param_t *param,
int get)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
/* Find all common service types */
service_type &= self->service_type;
if (!service_type) {
- IRDA_DEBUG(2,
+ IRDA_DEBUG(2,
"%s(), No common service type to use!\n", __FUNCTION__ );
return -1;
}
else if (service_type & IRCOMM_3_WIRE_RAW)
self->settings.service_type = IRCOMM_3_WIRE_RAW;
- IRDA_DEBUG(0, "%s(), resulting service type=0x%02x\n", __FUNCTION__ ,
+ IRDA_DEBUG(0, "%s(), resulting service type=0x%02x\n", __FUNCTION__ ,
self->settings.service_type);
- /*
+ /*
* Now the line is ready for some communication. Check if we are a
- * server, and send over some initial parameters.
+ * server, and send over some initial parameters.
* Client do it in ircomm_tty_state_setup().
* Note : we may get called from ircomm_tty_getvalue_confirm(),
* therefore before we even have open any socket. And self->client
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
-
+
if (get)
param->pv.i = IRCOMM_SERIAL;
else {
self->settings.port_type = (__u8) param->pv.i;
- IRDA_DEBUG(0, "%s(), port type=%d\n", __FUNCTION__ ,
+ IRDA_DEBUG(0, "%s(), port type=%d\n", __FUNCTION__ ,
self->settings.port_type);
}
return 0;
static int ircomm_param_port_name(void *instance, irda_param_t *param, int get)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
static int ircomm_param_data_rate(void *instance, irda_param_t *param, int get)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
param->pv.i = self->settings.data_rate;
else
self->settings.data_rate = param->pv.i;
-
+
IRDA_DEBUG(2, "%s(), data rate = %d\n", __FUNCTION__ , param->pv.i);
return 0;
* Exchange data format to be used in this settings
*
*/
-static int ircomm_param_data_format(void *instance, irda_param_t *param,
+static int ircomm_param_data_format(void *instance, irda_param_t *param,
int get)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
param->pv.i = self->settings.data_format;
else
self->settings.data_format = (__u8) param->pv.i;
-
+
return 0;
}
* Exchange flow control settings to be used in this settings
*
*/
-static int ircomm_param_flow_control(void *instance, irda_param_t *param,
+static int ircomm_param_flow_control(void *instance, irda_param_t *param,
int get)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
-
+
if (get)
param->pv.i = self->settings.flow_control;
else
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
-
+
if (get) {
param->pv.i = self->settings.xonxoff[0];
param->pv.i |= self->settings.xonxoff[1] << 8;
self->settings.xonxoff[1] = (__u16) param->pv.i >> 8;
}
- IRDA_DEBUG(0, "%s(), XON/XOFF = 0x%02x,0x%02x\n", __FUNCTION__ ,
+ IRDA_DEBUG(0, "%s(), XON/XOFF = 0x%02x,0x%02x\n", __FUNCTION__ ,
param->pv.i & 0xff, param->pv.i >> 8);
return 0;
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
-
+
if (get) {
param->pv.i = self->settings.enqack[0];
param->pv.i |= self->settings.enqack[1] << 8;
/*
* Function ircomm_param_line_status (self, param)
*
- *
+ *
*
*/
-static int ircomm_param_line_status(void *instance, irda_param_t *param,
+static int ircomm_param_line_status(void *instance, irda_param_t *param,
int get)
{
IRDA_DEBUG(2, "%s(), not impl.\n", __FUNCTION__ );
dte = (__u8) param->pv.i;
self->settings.dce = 0;
-
+
if (dte & IRCOMM_DELTA_DTR)
self->settings.dce |= (IRCOMM_DELTA_DSR|
IRCOMM_DELTA_RI |
self->settings.dce |= (IRCOMM_DSR|
IRCOMM_RI |
IRCOMM_CD);
-
+
if (dte & IRCOMM_DELTA_RTS)
self->settings.dce |= IRCOMM_DELTA_CTS;
if (dte & IRCOMM_RTS)
/*
* Function ircomm_param_dce (instance, param)
*
- *
+ *
*
*/
static int ircomm_param_dce(void *instance, irda_param_t *param, int get)
/*********************************************************************
- *
+ *
* Filename: ircomm_ttp.c
* Version: 1.0
* Description: Interface between IrCOMM and IrTTP
* Created at: Sun Jun 6 20:48:27 1999
* Modified at: Mon Dec 13 11:35:13 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1999 Dag Brattli, 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
+ *
+ * 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.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
+ *
********************************************************************/
#include <linux/sched.h>
static int ircomm_ttp_data_indication(void *instance, void *sap,
struct sk_buff *skb);
static void ircomm_ttp_connect_confirm(void *instance, void *sap,
- struct qos_info *qos,
- __u32 max_sdu_size,
+ struct qos_info *qos,
+ __u32 max_sdu_size,
__u8 max_header_size,
struct sk_buff *skb);
static void ircomm_ttp_connect_indication(void *instance, void *sap,
struct sk_buff *skb);
static void ircomm_ttp_flow_indication(void *instance, void *sap,
LOCAL_FLOW cmd);
-static void ircomm_ttp_disconnect_indication(void *instance, void *sap,
+static void ircomm_ttp_disconnect_indication(void *instance, void *sap,
LM_REASON reason,
struct sk_buff *skb);
static int ircomm_ttp_data_request(struct ircomm_cb *self,
- struct sk_buff *skb,
+ struct sk_buff *skb,
int clen);
-static int ircomm_ttp_connect_request(struct ircomm_cb *self,
- struct sk_buff *userdata,
+static int ircomm_ttp_connect_request(struct ircomm_cb *self,
+ struct sk_buff *userdata,
struct ircomm_info *info);
static int ircomm_ttp_connect_response(struct ircomm_cb *self,
struct sk_buff *userdata);
-static int ircomm_ttp_disconnect_request(struct ircomm_cb *self,
- struct sk_buff *userdata,
+static int ircomm_ttp_disconnect_request(struct ircomm_cb *self,
+ struct sk_buff *userdata,
struct ircomm_info *info);
/*
* Function ircomm_open_tsap (self)
*
- *
+ *
*
*/
int ircomm_open_tsap(struct ircomm_cb *self)
/*
* Function ircomm_ttp_connect_request (self, userdata)
*
- *
+ *
*
*/
-static int ircomm_ttp_connect_request(struct ircomm_cb *self,
- struct sk_buff *userdata,
+static int ircomm_ttp_connect_request(struct ircomm_cb *self,
+ struct sk_buff *userdata,
struct ircomm_info *info)
{
int ret = 0;
skb_get(userdata);
ret = irttp_connect_request(self->tsap, info->dlsap_sel,
- info->saddr, info->daddr, NULL,
- TTP_SAR_DISABLE, userdata);
+ info->saddr, info->daddr, NULL,
+ TTP_SAR_DISABLE, userdata);
return ret;
-}
+}
/*
* Function ircomm_ttp_connect_response (self, skb)
*
- *
+ *
*
*/
static int ircomm_ttp_connect_response(struct ircomm_cb *self,
int ret;
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
/* Don't forget to refcount it - should be NULL anyway */
if(userdata)
skb_get(userdata);
/*
* Function ircomm_ttp_data_request (self, userdata)
*
- * Send IrCOMM data to IrTTP layer. Currently we do not try to combine
- * control data with pure data, so they will be sent as separate frames.
+ * Send IrCOMM data to IrTTP layer. Currently we do not try to combine
+ * control data with pure data, so they will be sent as separate frames.
* Should not be a big problem though, since control frames are rare. But
- * some of them are sent after connection establishment, so this can
+ * some of them are sent after connection establishment, so this can
* increase the latency a bit.
*/
static int ircomm_ttp_data_request(struct ircomm_cb *self,
- struct sk_buff *skb,
+ struct sk_buff *skb,
int clen)
{
int ret;
IRDA_DEBUG(2, "%s(), clen=%d\n", __FUNCTION__ , clen);
- /*
+ /*
* Insert clen field, currently we either send data only, or control
* only frames, to make things easier and avoid queueing
*/
struct ircomm_cb *self = (struct ircomm_cb *) instance;
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;);
IRDA_ASSERT(skb != NULL, return -1;);
}
static void ircomm_ttp_connect_confirm(void *instance, void *sap,
- struct qos_info *qos,
- __u32 max_sdu_size,
+ struct qos_info *qos,
+ __u32 max_sdu_size,
__u8 max_header_size,
struct sk_buff *skb)
{
* Function ircomm_ttp_connect_indication (instance, sap, qos, max_sdu_size,
* max_header_size, skb)
*
- *
+ *
*
*/
static void ircomm_ttp_connect_indication(void *instance, void *sap,
/*
* Function ircomm_ttp_disconnect_request (self, userdata, info)
*
- *
+ *
*
*/
-static int ircomm_ttp_disconnect_request(struct ircomm_cb *self,
- struct sk_buff *userdata,
+static int ircomm_ttp_disconnect_request(struct ircomm_cb *self,
+ struct sk_buff *userdata,
struct ircomm_info *info)
{
int ret;
/*
* Function ircomm_ttp_disconnect_indication (instance, sap, reason, skb)
*
- *
+ *
*
*/
-static void ircomm_ttp_disconnect_indication(void *instance, void *sap,
+static void ircomm_ttp_disconnect_indication(void *instance, void *sap,
LM_REASON reason,
struct sk_buff *skb)
{
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;);
-
+
if (self->notify.flow_indication)
self->notify.flow_indication(self->notify.instance, self, cmd);
}
/*********************************************************************
- *
+ *
* Filename: ircomm_tty.c
* Version: 1.0
* Description: IrCOMM serial TTY driver
* Modified at: Wed Feb 23 00:09:02 2000
* Modified by: Dag Brattli <dagb@cs.uit.no>
* Sources: serial.c and previous IrCOMM work by Takahide Higuchi
- *
+ *
* Copyright (c) 1999-2000 Dag Brattli, 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
+ *
+ * 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.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
+ *
********************************************************************/
#include <linux/init.h>
struct sk_buff *skb);
static int ircomm_tty_control_indication(void *instance, void *sap,
struct sk_buff *skb);
-static void ircomm_tty_flow_indication(void *instance, void *sap,
+static void ircomm_tty_flow_indication(void *instance, void *sap,
LOCAL_FLOW cmd);
#ifdef CONFIG_PROC_FS
static int ircomm_tty_read_proc(char *buf, char **start, off_t offset, int len,
driver = alloc_tty_driver(IRCOMM_TTY_PORTS);
if (!driver)
return -ENOMEM;
- ircomm_tty = hashbin_new(HB_LOCK);
+ ircomm_tty = hashbin_new(HB_LOCK);
if (ircomm_tty == NULL) {
IRDA_ERROR("%s(), can't allocate hashbin!\n", __FUNCTION__);
put_tty_driver(driver);
{
int ret;
- IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
+ IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
ret = tty_unregister_driver(driver);
- if (ret) {
- IRDA_ERROR("%s(), failed to unregister driver\n",
+ if (ret) {
+ IRDA_ERROR("%s(), failed to unregister driver\n",
__FUNCTION__);
return;
}
/*
* Function ircomm_startup (self)
*
- *
+ *
*
*/
static int ircomm_tty_startup(struct ircomm_tty_cb *self)
/* These callbacks we must handle ourselves */
notify.data_indication = ircomm_tty_data_indication;
notify.udata_indication = ircomm_tty_control_indication;
- notify.flow_indication = ircomm_tty_flow_indication;
+ notify.flow_indication = ircomm_tty_flow_indication;
/* Use the ircomm_tty interface for these ones */
- notify.disconnect_indication = ircomm_tty_disconnect_indication;
+ notify.disconnect_indication = ircomm_tty_disconnect_indication;
notify.connect_confirm = ircomm_tty_connect_confirm;
- notify.connect_indication = ircomm_tty_connect_indication;
+ notify.connect_indication = ircomm_tty_connect_indication;
strlcpy(notify.name, "ircomm_tty", sizeof(notify.name));
notify.instance = self;
if (!self->ircomm) {
- self->ircomm = ircomm_open(¬ify, self->service_type,
+ self->ircomm = ircomm_open(¬ify, self->service_type,
self->line);
}
if (!self->ircomm)
/*
* Function ircomm_block_til_ready (self, filp)
*
- *
+ *
*
*/
-static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self,
+static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self,
struct file *filp)
{
DECLARE_WAITQUEUE(wait, current);
int do_clocal = 0, extra_count = 0;
unsigned long flags;
struct tty_struct *tty;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
tty = self->tty;
/*
* If non-blocking mode is set, or the port is not enabled,
* then make the check up front and then exit.
- */
+ */
if (filp->f_flags & O_NONBLOCK || tty->flags & (1 << TTY_IO_ERROR)){
/* nonblock mode is set or port is not enabled */
self->flags |= ASYNC_NORMAL_ACTIVE;
IRDA_DEBUG(1, "%s(), doing CLOCAL!\n", __FUNCTION__ );
do_clocal = 1;
}
-
+
/* Wait for carrier detect and the line to become
* free (i.e., not in use by the callout). While we are in
* this loop, self->open_count is dropped by one, so that
* mgsl_close() knows when to free things. We restore it upon
* exit, either normal or abnormal.
*/
-
+
retval = 0;
add_wait_queue(&self->open_wait, &wait);
-
+
IRDA_DEBUG(2, "%s(%d):block_til_ready before block on %s open_count=%d\n",
__FILE__,__LINE__, tty->driver->name, self->open_count );
}
spin_unlock_irqrestore(&self->spinlock, flags);
self->blocked_open++;
-
+
while (1) {
if (tty->termios->c_cflag & CBAUD) {
/* Here, we use to lock those two guys, but
* I don't see the point (and I see the deadlock).
* Jean II */
self->settings.dte |= IRCOMM_RTS + IRCOMM_DTR;
-
+
ircomm_param_request(self, IRCOMM_DTE, TRUE);
}
-
+
current->state = TASK_INTERRUPTIBLE;
-
+
if (tty_hung_up_p(filp) ||
!test_bit(ASYNC_B_INITIALIZED, &self->flags)) {
retval = (self->flags & ASYNC_HUP_NOTIFY) ?
-EAGAIN : -ERESTARTSYS;
break;
}
-
- /*
+
+ /*
* Check if link is ready now. Even if CLOCAL is
* specified, we cannot return before the IrCOMM link is
- * ready
+ * ready
*/
- if (!test_bit(ASYNC_B_CLOSING, &self->flags) &&
- (do_clocal || (self->settings.dce & IRCOMM_CD)) &&
+ if (!test_bit(ASYNC_B_CLOSING, &self->flags) &&
+ (do_clocal || (self->settings.dce & IRCOMM_CD)) &&
self->state == IRCOMM_TTY_READY)
{
- break;
+ break;
}
-
+
if (signal_pending(current)) {
retval = -ERESTARTSYS;
break;
}
-
+
IRDA_DEBUG(1, "%s(%d):block_til_ready blocking on %s open_count=%d\n",
__FILE__,__LINE__, tty->driver->name, self->open_count );
-
+
schedule();
}
-
+
__set_current_state(TASK_RUNNING);
remove_wait_queue(&self->open_wait, &wait);
-
+
if (extra_count) {
/* ++ is not atomic, so this should be protected - Jean II */
spin_lock_irqsave(&self->spinlock, flags);
spin_unlock_irqrestore(&self->spinlock, flags);
}
self->blocked_open--;
-
+
IRDA_DEBUG(1, "%s(%d):block_til_ready after blocking on %s open_count=%d\n",
__FILE__,__LINE__, tty->driver->name, self->open_count);
-
+
if (!retval)
self->flags |= ASYNC_NORMAL_ACTIVE;
-
- return retval;
+
+ return retval;
}
/*
IRDA_ERROR("%s(), kmalloc failed!\n", __FUNCTION__);
return -ENOMEM;
}
-
+
self->magic = IRCOMM_TTY_MAGIC;
self->flow = FLOW_STOP;
/* Init some important stuff */
init_timer(&self->watchdog_timer);
init_waitqueue_head(&self->open_wait);
- init_waitqueue_head(&self->close_wait);
+ init_waitqueue_head(&self->close_wait);
spin_lock_init(&self->spinlock);
- /*
+ /*
* Force TTY into raw mode by default which is usually what
* we want for IrCOMM and IrLPT. This way applications will
- * not have to twiddle with printcap etc.
+ * not have to twiddle with printcap etc.
*/
tty->termios->c_iflag = 0;
tty->termios->c_oflag = 0;
self->tty = tty;
spin_unlock_irqrestore(&self->spinlock, flags);
- IRDA_DEBUG(1, "%s(), %s%d, count = %d\n", __FUNCTION__ , tty->driver->name,
+ IRDA_DEBUG(1, "%s(), %s%d, count = %d\n", __FUNCTION__ , tty->driver->name,
self->line, self->open_count);
/* Not really used by us, but lets do it anyway */
ret = ircomm_tty_block_til_ready(self, filp);
if (ret) {
- IRDA_DEBUG(2,
+ IRDA_DEBUG(2,
"%s(), returning after block_til_ready with %d\n", __FUNCTION__ ,
ret);
* serial port won't be shutdown.
*/
IRDA_DEBUG(0, "%s(), bad serial port count; "
- "tty->count is 1, state->count is %d\n", __FUNCTION__ ,
+ "tty->count is 1, state->count is %d\n", __FUNCTION__ ,
self->open_count);
self->open_count = 1;
}
spin_unlock_irqrestore(&self->spinlock, flags);
/*
- * Now we wait for the transmit buffer to clear; and we notify
+ * Now we wait for the transmit buffer to clear; and we notify
* the line discipline to only process XON/XOFF characters.
*/
tty->closing = 1;
/*
* Function ircomm_tty_flush_buffer (tty)
*
- *
+ *
*
*/
static void ircomm_tty_flush_buffer(struct tty_struct *tty)
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
- /*
- * Let do_softint() do this to avoid race condition with
- * do_softint() ;-)
+ /*
+ * Let do_softint() do this to avoid race condition with
+ * do_softint() ;-)
*/
schedule_work(&self->tqueue);
}
* Function ircomm_tty_do_softint (work)
*
* We use this routine to give the write wakeup to the user at at a
- * safe time (as fast as possible after write have completed). This
+ * safe time (as fast as possible after write have completed). This
* can be compared to the Tx interrupt.
*/
static void ircomm_tty_do_softint(struct work_struct *work)
/* Unlink transmit buffer */
spin_lock_irqsave(&self->spinlock, flags);
-
+
skb = self->tx_skb;
self->tx_skb = NULL;
/* Drop reference count - see ircomm_ttp_data_request(). */
dev_kfree_skb(skb);
}
-
+
/* Check if user (still) wants to be waken up */
- if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
+ if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
tty->ldisc.write_wakeup)
{
(tty->ldisc.write_wakeup)(tty);
/* Fetch current transmit buffer */
skb = self->tx_skb;
- /*
+ /*
* Send out all the data we get, possibly as multiple fragmented
* frames, but this will only happen if the data is larger than the
* max data size. The normal case however is just the opposite, and
* this function may be called multiple times, and will then actually
- * defragment the data and send it out as one packet as soon as
+ * defragment the data and send it out as one packet as soon as
* possible, but at a safer point in time
*/
while (count) {
/* Adjust data size to the max data size */
if (size > self->max_data_size)
size = self->max_data_size;
-
- /*
+
+ /*
* Do we already have a buffer ready for transmit, or do
- * we need to allocate a new frame
+ * we need to allocate a new frame
*/
- if (skb) {
- /*
- * Any room for more data at the end of the current
+ if (skb) {
+ /*
+ * Any room for more data at the end of the current
* transmit buffer? Cannot use skb_tailroom, since
- * dev_alloc_skb gives us a larger skb than we
+ * dev_alloc_skb gives us a larger skb than we
* requested
* Note : use tx_data_size, because max_data_size
* may have changed and we don't want to overwrite
if (size > tailroom)
size = tailroom;
} else {
- /*
- * Current transmit frame is full, so break
+ /*
+ * Current transmit frame is full, so break
* out, so we can send it as soon as possible
*/
break;
spin_unlock_irqrestore(&self->spinlock, flags);
- /*
+ /*
* Schedule a new thread which will transmit the frame as soon
* as possible, but at a safe point in time. We do this so the
* "user" can give us data multiple times, as PPP does (because of
* its 256 byte tx buffer). We will then defragment and send out
- * all this data as one single packet.
+ * all this data as one single packet.
*/
schedule_work(&self->tqueue);
-
+
return len;
}
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
unsigned long orig_jiffies, poll_time;
unsigned long flags;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return;);
*
* This routine notifies the tty driver that input buffers for the line
* discipline are close to full, and it should somehow signal that no
- * more characters should be sent to the tty.
+ * more characters should be sent to the tty.
*/
static void ircomm_tty_throttle(struct tty_struct *tty)
{
/* Software flow control? */
if (I_IXOFF(tty))
ircomm_tty_send_xchar(tty, STOP_CHAR(tty));
-
+
/* Hardware flow control? */
if (tty->termios->c_cflag & CRTSCTS) {
self->settings.dte &= ~IRCOMM_RTS;
self->settings.dte |= IRCOMM_DELTA_RTS;
-
+
ircomm_param_request(self, IRCOMM_DTE, TRUE);
}
- ircomm_flow_request(self->ircomm, FLOW_STOP);
+ ircomm_flow_request(self->ircomm, FLOW_STOP);
}
/*
ircomm_param_request(self, IRCOMM_DTE, TRUE);
IRDA_DEBUG(1, "%s(), FLOW_START\n", __FUNCTION__ );
}
- ircomm_flow_request(self->ircomm, FLOW_START);
+ ircomm_flow_request(self->ircomm, FLOW_START);
}
/*
spin_lock_irqsave(&self->spinlock, flags);
del_timer(&self->watchdog_timer);
-
+
/* Free parameter buffer */
if (self->ctrl_skb) {
dev_kfree_skb(self->ctrl_skb);
*
* This routine notifies the tty driver that it should hangup the tty
* device.
- *
+ *
*/
static void ircomm_tty_hangup(struct tty_struct *tty)
{
* Function ircomm_tty_start (tty)
*
* This routine notifies the tty driver that it resume sending
- * characters to the tty device.
+ * characters to the tty device.
*/
void ircomm_tty_start(struct tty_struct *tty)
{
* Function ircomm_tty_stop (tty)
*
* This routine notifies the tty driver that it should stop outputting
- * characters to the tty device.
+ * characters to the tty device.
*/
-static void ircomm_tty_stop(struct tty_struct *tty)
+static void ircomm_tty_stop(struct tty_struct *tty)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
/*wake_up_interruptible(&self->delta_msr_wait);*/
}
if ((self->flags & ASYNC_CHECK_CD) && (status & IRCOMM_DELTA_CD)) {
- IRDA_DEBUG(2,
+ IRDA_DEBUG(2,
"%s(), ircomm%d CD now %s...\n", __FUNCTION__ , self->line,
(status & IRCOMM_CD) ? "on" : "off");
if (status & IRCOMM_CD) {
wake_up_interruptible(&self->open_wait);
} else {
- IRDA_DEBUG(2,
+ IRDA_DEBUG(2,
"%s(), Doing serial hangup..\n", __FUNCTION__ );
if (tty)
tty_hangup(tty);
if (self->flags & ASYNC_CTS_FLOW) {
if (tty->hw_stopped) {
if (status & IRCOMM_CTS) {
- IRDA_DEBUG(2,
+ IRDA_DEBUG(2,
"%s(), CTS tx start...\n", __FUNCTION__ );
tty->hw_stopped = 0;
-
+
/* Wake up processes blocked on open */
wake_up_interruptible(&self->open_wait);
}
} else {
if (!(status & IRCOMM_CTS)) {
- IRDA_DEBUG(2,
+ IRDA_DEBUG(2,
"%s(), CTS tx stop...\n", __FUNCTION__ );
tty->hw_stopped = 1;
}
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
IRDA_ASSERT(skb != NULL, return -1;);
return 0;
}
- /*
+ /*
* If we receive data when hardware is stopped then something is wrong.
* We try to poll the peers line settings to check if we are up todate.
- * Devices like WinCE can do this, and since they don't send any
+ * Devices like WinCE can do this, and since they don't send any
* params, we can just as well declare the hardware for running.
*/
if (self->tty->hw_stopped && (self->flow == FLOW_START)) {
ircomm_tty_link_established(self);
}
- /*
+ /*
* Just give it over to the line discipline. There is no need to
- * involve the flip buffers, since we are not running in an interrupt
+ * involve the flip buffers, since we are not running in an interrupt
* handler
*/
self->tty->ldisc.receive_buf(self->tty, skb->data, NULL, skb->len);
int clen;
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
IRDA_ASSERT(skb != NULL, return -1;);
clen = skb->data[0];
- irda_param_extract_all(self, skb->data+1, IRDA_MIN(skb->len-1, clen),
+ irda_param_extract_all(self, skb->data+1, IRDA_MIN(skb->len-1, clen),
&ircomm_param_info);
/* No need to kfree_skb - see ircomm_control_indication() */
* transmission of data. We just mark the hardware as stopped, and wait
* for IrTTP to notify us that things are OK again.
*/
-static void ircomm_tty_flow_indication(void *instance, void *sap,
+static void ircomm_tty_flow_indication(void *instance, void *sap,
LOCAL_FLOW cmd)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
static int ircomm_tty_line_info(struct ircomm_tty_cb *self, char *buf)
{
- int ret=0;
+ int ret=0;
ret += sprintf(buf+ret, "State: %s\n", ircomm_tty_state[self->state]);
ret += sprintf(buf+ret, "3_WIRE_RAW");
else
ret += sprintf(buf+ret, "No common service type!\n");
- ret += sprintf(buf+ret, "\n");
+ ret += sprintf(buf+ret, "\n");
ret += sprintf(buf+ret, "Port name: %s\n", self->settings.port_name);
- ret += sprintf(buf+ret, "DTE status: ");
- if (self->settings.dte & IRCOMM_RTS)
- ret += sprintf(buf+ret, "RTS|");
- if (self->settings.dte & IRCOMM_DTR)
- ret += sprintf(buf+ret, "DTR|");
+ ret += sprintf(buf+ret, "DTE status: ");
+ if (self->settings.dte & IRCOMM_RTS)
+ ret += sprintf(buf+ret, "RTS|");
+ if (self->settings.dte & IRCOMM_DTR)
+ ret += sprintf(buf+ret, "DTR|");
if (self->settings.dte)
ret--; /* remove the last | */
- ret += sprintf(buf+ret, "\n");
+ ret += sprintf(buf+ret, "\n");
ret += sprintf(buf+ret, "DCE status: ");
- if (self->settings.dce & IRCOMM_CTS)
- ret += sprintf(buf+ret, "CTS|");
- if (self->settings.dce & IRCOMM_DSR)
- ret += sprintf(buf+ret, "DSR|");
- if (self->settings.dce & IRCOMM_CD)
- ret += sprintf(buf+ret, "CD|");
- if (self->settings.dce & IRCOMM_RI)
- ret += sprintf(buf+ret, "RI|");
+ if (self->settings.dce & IRCOMM_CTS)
+ ret += sprintf(buf+ret, "CTS|");
+ if (self->settings.dce & IRCOMM_DSR)
+ ret += sprintf(buf+ret, "DSR|");
+ if (self->settings.dce & IRCOMM_CD)
+ ret += sprintf(buf+ret, "CD|");
+ if (self->settings.dce & IRCOMM_RI)
+ ret += sprintf(buf+ret, "RI|");
if (self->settings.dce)
ret--; /* remove the last | */
- ret += sprintf(buf+ret, "\n");
+ ret += sprintf(buf+ret, "\n");
ret += sprintf(buf+ret, "Configuration: ");
if (!self->settings.null_modem)
ret += sprintf(buf+ret, "DTE <-> DCE\n");
else
- ret += sprintf(buf+ret,
+ ret += sprintf(buf+ret,
"DTE <-> DTE (null modem emulation)\n");
ret += sprintf(buf+ret, "Data rate: %d\n", self->settings.data_rate);
ret += sprintf(buf+ret, "ENQ_ACK_OUT|");
if (self->settings.flow_control)
ret--; /* remove the last | */
- ret += sprintf(buf+ret, "\n");
+ ret += sprintf(buf+ret, "\n");
ret += sprintf(buf+ret, "Flags: ");
if (self->flags & ASYNC_CTS_FLOW)
ret--; /* remove the last | */
ret += sprintf(buf+ret, "\n");
- ret += sprintf(buf+ret, "Role: %s\n", self->client ?
+ ret += sprintf(buf+ret, "Role: %s\n", self->client ?
"client" : "server");
ret += sprintf(buf+ret, "Open count: %d\n", self->open_count);
ret += sprintf(buf+ret, "Max data size: %d\n", self->max_data_size);
ret += sprintf(buf+ret, "Max header size: %d\n", self->max_header_size);
-
+
if (self->tty)
- ret += sprintf(buf+ret, "Hardware: %s\n",
+ ret += sprintf(buf+ret, "Hardware: %s\n",
self->tty->hw_stopped ? "Stopped" : "Running");
- ret += sprintf(buf+ret, "\n");
- return ret;
+ ret += sprintf(buf+ret, "\n");
+ return ret;
}
/*
* Function ircomm_tty_read_proc (buf, start, offset, len, eof, unused)
*
- *
+ *
*
*/
#ifdef CONFIG_PROC_FS
int *eof, void *unused)
{
struct ircomm_tty_cb *self;
- int count = 0, l;
- off_t begin = 0;
+ int count = 0, l;
+ off_t begin = 0;
unsigned long flags;
spin_lock_irqsave(&ircomm_tty->hb_spinlock, flags);
if (self->magic != IRCOMM_TTY_MAGIC)
break;
- l = ircomm_tty_line_info(self, buf + count);
- count += l;
- if (count+begin > offset+len)
- goto done;
- if (count+begin < offset) {
- begin += count;
- count = 0;
- }
-
+ l = ircomm_tty_line_info(self, buf + count);
+ count += l;
+ if (count+begin > offset+len)
+ goto done;
+ if (count+begin < offset) {
+ begin += count;
+ count = 0;
+ }
+
self = (struct ircomm_tty_cb *) hashbin_get_next(ircomm_tty);
- }
- *eof = 1;
+ }
+ *eof = 1;
done:
spin_unlock_irqrestore(&ircomm_tty->hb_spinlock, flags);
- if (offset >= count+begin)
- return 0;
- *start = buf + (offset-begin);
- return ((len < begin+count-offset) ? len : begin+count-offset);
+ if (offset >= count+begin)
+ return 0;
+ *start = buf + (offset-begin);
+ return ((len < begin+count-offset) ? len : begin+count-offset);
}
#endif /* CONFIG_PROC_FS */
/*********************************************************************
- *
+ *
* Filename: ircomm_tty_attach.c
- * Version:
+ * Version:
* Description: Code for attaching the serial driver to IrCOMM
* Status: Experimental.
* Author: Dag Brattli <dagb@cs.uit.no>
* Created at: Sat Jun 5 17:42:00 1999
* Modified at: Tue Jan 4 14:20:49 2000
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1999-2000 Dag Brattli, 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
+ *
+ * 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.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
+ *
********************************************************************/
#include <linux/sched.h>
static void ircomm_tty_discovery_indication(discinfo_t *discovery,
DISCOVERY_MODE mode,
void *priv);
-static void ircomm_tty_getvalue_confirm(int result, __u16 obj_id,
+static void ircomm_tty_getvalue_confirm(int result, __u16 obj_id,
struct ias_value *value, void *priv);
static void ircomm_tty_start_watchdog_timer(struct ircomm_tty_cb *self,
int timeout);
static void ircomm_tty_watchdog_timer_expired(void *data);
-static int ircomm_tty_state_idle(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_idle(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info);
-static int ircomm_tty_state_search(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_search(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info);
-static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info);
-static int ircomm_tty_state_query_lsap_sel(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_query_lsap_sel(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info);
-static int ircomm_tty_state_setup(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_setup(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info);
-static int ircomm_tty_state_ready(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_ready(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info);
char *ircomm_tty_state[] = {
#endif /* CONFIG_IRDA_DEBUG */
static int (*state[])(struct ircomm_tty_cb *self, IRCOMM_TTY_EVENT event,
- struct sk_buff *skb, struct ircomm_tty_info *info) =
+ struct sk_buff *skb, struct ircomm_tty_info *info) =
{
ircomm_tty_state_idle,
ircomm_tty_state_search,
* Function ircomm_tty_attach_cable (driver)
*
* Try to attach cable (IrCOMM link). This function will only return
- * when the link has been connected, or if an error condition occurs.
+ * when the link has been connected, or if an error condition occurs.
* If success, the return value is the resulting service type.
*/
int ircomm_tty_attach_cable(struct ircomm_tty_cb *self)
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
- /* Check if somebody has already connected to us */
+ /* Check if somebody has already connected to us */
if (ircomm_is_connected(self->ircomm)) {
IRDA_DEBUG(0, "%s(), already connected!\n", __FUNCTION__ );
return 0;
self->skey = NULL;
}
- if (self->iriap) {
+ if (self->iriap) {
iriap_close(self->iriap);
self->iriap = NULL;
}
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
-
+
/* Compute hint bits based on service */
hints = irlmp_service_to_hint(S_COMM);
if (self->service_type & IRCOMM_3_WIRE_RAW)
if (self->service_type & IRCOMM_3_WIRE_RAW) {
/* Register IrLPT with LM-IAS */
self->obj = irias_new_object("IrLPT", IAS_IRLPT_ID);
- irias_add_integer_attrib(self->obj, "IrDA:IrLMP:LsapSel",
+ irias_add_integer_attrib(self->obj, "IrDA:IrLMP:LsapSel",
self->slsap_sel, IAS_KERNEL_ATTR);
} else {
/* Register IrCOMM with LM-IAS */
self->obj = irias_new_object("IrDA:IrCOMM", IAS_IRCOMM_ID);
- irias_add_integer_attrib(self->obj, "IrDA:TinyTP:LsapSel",
+ irias_add_integer_attrib(self->obj, "IrDA:TinyTP:LsapSel",
self->slsap_sel, IAS_KERNEL_ATTR);
-
+
/* Code the parameters into the buffer */
- irda_param_pack(oct_seq, "bbbbbb",
+ irda_param_pack(oct_seq, "bbbbbb",
IRCOMM_SERVICE_TYPE, 1, self->service_type,
IRCOMM_PORT_TYPE, 1, IRCOMM_SERIAL);
-
+
/* Register parameters with LM-IAS */
irias_add_octseq_attrib(self->obj, "Parameters", oct_seq, 6,
IAS_KERNEL_ATTR);
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
- if (self->service_type & IRCOMM_3_WIRE_RAW)
+ if (self->service_type & IRCOMM_3_WIRE_RAW)
return 0;
- /*
- * Set default values, but only if the application for some reason
+ /*
+ * Set default values, but only if the application for some reason
* haven't set them already
*/
- IRDA_DEBUG(2, "%s(), data-rate = %d\n", __FUNCTION__ ,
+ IRDA_DEBUG(2, "%s(), data-rate = %d\n", __FUNCTION__ ,
self->settings.data_rate);
if (!self->settings.data_rate)
self->settings.data_rate = 9600;
- IRDA_DEBUG(2, "%s(), data-format = %d\n", __FUNCTION__ ,
+ IRDA_DEBUG(2, "%s(), data-format = %d\n", __FUNCTION__ ,
self->settings.data_format);
if (!self->settings.data_format)
self->settings.data_format = IRCOMM_WSIZE_8; /* 8N1 */
- IRDA_DEBUG(2, "%s(), flow-control = %d\n", __FUNCTION__ ,
+ IRDA_DEBUG(2, "%s(), flow-control = %d\n", __FUNCTION__ ,
self->settings.flow_control);
/*self->settings.flow_control = IRCOMM_RTS_CTS_IN|IRCOMM_RTS_CTS_OUT;*/
ircomm_param_request(self, IRCOMM_SERVICE_TYPE, FALSE);
ircomm_param_request(self, IRCOMM_DATA_RATE, FALSE);
ircomm_param_request(self, IRCOMM_DATA_FORMAT, FALSE);
-
+
/* For a 3 wire service, we just flush the last parameter and return */
if (self->settings.service_type == IRCOMM_3_WIRE) {
ircomm_param_request(self, IRCOMM_FLOW_CONTROL, TRUE);
#if 0
ircomm_param_request(self, IRCOMM_XON_XOFF, FALSE);
ircomm_param_request(self, IRCOMM_ENQ_ACK, FALSE);
-#endif
+#endif
/* Notify peer that we are ready to receive data */
ircomm_param_request(self, IRCOMM_DTE, TRUE);
-
+
return 0;
}
self = (struct ircomm_tty_cb *) hashbin_get_first(ircomm_tty);
while (self != NULL) {
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
-
- ircomm_tty_do_event(self, IRCOMM_TTY_DISCOVERY_INDICATION,
+
+ ircomm_tty_do_event(self, IRCOMM_TTY_DISCOVERY_INDICATION,
NULL, &info);
self = (struct ircomm_tty_cb *) hashbin_get_next(ircomm_tty);
* Link disconnected
*
*/
-void ircomm_tty_disconnect_indication(void *instance, void *sap,
+void ircomm_tty_disconnect_indication(void *instance, void *sap,
LM_REASON reason,
struct sk_buff *skb)
{
/* Stop data transfers */
self->tty->hw_stopped = 1;
- ircomm_tty_do_event(self, IRCOMM_TTY_DISCONNECT_INDICATION, NULL,
+ ircomm_tty_do_event(self, IRCOMM_TTY_DISCONNECT_INDICATION, NULL,
NULL);
}
* Got result from the IAS query we make
*
*/
-static void ircomm_tty_getvalue_confirm(int result, __u16 obj_id,
- struct ias_value *value,
+static void ircomm_tty_getvalue_confirm(int result, __u16 obj_id,
+ struct ias_value *value,
void *priv)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) priv;
}
switch (value->type) {
- case IAS_OCT_SEQ:
+ case IAS_OCT_SEQ:
IRDA_DEBUG(2, "%s(), got octet sequence\n", __FUNCTION__ );
irda_param_extract_all(self, value->t.oct_seq, value->len,
&ircomm_param_info);
- ircomm_tty_do_event(self, IRCOMM_TTY_GOT_PARAMETERS, NULL,
+ ircomm_tty_do_event(self, IRCOMM_TTY_GOT_PARAMETERS, NULL,
NULL);
break;
case IAS_INTEGER:
- /* Got LSAP selector */
- IRDA_DEBUG(2, "%s(), got lsapsel = %d\n", __FUNCTION__ ,
+ /* Got LSAP selector */
+ IRDA_DEBUG(2, "%s(), got lsapsel = %d\n", __FUNCTION__ ,
value->t.integer);
if (value->t.integer == -1) {
* Connection confirmed
*
*/
-void ircomm_tty_connect_confirm(void *instance, void *sap,
- struct qos_info *qos,
- __u32 max_data_size,
- __u8 max_header_size,
+void ircomm_tty_connect_confirm(void *instance, void *sap,
+ struct qos_info *qos,
+ __u32 max_data_size,
+ __u8 max_header_size,
struct sk_buff *skb)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
}
/*
- * Function ircomm_tty_connect_indication (instance, sap, qos, max_sdu_size,
+ * Function ircomm_tty_connect_indication (instance, sap, qos, max_sdu_size,
* skb)
*
* we are discovered and being requested to connect by remote device !
*
*/
-void ircomm_tty_connect_indication(void *instance, void *sap,
- struct qos_info *qos,
+void ircomm_tty_connect_indication(void *instance, void *sap,
+ struct qos_info *qos,
__u32 max_data_size,
- __u8 max_header_size,
+ __u8 max_header_size,
struct sk_buff *skb)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
clen = skb->data[0];
if (clen)
- irda_param_extract_all(self, skb->data+1,
- IRDA_MIN(skb->len, clen),
+ irda_param_extract_all(self, skb->data+1,
+ IRDA_MIN(skb->len, clen),
&ircomm_param_info);
ircomm_tty_do_event(self, IRCOMM_TTY_CONNECT_INDICATION, NULL, NULL);
if (!self->tty)
return;
-
+
del_timer(&self->watchdog_timer);
- /*
+ /*
* IrCOMM link is now up, and if we are not using hardware
* flow-control, then declare the hardware as running. Otherwise we
* will have to wait for the peer device (DCE) to raise the CTS
- * line.
+ * line.
*/
if ((self->flags & ASYNC_CTS_FLOW) && ((self->settings.dce & IRCOMM_CTS) == 0)) {
IRDA_DEBUG(0, "%s(), waiting for CTS ...\n", __FUNCTION__ );
IRDA_DEBUG(1, "%s(), starting hardware!\n", __FUNCTION__ );
self->tty->hw_stopped = 0;
-
+
/* Wake up processes blocked on open */
wake_up_interruptible(&self->open_wait);
}
/*
* Function ircomm_tty_start_watchdog_timer (self, timeout)
*
- * Start the watchdog timer. This timer is used to make sure that any
- * connection attempt is successful, and if not, we will retry after
+ * Start the watchdog timer. This timer is used to make sure that any
+ * connection attempt is successful, and if not, we will retry after
* the timeout
*/
static void ircomm_tty_start_watchdog_timer(struct ircomm_tty_cb *self,
static void ircomm_tty_watchdog_timer_expired(void *data)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) data;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return;);
*
*/
int ircomm_tty_do_event(struct ircomm_tty_cb *self, IRCOMM_TTY_EVENT event,
- struct sk_buff *skb, struct ircomm_tty_info *info)
+ struct sk_buff *skb, struct ircomm_tty_info *info)
{
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
IRDA_DEBUG(2, "%s: state=%s, event=%s\n", __FUNCTION__ ,
ircomm_tty_state[self->state], ircomm_tty_event[event]);
-
+
return (*state[self->state])(self, event, skb, info);
}
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
- IRDA_DEBUG(2, "%s: next state=%s, service type=%d\n", __FUNCTION__ ,
+ IRDA_DEBUG(2, "%s: next state=%s, service type=%d\n", __FUNCTION__ ,
ircomm_tty_state[self->state], self->service_type);
*/
self->state = state;
* Just hanging around
*
*/
-static int ircomm_tty_state_idle(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_idle(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info)
{
int ret = 0;
ircomm_tty_state[self->state], ircomm_tty_event[event]);
switch (event) {
case IRCOMM_TTY_ATTACH_CABLE:
- /* Try to discover any remote devices */
+ /* Try to discover any remote devices */
ircomm_tty_start_watchdog_timer(self, 3*HZ);
ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH);
-
+
irlmp_discovery_request(DISCOVERY_DEFAULT_SLOTS);
break;
case IRCOMM_TTY_DISCOVERY_INDICATION:
iriap_getvaluebyclass_request(self->iriap,
self->saddr, self->daddr,
"IrDA:IrCOMM", "Parameters");
-
+
ircomm_tty_start_watchdog_timer(self, 3*HZ);
ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_PARAMETERS);
break;
* Trying to discover an IrCOMM device
*
*/
-static int ircomm_tty_state_search(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_search(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info)
{
int ret = 0;
__FUNCTION__);
return -EBUSY;
}
-
+
self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
ircomm_tty_getvalue_confirm);
-
+
if (self->service_type == IRCOMM_3_WIRE_RAW) {
iriap_getvaluebyclass_request(self->iriap, self->saddr,
- self->daddr, "IrLPT",
+ self->daddr, "IrLPT",
"IrDA:IrLMP:LsapSel");
ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_LSAP_SEL);
} else {
iriap_getvaluebyclass_request(self->iriap, self->saddr,
- self->daddr,
- "IrDA:IrCOMM",
+ self->daddr,
+ "IrDA:IrCOMM",
"Parameters");
ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_PARAMETERS);
#if 1
/* Give up */
#else
- /* Try to discover any remote devices */
+ /* Try to discover any remote devices */
ircomm_tty_start_watchdog_timer(self, 3*HZ);
irlmp_discovery_request(DISCOVERY_DEFAULT_SLOTS);
#endif
* Querying the remote LM-IAS for IrCOMM parameters
*
*/
-static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info)
{
int ret = 0;
__FUNCTION__);
return -EBUSY;
}
-
+
self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
ircomm_tty_getvalue_confirm);
- iriap_getvaluebyclass_request(self->iriap, self->saddr,
- self->daddr, "IrDA:IrCOMM",
+ iriap_getvaluebyclass_request(self->iriap, self->saddr,
+ self->daddr, "IrDA:IrCOMM",
"IrDA:TinyTP:LsapSel");
ircomm_tty_start_watchdog_timer(self, 3*HZ);
case IRCOMM_TTY_WD_TIMER_EXPIRED:
/* Go back to search mode */
ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH);
- ircomm_tty_start_watchdog_timer(self, 3*HZ);
+ ircomm_tty_start_watchdog_timer(self, 3*HZ);
break;
case IRCOMM_TTY_CONNECT_INDICATION:
del_timer(&self->watchdog_timer);
* Query remote LM-IAS for the LSAP selector which we can connect to
*
*/
-static int ircomm_tty_state_query_lsap_sel(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_query_lsap_sel(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info)
{
int ret = 0;
case IRCOMM_TTY_GOT_LSAPSEL:
/* Connect to remote device */
ret = ircomm_connect_request(self->ircomm, self->dlsap_sel,
- self->saddr, self->daddr,
+ self->saddr, self->daddr,
NULL, self->service_type);
ircomm_tty_start_watchdog_timer(self, 3*HZ);
ircomm_tty_next_state(self, IRCOMM_TTY_SETUP);
* Trying to connect
*
*/
-static int ircomm_tty_state_setup(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_setup(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info)
{
int ret = 0;
case IRCOMM_TTY_CONNECT_CONFIRM:
del_timer(&self->watchdog_timer);
ircomm_tty_ias_unregister(self);
-
- /*
+
+ /*
* Send initial parameters. This will also send out queued
- * parameters waiting for the connection to come up
+ * parameters waiting for the connection to come up
*/
ircomm_tty_send_initial_parameters(self);
ircomm_tty_link_established(self);
case IRCOMM_TTY_CONNECT_INDICATION:
del_timer(&self->watchdog_timer);
ircomm_tty_ias_unregister(self);
-
+
/* Accept connection */
ircomm_connect_response(self->ircomm, NULL);
ircomm_tty_next_state(self, IRCOMM_TTY_READY);
* IrCOMM is now connected
*
*/
-static int ircomm_tty_state_ready(struct ircomm_tty_cb *self,
- IRCOMM_TTY_EVENT event,
- struct sk_buff *skb,
+static int ircomm_tty_state_ready(struct ircomm_tty_cb *self,
+ IRCOMM_TTY_EVENT event,
+ struct sk_buff *skb,
struct ircomm_tty_info *info)
{
int ret = 0;
switch (event) {
case IRCOMM_TTY_DATA_REQUEST:
ret = ircomm_data_request(self->ircomm, skb);
- break;
+ break;
case IRCOMM_TTY_DETACH_CABLE:
ircomm_disconnect_request(self->ircomm, NULL);
ircomm_tty_next_state(self, IRCOMM_TTY_IDLE);
/*********************************************************************
- *
+ *
* Filename: ircomm_tty_ioctl.c
- * Version:
- * Description:
+ * Version:
+ * Description:
* Status: Experimental.
* Author: Dag Brattli <dagb@cs.uit.no>
* Created at: Thu Jun 10 14:39:09 1999
* Modified at: Wed Jan 5 14:45:43 2000
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
- *
- * 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.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
+ *
********************************************************************/
#include <linux/init.h>
}
if (cflag & CSTOPB)
cval |= IRCOMM_2_STOP_BIT;
-
+
if (cflag & PARENB)
cval |= IRCOMM_PARITY_ENABLE;
if (!(cflag & PARODD))
self->settings.data_rate = baud;
ircomm_param_request(self, IRCOMM_DATA_RATE, FALSE);
-
+
/* CTS flow control flag and modem status interrupts */
if (cflag & CRTSCTS) {
self->flags |= ASYNC_CTS_FLOW;
self->flags &= ~ASYNC_CHECK_CD;
else
self->flags |= ASYNC_CHECK_CD;
-#if 0
+#if 0
/*
* Set up parity check flag
*/
driver->read_status_mask |= LSR_FE | LSR_PE;
if (I_BRKINT(driver->tty) || I_PARMRK(driver->tty))
driver->read_status_mask |= LSR_BI;
-
+
/*
* Characters to ignore
*/
if (I_IGNBRK(self->tty)) {
self->ignore_status_mask |= LSR_BI;
/*
- * If we're ignore parity and break indicators, ignore
+ * If we're ignore parity and break indicators, ignore
* overruns too. (For real raw support).
*/
- if (I_IGNPAR(self->tty))
+ if (I_IGNPAR(self->tty))
self->ignore_status_mask |= LSR_OE;
}
#endif
self->settings.data_format = cval;
ircomm_param_request(self, IRCOMM_DATA_FORMAT, FALSE);
- ircomm_param_request(self, IRCOMM_FLOW_CONTROL, TRUE);
+ ircomm_param_request(self, IRCOMM_FLOW_CONTROL, TRUE);
}
/*
* should be prepared to accept the case where old == NULL, and try to
* do something rational.
*/
-void ircomm_tty_set_termios(struct tty_struct *tty,
+void ircomm_tty_set_termios(struct tty_struct *tty,
struct ktermios *old_termios)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
- if ((cflag == old_termios->c_cflag) &&
- (RELEVANT_IFLAG(tty->termios->c_iflag) ==
+ if ((cflag == old_termios->c_cflag) &&
+ (RELEVANT_IFLAG(tty->termios->c_iflag) ==
RELEVANT_IFLAG(old_termios->c_iflag)))
{
return;
self->settings.dte &= ~(IRCOMM_DTR|IRCOMM_RTS);
ircomm_param_request(self, IRCOMM_DTE, TRUE);
}
-
+
/* Handle transition away from B0 status */
if (!(old_termios->c_cflag & CBAUD) &&
(cflag & CBAUD)) {
self->settings.dte |= IRCOMM_DTR;
- if (!(tty->termios->c_cflag & CRTSCTS) ||
+ if (!(tty->termios->c_cflag & CRTSCTS) ||
!test_bit(TTY_THROTTLED, &tty->flags)) {
self->settings.dte |= IRCOMM_RTS;
}
ircomm_param_request(self, IRCOMM_DTE, TRUE);
}
-
+
/* Handle turning off CRTSCTS */
if ((old_termios->c_cflag & CRTSCTS) &&
- !(tty->termios->c_cflag & CRTSCTS))
+ !(tty->termios->c_cflag & CRTSCTS))
{
tty->hw_stopped = 0;
ircomm_tty_start(tty);
/*
* Function ircomm_tty_tiocmget (tty, file)
*
- *
+ *
*
*/
int ircomm_tty_tiocmget(struct tty_struct *tty, struct file *file)
/*
* Function ircomm_tty_tiocmset (tty, file, set, clear)
*
- *
+ *
*
*/
int ircomm_tty_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
-{
+{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
self->settings.dte |= IRCOMM_DELTA_DTR;
ircomm_param_request(self, IRCOMM_DTE, TRUE);
-
+
return 0;
}
/*
* Function get_serial_info (driver, retinfo)
*
- *
+ *
*
*/
static int ircomm_tty_get_serial_info(struct ircomm_tty_cb *self,
struct serial_struct __user *retinfo)
{
struct serial_struct info;
-
+
if (!retinfo)
return -EFAULT;
info.closing_wait = self->closing_wait;
/* For compatibility */
- info.type = PORT_16550A;
- info.port = 0;
- info.irq = 0;
+ info.type = PORT_16550A;
+ info.port = 0;
+ info.irq = 0;
info.xmit_fifo_size = 0;
- info.hub6 = 0;
+ info.hub6 = 0;
info.custom_divisor = 0;
if (copy_to_user(retinfo, &info, sizeof(*retinfo)))
/*
* Function set_serial_info (driver, new_info)
*
- *
+ *
*
*/
static int ircomm_tty_set_serial_info(struct ircomm_tty_cb *self,
state = self
old_state = *self;
-
+
if (!capable(CAP_SYS_ADMIN)) {
if ((new_serial.baud_base != state->settings.data_rate) ||
(new_serial.close_delay != state->close_delay) ||
/*
* Function ircomm_tty_ioctl (tty, file, cmd, arg)
*
- *
+ *
*
*/
-int ircomm_tty_ioctl(struct tty_struct *tty, struct file *file,
+int ircomm_tty_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
put_user(cnow.brk, &p_cuser->brk) ||
put_user(cnow.buf_overrun, &p_cuser->buf_overrun))
return -EFAULT;
-#endif
+#endif
return 0;
default:
ret = -ENOIOCTLCMD; /* ioctls which we must ignore */
*/
static void irda_device_setup(struct net_device *dev)
{
- dev->hard_header_len = 0;
- dev->addr_len = LAP_ALEN;
+ dev->hard_header_len = 0;
+ dev->addr_len = LAP_ALEN;
- dev->type = ARPHRD_IRDA;
- dev->tx_queue_len = 8; /* Window size + 1 s-frame */
+ dev->type = ARPHRD_IRDA;
+ dev->tx_queue_len = 8; /* Window size + 1 s-frame */
memset(dev->broadcast, 0xff, LAP_ALEN);
}
/*
- * Funciton alloc_irdadev
+ * Funciton alloc_irdadev
* Allocates and sets up an IRDA device in a manner similar to
* alloc_etherdev.
*/
/* Try to load the module needed */
if (!reg && capable(CAP_SYS_MODULE)) {
spin_unlock(&dongles->hb_spinlock);
-
+
request_module("irda-dongle-%d", type);
-
+
spin_lock(&dongles->hb_spinlock);
reg = hashbin_find(dongles, type, NULL);
}
spin_lock(&dongles->hb_spinlock);
/* Check if this dongle has been registered before */
if (hashbin_find(dongles, new->type, NULL)) {
- IRDA_MESSAGE("%s: Dongle type %x already registered\n",
+ IRDA_MESSAGE("%s: Dongle type %x already registered\n",
__FUNCTION__, new->type);
- } else {
+ } else {
/* Insert IrDA dongle into hashbin */
hashbin_insert(dongles, (irda_queue_t *) new, new->type, NULL);
}
spin_unlock(&dongles->hb_spinlock);
- return 0;
+ return 0;
}
EXPORT_SYMBOL(irda_device_register_dongle);
spin_lock(&dongles->hb_spinlock);
node = hashbin_remove(dongles, dongle->type, NULL);
- if (!node)
+ if (!node)
IRDA_ERROR("%s: dongle not found!\n", __FUNCTION__);
spin_unlock(&dongles->hb_spinlock);
}
static void iriap_watchdog_timer_expired(void *data);
-static inline void iriap_start_watchdog_timer(struct iriap_cb *self,
- int timeout)
+static inline void iriap_start_watchdog_timer(struct iriap_cb *self,
+ int timeout)
{
- irda_start_timer(&self->watchdog_timer, timeout, self,
+ irda_start_timer(&self->watchdog_timer, timeout, self,
iriap_watchdog_timer_expired);
}
if (attrib == NULL) {
IRDA_DEBUG(2, "LM-IAS: Attribute %s not found\n", attr);
iriap_getvaluebyclass_response(self, obj->id,
- IAS_ATTRIB_UNKNOWN,
+ IAS_ATTRIB_UNKNOWN,
&irias_missing);
return;
}
"IAS_STRING"
};
-static inline struct ias_object *irias_seq_idx(loff_t pos)
+static inline struct ias_object *irias_seq_idx(loff_t pos)
{
struct ias_object *obj;
if (pos-- == 0)
break;
}
-
+
return obj;
}
{
++*pos;
- return (v == SEQ_START_TOKEN)
+ return (v == SEQ_START_TOKEN)
? (void *) hashbin_get_first(irias_objects)
: (void *) hashbin_get_next(irias_objects);
}
for (attrib = (struct ias_attrib *) hashbin_get_first(obj->attribs);
attrib != NULL;
attrib = (struct ias_attrib *) hashbin_get_next(obj->attribs)) {
-
+
IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC,
goto outloop; );
attrib->value->t.string);
break;
case IAS_OCT_SEQ:
- seq_printf(seq, "octet sequence (%d bytes)\n",
+ seq_printf(seq, "octet sequence (%d bytes)\n",
attrib->value->len);
break;
case IAS_MISSING:
seq_puts(seq, "missing\n");
break;
default:
- seq_printf(seq, "type %d?\n",
+ seq_printf(seq, "type %d?\n",
attrib->value->type);
}
seq_putc(seq, '\n');
len = max;
/* Allocate new string */
- new_str = kmalloc(len + 1, GFP_ATOMIC);
- if (new_str == NULL) {
+ new_str = kmalloc(len + 1, GFP_ATOMIC);
+ if (new_str == NULL) {
IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
return NULL;
}
*/
struct ias_object *irias_new_object( char *name, int id)
{
- struct ias_object *obj;
+ struct ias_object *obj;
IRDA_DEBUG( 4, "%s()\n", __FUNCTION__);
/*********************************************************************
- *
+ *
* Filename: irlan_client.c
* Version: 0.9
* Description: IrDA LAN Access Protocol (IrLAN) Client
* Sources: skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
* slip.c by Laurence Culhane, <loz@holmes.demon.co.uk>
* Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
- *
- * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
+ *
+ * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
* All Rights Reserved.
- *
- * 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.
*
********************************************************************/
#undef CONFIG_IRLAN_GRATUITOUS_ARP
-static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap,
- LM_REASON reason,
+static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap,
+ LM_REASON reason,
struct sk_buff *);
-static int irlan_client_ctrl_data_indication(void *instance, void *sap,
+static int irlan_client_ctrl_data_indication(void *instance, void *sap,
struct sk_buff *skb);
-static void irlan_client_ctrl_connect_confirm(void *instance, void *sap,
- struct qos_info *qos,
+static void irlan_client_ctrl_connect_confirm(void *instance, void *sap,
+ struct qos_info *qos,
__u32 max_sdu_size,
__u8 max_header_size,
struct sk_buff *);
-static void irlan_check_response_param(struct irlan_cb *self, char *param,
+static void irlan_check_response_param(struct irlan_cb *self, char *param,
char *value, int val_len);
static void irlan_client_open_ctrl_tsap(struct irlan_cb *self);
static void irlan_client_kick_timer_expired(void *data)
{
struct irlan_cb *self = (struct irlan_cb *) data;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
-
- /*
+
+ /*
* If we are in peer mode, the client may not have got the discovery
- * indication it needs to make progress. If the client is still in
+ * indication it needs to make progress. If the client is still in
* IDLE state, we must kick it to, but only if the provider is not IDLE
- */
- if ((self->provider.access_type == ACCESS_PEER) &&
+ */
+ if ((self->provider.access_type == ACCESS_PEER) &&
(self->client.state == IRLAN_IDLE) &&
(self->provider.state != IRLAN_IDLE)) {
irlan_client_wakeup(self, self->saddr, self->daddr);
static void irlan_client_start_kick_timer(struct irlan_cb *self, int timeout)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
- irda_start_timer(&self->client.kick_timer, timeout, (void *) self,
+
+ irda_start_timer(&self->client.kick_timer, timeout, (void *) self,
irlan_client_kick_timer_expired);
}
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
- /*
+ /*
* Check if we are already awake, or if we are a provider in direct
* mode (in that case we must leave the client idle
*/
- if ((self->client.state != IRLAN_IDLE) ||
+ if ((self->client.state != IRLAN_IDLE) ||
(self->provider.access_type == ACCESS_DIRECT))
{
IRDA_DEBUG(0, "%s(), already awake!\n", __FUNCTION__ );
irlan_open_data_tsap(self);
irlan_do_client_event(self, IRLAN_DISCOVERY_INDICATION, NULL);
-
+
/* Start kick timer */
irlan_client_start_kick_timer(self, 2*HZ);
}
*/
void irlan_client_discovery_indication(discinfo_t *discovery,
DISCOVERY_MODE mode,
- void *priv)
+ void *priv)
{
struct irlan_cb *self;
__u32 saddr, daddr;
-
+
IRDA_DEBUG(1, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(discovery != NULL, return;);
IRDA_DEBUG(1, "%s(), Found instance (%08x)!\n", __FUNCTION__ ,
daddr);
-
+
irlan_client_wakeup(self, saddr, daddr);
}
IRDA_ASSERT_LABEL(out:)
rcu_read_unlock();
}
-
+
/*
* Function irlan_client_data_indication (handle, skb)
*
* This function gets the data that is received on the control channel
*
*/
-static int irlan_client_ctrl_data_indication(void *instance, void *sap,
+static int irlan_client_ctrl_data_indication(void *instance, void *sap,
struct sk_buff *skb)
{
struct irlan_cb *self;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
-
+
self = (struct irlan_cb *) instance;
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
IRDA_ASSERT(skb != NULL, return -1;);
-
- irlan_do_client_event(self, IRLAN_DATA_INDICATION, skb);
- /* Ready for a new command */
+ irlan_do_client_event(self, IRLAN_DATA_INDICATION, skb);
+
+ /* Ready for a new command */
IRDA_DEBUG(2, "%s(), clearing tx_busy\n", __FUNCTION__ );
self->client.tx_busy = FALSE;
return 0;
}
-static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap,
- LM_REASON reason,
- struct sk_buff *userdata)
+static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap,
+ LM_REASON reason,
+ struct sk_buff *userdata)
{
struct irlan_cb *self;
struct tsap_cb *tsap;
struct sk_buff *skb;
IRDA_DEBUG(4, "%s(), reason=%d\n", __FUNCTION__ , reason);
-
+
self = (struct irlan_cb *) instance;
tsap = (struct tsap_cb *) sap;
IRDA_ASSERT(self != NULL, return;);
- IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+ IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
IRDA_ASSERT(tsap != NULL, return;);
IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
-
+
IRDA_ASSERT(tsap == self->client.tsap_ctrl, return;);
- /* Remove frames queued on the control channel */
+ /* Remove frames queued on the control channel */
while ((skb = skb_dequeue(&self->client.txq)) != NULL) {
dev_kfree_skb(skb);
}
notify.disconnect_indication = irlan_client_ctrl_disconnect_indication;
notify.instance = self;
strlcpy(notify.name, "IrLAN ctrl (c)", sizeof(notify.name));
-
+
tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, ¬ify);
if (!tsap) {
IRDA_DEBUG(2, "%s(), Got no tsap!\n", __FUNCTION__ );
* Connection to peer IrLAN laye confirmed
*
*/
-static void irlan_client_ctrl_connect_confirm(void *instance, void *sap,
- struct qos_info *qos,
+static void irlan_client_ctrl_connect_confirm(void *instance, void *sap,
+ struct qos_info *qos,
__u32 max_sdu_size,
__u8 max_header_size,
- struct sk_buff *skb)
+ struct sk_buff *skb)
{
struct irlan_cb *self;
* Print return code of request to peer IrLAN layer.
*
*/
-static void print_ret_code(__u8 code)
+static void print_ret_code(__u8 code)
{
switch(code) {
case 0:
/*
* Function irlan_client_parse_response (self, skb)
*
- * Extract all parameters from received buffer, then feed them to
+ * Extract all parameters from received buffer, then feed them to
* check_params for parsing
*/
void irlan_client_parse_response(struct irlan_cb *self, struct sk_buff *skb)
int ret;
__u16 val_len;
int i;
- char *name;
- char *value;
+ char *name;
+ char *value;
+
+ IRDA_ASSERT(skb != NULL, return;);
- IRDA_ASSERT(skb != NULL, return;);
-
IRDA_DEBUG(4, "%s() skb->len=%d\n", __FUNCTION__ , (int) skb->len);
-
+
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
-
+
if (!skb) {
IRDA_ERROR("%s(), Got NULL skb!\n", __FUNCTION__);
return;
}
frame = skb->data;
-
- /*
- * Check return code and print it if not success
+
+ /*
+ * Check return code and print it if not success
*/
if (frame[0]) {
print_ret_code(frame[0]);
return;
}
-
+
name = kmalloc(255, GFP_ATOMIC);
if (!name)
return;
count = frame[1];
IRDA_DEBUG(4, "%s(), got %d parameters\n", __FUNCTION__ , count);
-
+
ptr = frame+2;
/* For all parameters */
- for (i=0; i<count;i++) {
+ for (i=0; i<count;i++) {
ret = irlan_extract_param(ptr, name, value, &val_len);
if (ret < 0) {
IRDA_DEBUG(2, "%s(), IrLAN, Error!\n", __FUNCTION__ );
}
ptr += ret;
irlan_check_response_param(self, name, value, val_len);
- }
+ }
/* Cleanup */
kfree(name);
kfree(value);
* Check which parameter is received and update local variables
*
*/
-static void irlan_check_response_param(struct irlan_cb *self, char *param,
- char *value, int val_len)
+static void irlan_check_response_param(struct irlan_cb *self, char *param,
+ char *value, int val_len)
{
__u16 tmp_cpu; /* Temporary value in host order */
__u8 *bytes;
self->client.filter_type |= IRLAN_BROADCAST;
else if (strcmp(value, "IPX_SOCKET") == 0)
self->client.filter_type |= IRLAN_IPX_SOCKET;
-
+
}
if (strcmp(param, "ACCESS_TYPE") == 0) {
if (strcmp(value, "DIRECT") == 0)
}
/* IRLAN version */
if (strcmp(param, "IRLAN_VER") == 0) {
- IRDA_DEBUG(4, "IrLAN version %d.%d\n", (__u8) value[0],
+ IRDA_DEBUG(4, "IrLAN version %d.%d\n", (__u8) value[0],
(__u8) value[1]);
self->version[0] = value[0];
memcpy(&tmp_cpu, value, 2); /* Align value */
le16_to_cpus(&tmp_cpu); /* Convert to host order */
self->client.recv_arb_val = tmp_cpu;
- IRDA_DEBUG(2, "%s(), receive arb val=%d\n", __FUNCTION__ ,
+ IRDA_DEBUG(2, "%s(), receive arb val=%d\n", __FUNCTION__ ,
self->client.recv_arb_val);
}
if (strcmp(param, "MAX_FRAME") == 0) {
memcpy(&tmp_cpu, value, 2); /* Align value */
le16_to_cpus(&tmp_cpu); /* Convert to host order */
self->client.max_frame = tmp_cpu;
- IRDA_DEBUG(4, "%s(), max frame=%d\n", __FUNCTION__ ,
+ IRDA_DEBUG(4, "%s(), max frame=%d\n", __FUNCTION__ ,
self->client.max_frame);
}
-
+
/* RECONNECT_KEY, in case the link goes down! */
if (strcmp(param, "RECONNECT_KEY") == 0) {
IRDA_DEBUG(4, "Got reconnect key: ");
if (strcmp(param, "FILTER_ENTRY") == 0) {
bytes = value;
IRDA_DEBUG(4, "Ethernet address = %02x:%02x:%02x:%02x:%02x:%02x\n",
- bytes[0], bytes[1], bytes[2], bytes[3], bytes[4],
+ bytes[0], bytes[1], bytes[2], bytes[3], bytes[4],
bytes[5]);
- for (i = 0; i < 6; i++)
+ for (i = 0; i < 6; i++)
self->dev->dev_addr[i] = bytes[i];
}
}
* Got results from remote LM-IAS
*
*/
-void irlan_client_get_value_confirm(int result, __u16 obj_id,
- struct ias_value *value, void *priv)
+void irlan_client_get_value_confirm(int result, __u16 obj_id,
+ struct ias_value *value, void *priv)
{
struct irlan_cb *self;
-
+
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(priv != NULL, return;);
/* Check if request succeeded */
if (result != IAS_SUCCESS) {
IRDA_DEBUG(2, "%s(), got NULL value!\n", __FUNCTION__ );
- irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL,
+ irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL,
NULL);
return;
}
/*********************************************************************
- *
+ *
* Filename: irlan_client_event.c
* Version: 0.9
* Description: IrLAN client state machine
* Created at: Sun Aug 31 20:14:37 1997
* Modified at: Sun Dec 26 21:52:24 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.
- *
- * 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.
*
********************************************************************/
#include <net/irda/irlan_client.h>
#include <net/irda/irlan_event.h>
-static int irlan_client_state_idle (struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_idle (struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_client_state_conn (struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_conn (struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_client_state_info (struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_info (struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_client_state_open (struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_open (struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_client_state_wait (struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_wait (struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_client_state_arb (struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_arb (struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_client_state_data (struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_data (struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_client_state_sync (struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_client_state_sync (struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
static int (*state[])(struct irlan_cb *, IRLAN_EVENT event, struct sk_buff *) =
-{
+{
irlan_client_state_idle,
irlan_client_state_query,
irlan_client_state_conn,
irlan_client_state_sync
};
-void irlan_do_client_event(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+void irlan_do_client_event(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
* IDLE, We are waiting for an indication that there is a provider
* available.
*/
-static int irlan_client_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
-
+
switch (event) {
case IRLAN_DISCOVERY_INDICATION:
if (self->client.iriap) {
__FUNCTION__);
return -EBUSY;
}
-
+
self->client.iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
irlan_client_get_value_confirm);
/* Get some values from peer IAS */
IRDA_DEBUG(4, "%s(), Unknown event %d\n", __FUNCTION__ , event);
break;
}
- if (skb)
+ if (skb)
dev_kfree_skb(skb);
return 0;
* to provider, just waiting for the confirm.
*
*/
-static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
-
+
switch(event) {
case IRLAN_IAS_PROVIDER_AVAIL:
IRDA_ASSERT(self->dtsap_sel_ctrl != 0, return -1;);
self->client.open_retries = 0;
-
- irttp_connect_request(self->client.tsap_ctrl,
- self->dtsap_sel_ctrl,
- self->saddr, self->daddr, NULL,
+
+ irttp_connect_request(self->client.tsap_ctrl,
+ self->dtsap_sel_ctrl,
+ self->saddr, self->daddr, NULL,
IRLAN_MTU, NULL);
irlan_next_client_state(self, IRLAN_CONN);
break;
irlan_next_client_state(self, IRLAN_IDLE);
/* Give the client a kick! */
- if ((self->provider.access_type == ACCESS_PEER) &&
+ if ((self->provider.access_type == ACCESS_PEER) &&
(self->provider.state != IRLAN_IDLE))
irlan_client_wakeup(self, self->saddr, self->daddr);
break;
}
if (skb)
dev_kfree_skb(skb);
-
+
return 0;
}
* commands yet.
*
*/
-static int irlan_client_state_conn(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_conn(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return -1;);
-
+
switch (event) {
case IRLAN_CONNECT_COMPLETE:
/* Send getinfo cmd */
}
if (skb)
dev_kfree_skb(skb);
-
+
return 0;
}
*
* INFO, We have issued a GetInfo command and is awaiting a reply.
*/
-static int irlan_client_state_info(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_info(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return -1;);
-
+
switch (event) {
case IRLAN_DATA_INDICATION:
IRDA_ASSERT(skb != NULL, return -1;);
-
+
irlan_client_parse_response(self, skb);
-
+
irlan_next_client_state(self, IRLAN_MEDIA);
-
+
irlan_get_media_char(self);
break;
-
+
case IRLAN_LMP_DISCONNECT:
case IRLAN_LAP_DISCONNECT:
irlan_next_client_state(self, IRLAN_IDLE);
}
if (skb)
dev_kfree_skb(skb);
-
+
return 0;
}
* reply.
*
*/
-static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return -1;);
switch(event) {
}
if (skb)
dev_kfree_skb(skb);
-
+
return 0;
}
* reply
*
*/
-static int irlan_client_state_open(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_open(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
struct qos_info qos;
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return -1;);
switch(event) {
case IRLAN_DATA_INDICATION:
irlan_client_parse_response(self, skb);
-
+
/*
- * Check if we have got the remote TSAP for data
+ * Check if we have got the remote TSAP for data
* communications
*/
- IRDA_ASSERT(self->dtsap_sel_data != 0, return -1;);
+ IRDA_ASSERT(self->dtsap_sel_data != 0, return -1;);
/* Check which access type we are dealing with */
switch (self->client.access_type) {
case ACCESS_PEER:
if (self->provider.state == IRLAN_OPEN) {
-
+
irlan_next_client_state(self, IRLAN_ARB);
- irlan_do_client_event(self, IRLAN_CHECK_CON_ARB,
+ irlan_do_client_event(self, IRLAN_CHECK_CON_ARB,
NULL);
} else {
-
+
irlan_next_client_state(self, IRLAN_WAIT);
}
break;
case ACCESS_DIRECT:
case ACCESS_HOSTED:
qos.link_disc_time.bits = 0x01; /* 3 secs */
-
- irttp_connect_request(self->tsap_data,
- self->dtsap_sel_data,
- self->saddr, self->daddr, &qos,
+
+ irttp_connect_request(self->tsap_data,
+ self->dtsap_sel_data,
+ self->saddr, self->daddr, &qos,
IRLAN_MTU, NULL);
-
+
irlan_next_client_state(self, IRLAN_DATA);
break;
default:
IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
break;
}
-
+
if (skb)
dev_kfree_skb(skb);
* provider OPEN state.
*
*/
-static int irlan_client_state_wait(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_wait(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return -1;);
-
+
switch(event) {
case IRLAN_PROVIDER_SIGNAL:
irlan_next_client_state(self, IRLAN_ARB);
}
if (skb)
dev_kfree_skb(skb);
-
+
return 0;
}
-static int irlan_client_state_arb(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_arb(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
struct qos_info qos;
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return -1;);
-
+
switch(event) {
case IRLAN_CHECK_CON_ARB:
if (self->client.recv_arb_val == self->provider.send_arb_val) {
irlan_next_client_state(self, IRLAN_CLOSE);
irlan_close_data_channel(self);
- } else if (self->client.recv_arb_val <
- self->provider.send_arb_val)
+ } else if (self->client.recv_arb_val <
+ self->provider.send_arb_val)
{
qos.link_disc_time.bits = 0x01; /* 3 secs */
irlan_next_client_state(self, IRLAN_DATA);
- irttp_connect_request(self->tsap_data,
- self->dtsap_sel_data,
- self->saddr, self->daddr, &qos,
+ irttp_connect_request(self->tsap_data,
+ self->dtsap_sel_data,
+ self->saddr, self->daddr, &qos,
IRLAN_MTU, NULL);
} else if (self->client.recv_arb_val >
- self->provider.send_arb_val)
+ self->provider.send_arb_val)
{
IRDA_DEBUG(2, "%s(), lost the battle :-(\n", __FUNCTION__ );
}
}
if (skb)
dev_kfree_skb(skb);
-
+
return 0;
}
* the local and remote machines.
*
*/
-static int irlan_client_state_data(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_data(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
switch(event) {
case IRLAN_DATA_INDICATION:
irlan_client_parse_response(self, skb);
- break;
+ break;
case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
case IRLAN_LAP_DISCONNECT:
irlan_next_client_state(self, IRLAN_IDLE);
}
if (skb)
dev_kfree_skb(skb);
-
+
return 0;
}
/*
* Function irlan_client_state_close (self, event, skb, info)
*
- *
+ *
*
*/
-static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
/*
* Function irlan_client_state_sync (self, event, skb, info)
*
- *
+ *
*
*/
-static int irlan_client_state_sync(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_client_state_sync(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
-
+
if (skb)
dev_kfree_skb(skb);
-
+
return 0;
}
/*********************************************************************
- *
+ *
* Filename: irlan_common.c
* Version: 0.9
* Description: IrDA LAN Access Protocol Implementation
* Created at: Sun Aug 31 20:14:37 1997
* Modified at: Sun Dec 26 21:53:10 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
- * Copyright (c) 1997, 1999 Dag Brattli <dagb@cs.uit.no>,
+ *
+ * Copyright (c) 1997, 1999 Dag Brattli <dagb@cs.uit.no>,
* All Rights Reserved.
- *
- * 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.
*
********************************************************************/
#include <net/irda/irlan_common.h>
#include <net/irda/irlan_client.h>
-#include <net/irda/irlan_provider.h>
+#include <net/irda/irlan_provider.h>
#include <net/irda/irlan_eth.h>
#include <net/irda/irlan_filter.h>
-/*
+/*
* Send gratuitous ARP when connected to a new AP or not. May be a clever
* thing to do, but for some reason the machine crashes if you use DHCP. So
* lets not use it by default.
static struct irlan_cb *irlan_open(__u32 saddr, __u32 daddr);
static void __irlan_close(struct irlan_cb *self);
-static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
- __u8 value_byte, __u16 value_short,
+static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
+ __u8 value_byte, __u16 value_short,
__u8 *value_array, __u16 value_len);
static void irlan_open_unicast_addr(struct irlan_cb *self);
static void irlan_get_unicast_addr(struct irlan_cb *self);
return -ENOMEM;
}
-static void __exit irlan_cleanup(void)
+static void __exit irlan_cleanup(void)
{
struct irlan_cb *self, *next;
/*
* Function irlan_open (void)
*
- * Open new instance of a client/provider, we should only register the
+ * Open new instance of a client/provider, we should only register the
* network device if this instance is ment for a particular client/provider
*/
static struct irlan_cb *irlan_open(__u32 saddr, __u32 daddr)
/* Provider access can only be PEER, DIRECT, or HOSTED */
self->provider.access_type = access;
if (access == ACCESS_DIRECT) {
- /*
+ /*
* Since we are emulating an IrLAN sever we will have to
- * give ourself an ethernet address!
+ * give ourself an ethernet address!
*/
dev->dev_addr[0] = 0x40;
dev->dev_addr[1] = 0x00;
self->disconnect_reason = LM_USER_REQUEST;
init_timer(&self->watchdog_timer);
init_timer(&self->client.kick_timer);
- init_waitqueue_head(&self->open_wait);
-
+ init_waitqueue_head(&self->open_wait);
+
skb_queue_head_init(&self->client.txq);
-
+
irlan_next_client_state(self, IRLAN_IDLE);
irlan_next_provider_state(self, IRLAN_IDLE);
if (register_netdev(dev)) {
- IRDA_DEBUG(2, "%s(), register_netdev() failed!\n",
+ IRDA_DEBUG(2, "%s(), register_netdev() failed!\n",
__FUNCTION__ );
self = NULL;
free_netdev(dev);
/*
* Function __irlan_close (self)
*
- * This function closes and deallocates the IrLAN client instances. Be
+ * This function closes and deallocates the IrLAN client instances. Be
* aware that other functions which calls client_close() must
* remove self from irlans list first.
*/
static void __irlan_close(struct irlan_cb *self)
{
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
-
+
ASSERT_RTNL();
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
/* Close all open connections and remove TSAPs */
irlan_close_tsaps(self);
-
- if (self->client.iriap)
+
+ if (self->client.iriap)
iriap_close(self->client.iriap);
/* Remove frames queued on the control channel */
static void irlan_connect_indication(void *instance, void *sap,
struct qos_info *qos,
__u32 max_sdu_size,
- __u8 max_header_size,
+ __u8 max_header_size,
struct sk_buff *skb)
{
struct irlan_cb *self;
struct tsap_cb *tsap;
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
-
+
self = (struct irlan_cb *) instance;
tsap = (struct tsap_cb *) sap;
-
+
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
IRDA_ASSERT(tsap == self->tsap_data,return;);
irlan_do_client_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL);
if (self->provider.access_type == ACCESS_PEER) {
- /*
+ /*
* Data channel is open, so we are now allowed to
- * configure the remote filter
+ * configure the remote filter
*/
irlan_get_unicast_addr(self);
irlan_open_unicast_addr(self);
}
static void irlan_connect_confirm(void *instance, void *sap,
- struct qos_info *qos,
+ struct qos_info *qos,
__u32 max_sdu_size,
- __u8 max_header_size,
- struct sk_buff *skb)
+ __u8 max_header_size,
+ struct sk_buff *skb)
{
struct irlan_cb *self;
IRDA_DEBUG(0, "%s: We are now connected!\n", __FUNCTION__);
del_timer(&self->watchdog_timer);
- /*
+ /*
* Data channel is open, so we are now allowed to configure the remote
- * filter
+ * filter
*/
irlan_get_unicast_addr(self);
irlan_open_unicast_addr(self);
-
+
/* Open broadcast and multicast filter by default */
- irlan_set_broadcast_filter(self, TRUE);
- irlan_set_multicast_filter(self, TRUE);
+ irlan_set_broadcast_filter(self, TRUE);
+ irlan_set_multicast_filter(self, TRUE);
/* Ready to transfer Ethernet frames */
netif_start_queue(self->dev);
* the specified connection (handle)
*/
static void irlan_disconnect_indication(void *instance,
- void *sap, LM_REASON reason,
- struct sk_buff *userdata)
+ void *sap, LM_REASON reason,
+ struct sk_buff *userdata)
{
struct irlan_cb *self;
struct tsap_cb *tsap;
IRDA_DEBUG(0, "%s(), reason=%d\n", __FUNCTION__ , reason);
-
+
self = (struct irlan_cb *) instance;
tsap = (struct tsap_cb *) sap;
IRDA_ASSERT(self != NULL, return;);
- IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+ IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
IRDA_ASSERT(tsap != NULL, return;);
IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
-
+
IRDA_ASSERT(tsap == self->tsap_data, return;);
IRDA_DEBUG(2, "IrLAN, data channel disconnected by peer!\n");
/* Save reason so we know if we should try to reconnect or not */
self->disconnect_reason = reason;
-
+
switch (reason) {
case LM_USER_REQUEST: /* User request */
IRDA_DEBUG(2, "%s(), User requested\n", __FUNCTION__ );
IRDA_ERROR("%s(), Unknown disconnect reason\n", __FUNCTION__);
break;
}
-
+
/* If you want to pass the skb to *both* state machines, you will
* need to skb_clone() it, so that you don't free it twice.
* As the state machines don't need it, git rid of it here...
irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
-
+
wake_up_interruptible(&self->open_wait);
}
return;
irda_notify_init(¬ify);
-
+
notify.data_indication = irlan_eth_receive;
notify.udata_indication = irlan_eth_receive;
notify.connect_indication = irlan_connect_indication;
notify.connect_confirm = irlan_connect_confirm;
- notify.flow_indication = irlan_eth_flow_indication;
+ notify.flow_indication = irlan_eth_flow_indication;
notify.disconnect_indication = irlan_disconnect_indication;
notify.instance = self;
strlcpy(notify.name, "IrLAN data", sizeof(notify.name));
}
self->tsap_data = tsap;
- /*
+ /*
* This is the data TSAP selector which we will pass to the client
* when the client ask for it.
*/
self->tsap_data = NULL;
}
if (self->client.tsap_ctrl) {
- irttp_disconnect_request(self->client.tsap_ctrl, NULL,
+ irttp_disconnect_request(self->client.tsap_ctrl, NULL,
P_NORMAL);
irttp_close_tsap(self->client.tsap_ctrl);
self->client.tsap_ctrl = NULL;
}
if (self->provider.tsap_ctrl) {
- irttp_disconnect_request(self->provider.tsap_ctrl, NULL,
+ irttp_disconnect_request(self->provider.tsap_ctrl, NULL,
P_NORMAL);
irttp_close_tsap(self->provider.tsap_ctrl);
self->provider.tsap_ctrl = NULL;
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
-
- /*
+
+ /*
* Check if object has already been registered by a previous provider.
* If that is the case, we just change the value of the attribute
*/
irias_object_change_attribute("IrLAN", "IrDA:TinyTP:LsapSel",
new_value);
}
-
- /* Register PnP object only if not registered before */
- if (!irias_find_object("PnP")) {
+
+ /* Register PnP object only if not registered before */
+ if (!irias_find_object("PnP")) {
obj = irias_new_object("PnP", IAS_PNP_ID);
#if 0
irias_add_string_attrib(obj, "Name", sysctl_devname,
self->client.tx_busy = FALSE;
return 0;
}
-
+
/* Check that it's really possible to send commands */
- if ((self->client.tsap_ctrl == NULL) ||
- (self->client.state == IRLAN_IDLE))
+ if ((self->client.tsap_ctrl == NULL) ||
+ (self->client.state == IRLAN_IDLE))
{
self->client.tx_busy = FALSE;
dev_kfree_skb(skb);
__u8 *frame;
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
/* Reserve space for TTP, LMP, and LAP header */
skb_reserve(skb, self->client.max_header_size);
skb_put(skb, 2);
-
+
frame = skb->data;
-
- frame[0] = CMD_GET_PROVIDER_INFO;
+
+ frame[0] = CMD_GET_PROVIDER_INFO;
frame[1] = 0x00; /* Zero parameters */
-
+
irlan_ctrl_data_request(self, skb);
}
* Send an Open Data Command to provider
*
*/
-void irlan_open_data_channel(struct irlan_cb *self)
+void irlan_open_data_channel(struct irlan_cb *self)
{
struct sk_buff *skb;
__u8 *frame;
-
+
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
-
+
skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3") +
IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "DIRECT"),
skb_reserve(skb, self->client.max_header_size);
skb_put(skb, 2);
-
+
frame = skb->data;
-
+
/* Build frame */
- frame[0] = CMD_OPEN_DATA_CHANNEL;
+ frame[0] = CMD_OPEN_DATA_CHANNEL;
frame[1] = 0x02; /* Two parameters */
irlan_insert_string_param(skb, "MEDIA", "802.3");
irlan_ctrl_data_request(self, skb);
}
-void irlan_close_data_channel(struct irlan_cb *self)
+void irlan_close_data_channel(struct irlan_cb *self)
{
struct sk_buff *skb;
__u8 *frame;
-
+
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return;);
skb_reserve(skb, self->client.max_header_size);
skb_put(skb, 2);
-
+
frame = skb->data;
-
+
/* Build frame */
- frame[0] = CMD_CLOSE_DATA_CHAN;
+ frame[0] = CMD_CLOSE_DATA_CHAN;
frame[1] = 0x01; /* One parameter */
irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
/*
* Function irlan_open_unicast_addr (self)
*
- * Make IrLAN provider accept ethernet frames addressed to the unicast
+ * Make IrLAN provider accept ethernet frames addressed to the unicast
* address.
*
*/
{
struct sk_buff *skb;
__u8 *frame;
-
+
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return;);
- IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
-
+ IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+
skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
/* Reserve space for TTP, LMP, and LAP header */
skb_reserve(skb, self->max_header_size);
skb_put(skb, 2);
-
+
frame = skb->data;
-
- frame[0] = CMD_FILTER_OPERATION;
+
+ frame[0] = CMD_FILTER_OPERATION;
frame[1] = 0x03; /* Three parameters */
- irlan_insert_byte_param(skb, "DATA_CHAN" , self->dtsap_sel_data);
- irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
- irlan_insert_string_param(skb, "FILTER_MODE", "FILTER");
-
+ irlan_insert_byte_param(skb, "DATA_CHAN" , self->dtsap_sel_data);
+ irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
+ irlan_insert_string_param(skb, "FILTER_MODE", "FILTER");
+
irlan_ctrl_data_request(self, skb);
}
* one but then _we_ have to initiate all communication with other
* hosts, since ARP request for this host will not be answered.
*/
-void irlan_set_broadcast_filter(struct irlan_cb *self, int status)
+void irlan_set_broadcast_filter(struct irlan_cb *self, int status)
{
struct sk_buff *skb;
__u8 *frame;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
-
- skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
+
+ skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BROADCAST") +
/* We may waste one byte here...*/
/* Reserve space for TTP, LMP, and LAP header */
skb_reserve(skb, self->client.max_header_size);
skb_put(skb, 2);
-
+
frame = skb->data;
-
- frame[0] = CMD_FILTER_OPERATION;
+
+ frame[0] = CMD_FILTER_OPERATION;
frame[1] = 0x03; /* Three parameters */
- irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
- irlan_insert_string_param(skb, "FILTER_TYPE", "BROADCAST");
+ irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
+ irlan_insert_string_param(skb, "FILTER_TYPE", "BROADCAST");
if (status)
- irlan_insert_string_param(skb, "FILTER_MODE", "FILTER");
+ irlan_insert_string_param(skb, "FILTER_MODE", "FILTER");
else
- irlan_insert_string_param(skb, "FILTER_MODE", "NONE");
+ irlan_insert_string_param(skb, "FILTER_MODE", "NONE");
irlan_ctrl_data_request(self, skb);
}
* Function irlan_set_multicast_filter (self, status)
*
* Make IrLAN provider accept ethernet frames addressed to the multicast
- * address.
+ * address.
*
*/
-void irlan_set_multicast_filter(struct irlan_cb *self, int status)
+void irlan_set_multicast_filter(struct irlan_cb *self, int status)
{
struct sk_buff *skb;
__u8 *frame;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return;);
GFP_ATOMIC);
if (!skb)
return;
-
+
/* Reserve space for TTP, LMP, and LAP header */
skb_reserve(skb, self->client.max_header_size);
skb_put(skb, 2);
-
+
frame = skb->data;
-
- frame[0] = CMD_FILTER_OPERATION;
+
+ frame[0] = CMD_FILTER_OPERATION;
frame[1] = 0x03; /* Three parameters */
- irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
- irlan_insert_string_param(skb, "FILTER_TYPE", "MULTICAST");
+ irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
+ irlan_insert_string_param(skb, "FILTER_TYPE", "MULTICAST");
if (status)
- irlan_insert_string_param(skb, "FILTER_MODE", "ALL");
+ irlan_insert_string_param(skb, "FILTER_MODE", "ALL");
else
- irlan_insert_string_param(skb, "FILTER_MODE", "NONE");
+ irlan_insert_string_param(skb, "FILTER_MODE", "NONE");
irlan_ctrl_data_request(self, skb);
}
{
struct sk_buff *skb;
__u8 *frame;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
-
+
skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
/* Reserve space for TTP, LMP, and LAP header */
skb_reserve(skb, self->client.max_header_size);
skb_put(skb, 2);
-
+
frame = skb->data;
-
- frame[0] = CMD_FILTER_OPERATION;
+
+ frame[0] = CMD_FILTER_OPERATION;
frame[1] = 0x03; /* Three parameters */
- irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
- irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
- irlan_insert_string_param(skb, "FILTER_OPERATION", "DYNAMIC");
-
+ irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
+ irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
+ irlan_insert_string_param(skb, "FILTER_OPERATION", "DYNAMIC");
+
irlan_ctrl_data_request(self, skb);
}
/*
* Function irlan_get_media_char (self)
*
- *
+ *
*
*/
-void irlan_get_media_char(struct irlan_cb *self)
+void irlan_get_media_char(struct irlan_cb *self)
{
struct sk_buff *skb;
__u8 *frame;
-
+
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
-
+
skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3"),
GFP_ATOMIC);
/* Reserve space for TTP, LMP, and LAP header */
skb_reserve(skb, self->client.max_header_size);
skb_put(skb, 2);
-
+
frame = skb->data;
-
+
/* Build frame */
- frame[0] = CMD_GET_MEDIA_CHAR;
+ frame[0] = CMD_GET_MEDIA_CHAR;
frame[1] = 0x01; /* One parameter */
-
+
irlan_insert_string_param(skb, "MEDIA", "802.3");
irlan_ctrl_data_request(self, skb);
}
{
int string_len = strlen(string);
- return __irlan_insert_param(skb, param, IRLAN_ARRAY, 0, 0, string,
+ return __irlan_insert_param(skb, param, IRLAN_ARRAY, 0, 0, string,
string_len);
}
int irlan_insert_array_param(struct sk_buff *skb, char *name, __u8 *array,
__u16 array_len)
{
- return __irlan_insert_param(skb, name, IRLAN_ARRAY, 0, 0, array,
+ return __irlan_insert_param(skb, name, IRLAN_ARRAY, 0, 0, array,
array_len);
}
* | Name Length[1] | Param Name[1..255] | Val Length[2] | Value[0..1016]|
* -----------------------------------------------------------------------
*/
-static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
- __u8 value_byte, __u16 value_short,
+static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
+ __u8 value_byte, __u16 value_short,
__u8 *value_array, __u16 value_len)
{
__u8 *frame;
__u8 param_len;
__le16 tmp_le; /* Temporary value in little endian format */
int n=0;
-
+
if (skb == NULL) {
IRDA_DEBUG(2, "%s(), Got NULL skb\n", __FUNCTION__ );
return 0;
- }
+ }
param_len = strlen(param);
switch (type) {
return 0;
break;
}
-
+
/* Insert at end of sk-buffer */
frame = skb->tail;
if (skb_tailroom(skb) < (param_len+value_len+3)) {
IRDA_DEBUG(2, "%s(), No more space at end of skb\n", __FUNCTION__ );
return 0;
- }
+ }
skb_put(skb, param_len+value_len+3);
-
+
/* Insert parameter length */
frame[n++] = param_len;
-
+
/* Insert parameter */
memcpy(frame+n, param, param_len); n += param_len;
-
+
/* Insert value length (2 byte little endian format, LSB first) */
tmp_le = cpu_to_le16(value_len);
memcpy(frame+n, &tmp_le, 2); n += 2; /* To avoid alignment problems */
* Function irlan_extract_param (buf, name, value, len)
*
* Extracts a single parameter name/value pair from buffer and updates
- * the buffer pointer to point to the next name/value pair.
+ * the buffer pointer to point to the next name/value pair.
*/
int irlan_extract_param(__u8 *buf, char *name, char *value, __u16 *len)
{
__u8 name_len;
__u16 val_len;
int n=0;
-
+
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
/* get length of parameter name (1 byte) */
name_len = buf[n++];
-
+
if (name_len > 254) {
IRDA_DEBUG(2, "%s(), name_len > 254\n", __FUNCTION__ );
return -RSP_INVALID_COMMAND_FORMAT;
}
-
+
/* get parameter name */
memcpy(name, buf+n, name_len);
name[name_len] = '\0';
n+=name_len;
-
- /*
- * Get length of parameter value (2 bytes in little endian
- * format)
+
+ /*
+ * Get length of parameter value (2 bytes in little endian
+ * format)
*/
memcpy(&val_len, buf+n, 2); /* To avoid alignment problems */
le16_to_cpus(&val_len); n+=2;
-
+
if (val_len > 1016) {
IRDA_DEBUG(2, "%s(), parameter length to long\n", __FUNCTION__ );
return -RSP_INVALID_COMMAND_FORMAT;
memcpy(value, buf+n, val_len);
value[val_len] = '\0';
n+=val_len;
-
- IRDA_DEBUG(4, "Parameter: %s ", name);
- IRDA_DEBUG(4, "Value: %s\n", value);
+
+ IRDA_DEBUG(4, "Parameter: %s ", name);
+ IRDA_DEBUG(4, "Value: %s\n", value);
return n;
}
/*
* Start of reading /proc entries.
- * Return entry at pos,
+ * Return entry at pos,
* or start_token to indicate print header line
* or NULL if end of file
*/
return SEQ_START_TOKEN;
list_for_each_entry(self, &irlans, dev_list) {
- if (*pos == i)
+ if (*pos == i)
return self;
++i;
}
struct list_head *nxt;
++*pos;
- if (v == SEQ_START_TOKEN)
+ if (v == SEQ_START_TOKEN)
nxt = irlans.next;
else
nxt = ((struct irlan_cb *)v)->dev_list.next;
- return (nxt == &irlans) ? NULL
+ return (nxt == &irlans) ? NULL
: list_entry(nxt, struct irlan_cb, dev_list);
}
seq_puts(seq, "IrLAN instances:\n");
else {
struct irlan_cb *self = v;
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
self->daddr);
seq_printf(seq,"version: %d.%d,\n",
self->version[1], self->version[0]);
- seq_printf(seq,"access type: %s\n",
+ seq_printf(seq,"access type: %s\n",
irlan_access[self->client.access_type]);
- seq_printf(seq,"media: %s\n",
+ seq_printf(seq,"media: %s\n",
irlan_media[self->media]);
-
+
seq_printf(seq,"local filter:\n");
seq_printf(seq,"remote filter: ");
irlan_print_filter(seq, self->client.filter_type);
- seq_printf(seq,"tx busy: %s\n",
+ seq_printf(seq,"tx busy: %s\n",
netif_queue_stopped(self->dev) ? "TRUE" : "FALSE");
-
+
seq_putc(seq,'\n');
}
return 0;
#endif
MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
-MODULE_DESCRIPTION("The Linux IrDA LAN protocol");
+MODULE_DESCRIPTION("The Linux IrDA LAN protocol");
MODULE_LICENSE("GPL");
module_param(eth, bool, 0);
/*********************************************************************
- *
+ *
* Filename: irlan_eth.c
- * Version:
- * Description:
+ * Version:
+ * Description:
* Status: Experimental.
* Author: Dag Brattli <dagb@cs.uit.no>
* Created at: Thu Oct 15 08:37:58 1998
* Sources: skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
* slip.c by Laurence Culhane, <loz@holmes.demon.co.uk>
* Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
- *
+ *
* Copyright (c) 1998-2000 Dag Brattli, All Rights Reserved.
- *
- * 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.
- *
+ *
********************************************************************/
#include <linux/netdevice.h>
{
dev->open = irlan_eth_open;
dev->stop = irlan_eth_close;
- dev->hard_start_xmit = irlan_eth_xmit;
+ dev->hard_start_xmit = irlan_eth_xmit;
dev->get_stats = irlan_eth_get_stats;
dev->set_multicast_list = irlan_eth_set_multicast_list;
dev->destructor = free_netdev;
SET_MODULE_OWNER(dev);
ether_setup(dev);
-
- /*
+
+ /*
* Lets do all queueing in IrTTP instead of this device driver.
* Queueing here as well can introduce some strange latency
* problems, which we will avoid by setting the queue size to 0.
static int irlan_eth_open(struct net_device *dev)
{
struct irlan_cb *self = netdev_priv(dev);
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
/* Ready to play! */
- netif_stop_queue(dev); /* Wait until data link is ready */
+ netif_stop_queue(dev); /* Wait until data link is ready */
/* We are now open, so time to do some work */
self->disconnect_reason = 0;
irlan_client_wakeup(self, self->saddr, self->daddr);
- /* Make sure we have a hardware address before we return,
+ /* Make sure we have a hardware address before we return,
so DHCP clients gets happy */
return wait_event_interruptible(self->open_wait,
!self->tsap_data->connected);
* Function irlan_eth_close (dev)
*
* Stop the ether network device, his function will usually be called by
- * ifconfig down. We should now disconnect the link, We start the
+ * ifconfig down. We should now disconnect the link, We start the
* close timer, so that the instance will be removed if we are unable
* to discover the remote device after the disconnect.
*/
static int irlan_eth_close(struct net_device *dev)
{
struct irlan_cb *self = netdev_priv(dev);
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
-
+
/* Stop device */
netif_stop_queue(dev);
-
+
irlan_close_data_channel(self);
irlan_close_tsaps(self);
irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
- irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
-
+ irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
+
/* Remove frames queued on the control channel */
skb_queue_purge(&self->client.txq);
self->client.tx_busy = 0;
-
+
return 0;
}
/* skb headroom large enough to contain all IrDA-headers? */
if ((skb_headroom(skb) < self->max_header_size) || (skb_shared(skb))) {
- struct sk_buff *new_skb =
+ struct sk_buff *new_skb =
skb_realloc_headroom(skb, self->max_header_size);
/* We have to free the original skb anyway */
/* Use the new skb instead */
skb = new_skb;
- }
+ }
dev->trans_start = jiffies;
ret = irttp_data_request(self->tsap_data, skb);
if (ret < 0) {
- /*
+ /*
* IrTTPs tx queue is full, so we just have to
* drop the frame! You might think that we should
* just return -1 and don't deallocate the frame,
* we have replaced the original skb with a new
* one with larger headroom, and that would really
* confuse do_dev_queue_xmit() in dev.c! I have
- * tried :-) DB
+ * tried :-) DB
*/
/* irttp_data_request already free the packet */
self->stats.tx_dropped++;
} else {
self->stats.tx_packets++;
- self->stats.tx_bytes += skb->len;
+ self->stats.tx_bytes += skb->len;
}
-
+
return 0;
}
struct irlan_cb *self = instance;
if (skb == NULL) {
- ++self->stats.rx_dropped;
+ ++self->stats.rx_dropped;
return 0;
}
if (skb->len < ETH_HLEN) {
IRDA_DEBUG(0, "%s() : IrLAN frame too short (%d)\n",
__FUNCTION__, skb->len);
- ++self->stats.rx_dropped;
+ ++self->stats.rx_dropped;
dev_kfree_skb(skb);
return 0;
}
-
- /*
- * Adopt this frame! Important to set all these fields since they
+
+ /*
+ * Adopt this frame! Important to set all these fields since they
* might have been previously set by the low level IrDA network
- * device driver
+ * device driver
*/
skb->dev = self->dev;
skb->protocol=eth_type_trans(skb, skb->dev); /* Remove eth header */
-
+
self->stats.rx_packets++;
- self->stats.rx_bytes += skb->len;
+ self->stats.rx_bytes += skb->len;
netif_rx(skb); /* Eat it! */
-
+
return 0;
}
/*
* Function irlan_eth_flow (status)
*
- * Do flow control between IP/Ethernet and IrLAN/IrTTP. This is done by
+ * Do flow control between IP/Ethernet and IrLAN/IrTTP. This is done by
* controlling the queue stop/start.
*
* The IrDA link layer has the advantage to have flow control, and
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
-
+
dev = self->dev;
IRDA_ASSERT(dev != NULL, return;);
-
+
IRDA_DEBUG(0, "%s() : flow %s ; running %d\n", __FUNCTION__,
flow == FLOW_STOP ? "FLOW_STOP" : "FLOW_START",
netif_running(dev));
{
struct in_device *in_dev;
- /*
+ /*
* When we get a new MAC address do a gratuitous ARP. This
* is useful if we have changed access points on the same
- * subnet.
+ * subnet.
*/
#ifdef CONFIG_INET
IRDA_DEBUG(4, "IrLAN: Sending gratuitous ARP\n");
if (in_dev == NULL)
goto out;
if (in_dev->ifa_list)
-
- arp_send(ARPOP_REQUEST, ETH_P_ARP,
+
+ arp_send(ARPOP_REQUEST, ETH_P_ARP,
in_dev->ifa_list->ifa_address,
- dev,
+ dev,
in_dev->ifa_list->ifa_address,
NULL, dev->dev_addr, NULL);
out:
*
*/
#define HW_MAX_ADDRS 4 /* Must query to get it! */
-static void irlan_eth_set_multicast_list(struct net_device *dev)
+static void irlan_eth_set_multicast_list(struct net_device *dev)
{
- struct irlan_cb *self = netdev_priv(dev);
+ struct irlan_cb *self = netdev_priv(dev);
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
if (dev->flags & IFF_PROMISC) {
/* Enable promiscuous mode */
IRDA_WARNING("Promiscous mode not implemented by IrLAN!\n");
- }
+ }
else if ((dev->flags & IFF_ALLMULTI) || dev->mc_count > HW_MAX_ADDRS) {
/* Disable promiscuous mode, use normal mode. */
IRDA_DEBUG(4, "%s(), Setting multicast filter\n", __FUNCTION__ );
* Get the current statistics for this device
*
*/
-static struct net_device_stats *irlan_eth_get_stats(struct net_device *dev)
+static struct net_device_stats *irlan_eth_get_stats(struct net_device *dev)
{
struct irlan_cb *self = netdev_priv(dev);
/*********************************************************************
- *
+ *
* Filename: irlan_event.c
- * Version:
- * Description:
+ * Version:
+ * Description:
* Status: Experimental.
* Author: Dag Brattli <dagb@cs.uit.no>
* Created at: Tue Oct 20 09:10:16 1998
* Modified at: Sat Oct 30 12:59:01 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1998-1999 Dag Brattli, All Rights Reserved.
- *
- * 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.
- *
+ *
********************************************************************/
#include <net/irda/irlan_event.h>
"IRLAN_SYNC",
};
-void irlan_next_client_state(struct irlan_cb *self, IRLAN_STATE state)
+void irlan_next_client_state(struct irlan_cb *self, IRLAN_STATE state)
{
IRDA_DEBUG(2, "%s(), %s\n", __FUNCTION__ , irlan_state[state]);
self->client.state = state;
}
-void irlan_next_provider_state(struct irlan_cb *self, IRLAN_STATE state)
+void irlan_next_provider_state(struct irlan_cb *self, IRLAN_STATE state)
{
IRDA_DEBUG(2, "%s(), %s\n", __FUNCTION__ , irlan_state[state]);
/*********************************************************************
- *
+ *
* Filename: irlan_filter.c
- * Version:
- * Description:
+ * Version:
+ * Description:
* Status: Experimental.
* Author: Dag Brattli <dagb@cs.uit.no>
* Created at: Fri Jan 29 11:16:38 1999
* Modified at: Sat Oct 30 12:58:45 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1998-1999 Dag Brattli, All Rights Reserved.
- *
- * 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.
- *
+ *
********************************************************************/
#include <linux/skbuff.h>
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
- if ((self->provider.filter_type == IRLAN_DIRECTED) &&
+ if ((self->provider.filter_type == IRLAN_DIRECTED) &&
(self->provider.filter_operation == DYNAMIC))
{
IRDA_DEBUG(0, "Giving peer a dynamic Ethernet address\n");
self->provider.mac_address[1] = 0x00;
self->provider.mac_address[2] = 0x00;
self->provider.mac_address[3] = 0x00;
-
+
/* Use arbitration value to generate MAC address */
if (self->provider.access_type == ACCESS_PEER) {
- self->provider.mac_address[4] =
+ self->provider.mac_address[4] =
self->provider.send_arb_val & 0xff;
- self->provider.mac_address[5] =
+ self->provider.mac_address[5] =
(self->provider.send_arb_val >> 8) & 0xff;
} else {
/* Just generate something for now */
skb->data[1] = 0x03;
irlan_insert_string_param(skb, "FILTER_MODE", "NONE");
irlan_insert_short_param(skb, "MAX_ENTRY", 0x0001);
- irlan_insert_array_param(skb, "FILTER_ENTRY",
+ irlan_insert_array_param(skb, "FILTER_ENTRY",
self->provider.mac_address, 6);
return;
}
-
- if ((self->provider.filter_type == IRLAN_DIRECTED) &&
+
+ if ((self->provider.filter_type == IRLAN_DIRECTED) &&
(self->provider.filter_mode == FILTER))
{
IRDA_DEBUG(0, "Directed filter on\n");
skb->data[1] = 0x00;
return;
}
- if ((self->provider.filter_type == IRLAN_DIRECTED) &&
+ if ((self->provider.filter_type == IRLAN_DIRECTED) &&
(self->provider.filter_mode == NONE))
{
IRDA_DEBUG(0, "Directed filter off\n");
return;
}
- if ((self->provider.filter_type == IRLAN_BROADCAST) &&
+ if ((self->provider.filter_type == IRLAN_BROADCAST) &&
(self->provider.filter_mode == FILTER))
{
IRDA_DEBUG(0, "Broadcast filter on\n");
skb->data[1] = 0x00;
return;
}
- if ((self->provider.filter_type == IRLAN_BROADCAST) &&
+ if ((self->provider.filter_type == IRLAN_BROADCAST) &&
(self->provider.filter_mode == NONE))
{
IRDA_DEBUG(0, "Broadcast filter off\n");
skb->data[1] = 0x00;
return;
}
- if ((self->provider.filter_type == IRLAN_MULTICAST) &&
+ if ((self->provider.filter_type == IRLAN_MULTICAST) &&
(self->provider.filter_mode == FILTER))
{
IRDA_DEBUG(0, "Multicast filter on\n");
skb->data[1] = 0x00;
return;
}
- if ((self->provider.filter_type == IRLAN_MULTICAST) &&
+ if ((self->provider.filter_type == IRLAN_MULTICAST) &&
(self->provider.filter_mode == NONE))
{
IRDA_DEBUG(0, "Multicast filter off\n");
skb->data[1] = 0x00;
return;
}
- if ((self->provider.filter_type == IRLAN_MULTICAST) &&
+ if ((self->provider.filter_type == IRLAN_MULTICAST) &&
(self->provider.filter_operation == GET))
{
IRDA_DEBUG(0, "Multicast filter get\n");
/*********************************************************************
- *
+ *
* Filename: irlan_provider.c
* Version: 0.9
* Description: IrDA LAN Access Protocol Implementation
* Sources: skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
* slip.c by Laurence Culhane, <loz@holmes.demon.co.uk>
* Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
- *
- * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
+ *
+ * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
* All Rights Reserved.
- *
- * 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.
*
********************************************************************/
#include <net/irda/irlan_filter.h>
#include <net/irda/irlan_client.h>
-static void irlan_provider_connect_indication(void *instance, void *sap,
- struct qos_info *qos,
+static void irlan_provider_connect_indication(void *instance, void *sap,
+ struct qos_info *qos,
__u32 max_sdu_size,
__u8 max_header_size,
struct sk_buff *skb);
* This function gets the data that is received on the control channel
*
*/
-static int irlan_provider_data_indication(void *instance, void *sap,
- struct sk_buff *skb)
+static int irlan_provider_data_indication(void *instance, void *sap,
+ struct sk_buff *skb)
{
struct irlan_cb *self;
__u8 code;
-
+
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
self = (struct irlan_cb *) instance;
IRDA_ASSERT(self != NULL, return -1;);
switch(code) {
case CMD_GET_PROVIDER_INFO:
IRDA_DEBUG(4, "Got GET_PROVIDER_INFO command!\n");
- irlan_do_provider_event(self, IRLAN_GET_INFO_CMD, skb);
+ irlan_do_provider_event(self, IRLAN_GET_INFO_CMD, skb);
break;
case CMD_GET_MEDIA_CHAR:
IRDA_DEBUG(4, "Got GET_MEDIA_CHAR command!\n");
- irlan_do_provider_event(self, IRLAN_GET_MEDIA_CMD, skb);
+ irlan_do_provider_event(self, IRLAN_GET_MEDIA_CMD, skb);
break;
case CMD_OPEN_DATA_CHANNEL:
IRDA_DEBUG(4, "Got OPEN_DATA_CHANNEL command!\n");
- irlan_do_provider_event(self, IRLAN_OPEN_DATA_CMD, skb);
+ irlan_do_provider_event(self, IRLAN_OPEN_DATA_CMD, skb);
break;
case CMD_FILTER_OPERATION:
IRDA_DEBUG(4, "Got FILTER_OPERATION command!\n");
* Got connection from peer IrLAN client
*
*/
-static void irlan_provider_connect_indication(void *instance, void *sap,
+static void irlan_provider_connect_indication(void *instance, void *sap,
struct qos_info *qos,
- __u32 max_sdu_size,
+ __u32 max_sdu_size,
__u8 max_header_size,
struct sk_buff *skb)
{
__u32 saddr, daddr;
IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
-
+
self = (struct irlan_cb *) instance;
tsap = (struct tsap_cb *) sap;
-
+
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
-
+
IRDA_ASSERT(tsap == self->provider.tsap_ctrl,return;);
IRDA_ASSERT(self->provider.state == IRLAN_IDLE, return;);
irlan_do_provider_event(self, IRLAN_CONNECT_INDICATION, NULL);
- /*
+ /*
* If we are in peer mode, the client may not have got the discovery
- * indication it needs to make progress. If the client is still in
- * IDLE state, we must kick it.
+ * indication it needs to make progress. If the client is still in
+ * IDLE state, we must kick it.
*/
- if ((self->provider.access_type == ACCESS_PEER) &&
- (self->client.state == IRLAN_IDLE))
+ if ((self->provider.access_type == ACCESS_PEER) &&
+ (self->client.state == IRLAN_IDLE))
{
irlan_client_wakeup(self, self->saddr, self->daddr);
}
irttp_connect_response(tsap, IRLAN_MTU, NULL);
}
-static void irlan_provider_disconnect_indication(void *instance, void *sap,
- LM_REASON reason,
- struct sk_buff *userdata)
+static void irlan_provider_disconnect_indication(void *instance, void *sap,
+ LM_REASON reason,
+ struct sk_buff *userdata)
{
struct irlan_cb *self;
struct tsap_cb *tsap;
IRDA_DEBUG(4, "%s(), reason=%d\n", __FUNCTION__ , reason);
-
+
self = (struct irlan_cb *) instance;
tsap = (struct tsap_cb *) sap;
IRDA_ASSERT(self != NULL, return;);
- IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+ IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
IRDA_ASSERT(tsap != NULL, return;);
IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
-
+
IRDA_ASSERT(tsap == self->provider.tsap_ctrl, return;);
-
+
irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
}
/*
* Function irlan_parse_open_data_cmd (self, skb)
*
- *
+ *
*
*/
int irlan_parse_open_data_cmd(struct irlan_cb *self, struct sk_buff *skb)
{
int ret;
-
+
ret = irlan_provider_parse_command(self, CMD_OPEN_DATA_CHANNEL, skb);
/* Open data channel */
/*
* Function parse_command (skb)
*
- * Extract all parameters from received buffer, then feed them to
+ * Extract all parameters from received buffer, then feed them to
* check_params for parsing
*
*/
int irlan_provider_parse_command(struct irlan_cb *self, int cmd,
- struct sk_buff *skb)
+ struct sk_buff *skb)
{
__u8 *frame;
__u8 *ptr;
__u16 val_len;
int i;
char *name;
- char *value;
+ char *value;
int ret = RSP_SUCCESS;
-
+
IRDA_ASSERT(skb != NULL, return -RSP_PROTOCOL_ERROR;);
-
+
IRDA_DEBUG(4, "%s(), skb->len=%d\n", __FUNCTION__ , (int)skb->len);
IRDA_ASSERT(self != NULL, return -RSP_PROTOCOL_ERROR;);
IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -RSP_PROTOCOL_ERROR;);
-
+
if (!skb)
return -RSP_PROTOCOL_ERROR;
count = frame[1];
IRDA_DEBUG(4, "Got %d parameters\n", count);
-
+
ptr = frame+2;
-
+
/* For all parameters */
- for (i=0; i<count;i++) {
+ for (i=0; i<count;i++) {
ret = irlan_extract_param(ptr, name, value, &val_len);
if (ret < 0) {
IRDA_DEBUG(2, "%s(), IrLAN, Error!\n", __FUNCTION__ );
* Send reply to query to peer IrLAN layer
*
*/
-void irlan_provider_send_reply(struct irlan_cb *self, int command,
+void irlan_provider_send_reply(struct irlan_cb *self, int command,
int ret_code)
{
struct sk_buff *skb;
/* Reserve space for TTP, LMP, and LAP header */
skb_reserve(skb, self->provider.max_header_size);
skb_put(skb, 2);
-
+
switch (command) {
case CMD_GET_PROVIDER_INFO:
skb->data[0] = 0x00; /* Success */
skb->data[0] = 0x00; /* Success */
if (self->provider.send_arb_val) {
skb->data[1] = 0x03; /* 3 parameters */
- irlan_insert_short_param(skb, "CON_ARB",
+ irlan_insert_short_param(skb, "CON_ARB",
self->provider.send_arb_val);
} else
skb->data[1] = 0x02; /* 2 parameters */
* Function irlan_provider_register(void)
*
* Register provider support so we can accept incoming connections.
- *
+ *
*/
int irlan_provider_open_ctrl_tsap(struct irlan_cb *self)
{
struct tsap_cb *tsap;
notify_t notify;
-
+
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
IRDA_ASSERT(self != NULL, return -1;);
/* Check if already open */
if (self->provider.tsap_ctrl)
return -1;
-
+
/*
* First register well known control TSAP
*/
/*********************************************************************
- *
+ *
* Filename: irlan_provider_event.c
* Version: 0.9
* Description: IrLAN provider state machine)
* Created at: Sun Aug 31 20:14:37 1997
* Modified at: Sat Oct 30 12:52:41 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>, All Rights Reserved.
- *
- * 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.
*
********************************************************************/
#include <net/irda/irlan_provider.h>
#include <net/irda/irlan_event.h>
-static int irlan_provider_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_provider_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_provider_state_info(struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_provider_state_info(struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_provider_state_open(struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_provider_state_open(struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int irlan_provider_state_data(struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_provider_state_data(struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb);
-static int (*state[])(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb) =
-{
+static int (*state[])(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb) =
+{
irlan_provider_state_idle,
NULL, /* Query */
NULL, /* Info */
NULL, /* Sync */
};
-void irlan_do_provider_event(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+void irlan_do_provider_event(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_ASSERT(*state[ self->provider.state] != NULL, return;);
struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return -1;);
-
+
switch(event) {
case IRLAN_CONNECT_INDICATION:
irlan_provider_connect_response( self, self->provider.tsap_ctrl);
*
* INFO, We have issued a GetInfo command and is awaiting a reply.
*/
-static int irlan_provider_state_info(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_provider_state_info(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
int ret;
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
-
+
IRDA_ASSERT(self != NULL, return -1;);
switch(event) {
/* Be sure to use 802.3 in case of peer mode */
if (self->provider.access_type == ACCESS_PEER) {
self->media = MEDIA_802_3;
-
+
/* Check if client has started yet */
if (self->client.state == IRLAN_IDLE) {
/* This should get the client going */
}
}
- irlan_provider_send_reply(self, CMD_GET_PROVIDER_INFO,
+ irlan_provider_send_reply(self, CMD_GET_PROVIDER_INFO,
RSP_SUCCESS);
/* Keep state */
break;
- case IRLAN_GET_MEDIA_CMD:
- irlan_provider_send_reply(self, CMD_GET_MEDIA_CHAR,
+ case IRLAN_GET_MEDIA_CMD:
+ irlan_provider_send_reply(self, CMD_GET_MEDIA_CHAR,
RSP_SUCCESS);
/* Keep state */
- break;
+ break;
case IRLAN_OPEN_DATA_CMD:
ret = irlan_parse_open_data_cmd(self, skb);
if (self->provider.access_type == ACCESS_PEER) {
}
if (skb)
dev_kfree_skb(skb);
-
+
return 0;
}
* reply
*
*/
-static int irlan_provider_state_open(struct irlan_cb *self, IRLAN_EVENT event,
+static int irlan_provider_state_open(struct irlan_cb *self, IRLAN_EVENT event,
struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
switch(event) {
case IRLAN_FILTER_CONFIG_CMD:
irlan_provider_parse_command(self, CMD_FILTER_OPERATION, skb);
- irlan_provider_send_reply(self, CMD_FILTER_OPERATION,
+ irlan_provider_send_reply(self, CMD_FILTER_OPERATION,
RSP_SUCCESS);
/* Keep state */
break;
- case IRLAN_DATA_CONNECT_INDICATION:
+ case IRLAN_DATA_CONNECT_INDICATION:
irlan_next_provider_state(self, IRLAN_DATA);
irlan_provider_connect_response(self, self->tsap_data);
break;
* the local and remote machines.
*
*/
-static int irlan_provider_state_data(struct irlan_cb *self, IRLAN_EVENT event,
- struct sk_buff *skb)
+static int irlan_provider_state_data(struct irlan_cb *self, IRLAN_EVENT event,
+ struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
switch(event) {
case IRLAN_FILTER_CONFIG_CMD:
irlan_provider_parse_command(self, CMD_FILTER_OPERATION, skb);
- irlan_provider_send_reply(self, CMD_FILTER_OPERATION,
+ irlan_provider_send_reply(self, CMD_FILTER_OPERATION,
RSP_SUCCESS);
break;
case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
}
if (skb)
dev_kfree_skb(skb);
-
+
return 0;
}
/* Allocate master array */
irlap = hashbin_new(HB_LOCK);
if (irlap == NULL) {
- IRDA_ERROR("%s: can't allocate irlap hashbin!\n",
+ IRDA_ERROR("%s: can't allocate irlap hashbin!\n",
__FUNCTION__);
return -ENOMEM;
}
int count = 0;
/*
- * Remove all the ack-ed frames from the window queue.
- */
+ * Remove all the ack-ed frames from the window queue.
+ */
/*
* Optimize for the common case. It is most likely that the receiver
spin_lock_irq(&irlap->hb_spinlock);
iter->id = 0;
- for (self = (struct irlap_cb *) hashbin_get_first(irlap);
+ for (self = (struct irlap_cb *) hashbin_get_first(irlap);
self; self = (struct irlap_cb *) hashbin_get_next(irlap)) {
if (iter->id == *pos)
break;
++iter->id;
}
-
+
return self;
}
{
const struct irlap_iter_state *iter = seq->private;
const struct irlap_cb *self = v;
-
+
IRDA_ASSERT(self->magic == LAP_MAGIC, return -EINVAL;);
seq_printf(seq, "irlap%d ", iter->id);
struct seq_file *seq;
int rc = -ENOMEM;
struct irlap_iter_state *s = kzalloc(sizeof(*s), GFP_KERNEL);
-
+
if (!s)
goto out;
irlap_disconnect_indication(self, LAP_DISC_INDICATION);
break;
default:
- IRDA_DEBUG(1, "%s(), Unknown event %d, %s\n", __FUNCTION__,
+ IRDA_DEBUG(1, "%s(), Unknown event %d, %s\n", __FUNCTION__,
event, irlap_event[event]);
ret = -1;
* between 15 msecs and 45 msecs.
*/
irlap_start_backoff_timer(self, msecs_to_jiffies(20 +
- (jiffies % 30)));
+ (jiffies % 30)));
} else {
/* Always switch state before calling upper layers */
irlap_next_state(self, LAP_NDM);
/* Resend rejected frames */
irlap_resend_rejected_frames(self, CMD_FRAME);
- /* Give peer some time to retransmit!
+ /* Give peer some time to retransmit!
* But account for our own Tx. */
irlap_start_final_timer(self, 2 * self->final_timeout);
IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
return;
}
-
+
xid = (struct xid_frame *) skb->data;
info->daddr = le32_to_cpu(xid->saddr);
IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
return;
}
-
+
xid = (struct xid_frame *) skb->data;
info->daddr = le32_to_cpu(xid->saddr);
*/
if (info->s == 0xff) {
/* Check if things are sane at this point... */
- if((discovery_info == NULL) ||
+ if((discovery_info == NULL) ||
!pskb_may_pull(skb, 3)) {
IRDA_ERROR("%s: discovery frame to short!\n",
__FUNCTION__);
* Remove IrLMP layer
*
*/
-void __exit irlmp_cleanup(void)
+void __exit irlmp_cleanup(void)
{
/* Check for main structure */
IRDA_ASSERT(irlmp != NULL, return;);
/*
* Start a single discovery operation if discovery is not already
- * running
+ * running
*/
if (!sysctl_discovery) {
/* Check if user wants to override the default */
/* Refresh current hint bits */
spin_lock_irqsave(&irlmp->services->hb_spinlock, flags);
- service = (irlmp_service_t *) hashbin_get_first(irlmp->services);
- while (service) {
+ service = (irlmp_service_t *) hashbin_get_first(irlmp->services);
+ while (service) {
irlmp->hints.word |= service->hints.word;
- service = (irlmp_service_t *)hashbin_get_next(irlmp->services);
- }
+ service = (irlmp_service_t *)hashbin_get_next(irlmp->services);
+ }
spin_unlock_irqrestore(&irlmp->services->hb_spinlock, flags);
return 0;
}
spin_lock_irq(&iter->hashbin->hb_spinlock);
for (element = hashbin_get_first(iter->hashbin);
- element != NULL;
+ element != NULL;
element = hashbin_get_next(iter->hashbin)) {
if (!off || *off-- == 0) {
/* NB: hashbin left locked */
if (v == NULL) { /* no more in this hash bin */
spin_unlock_irq(&iter->hashbin->hb_spinlock);
- if (iter->hashbin == irlmp->unconnected_lsaps)
+ if (iter->hashbin == irlmp->unconnected_lsaps)
v = LINK_START_TOKEN;
iter->hashbin = NULL;
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",
+ IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n",
__FUNCTION__, irlmp_event[event], self->slsap_sel);
break;
}
/*********************************************************************
- *
+ *
* Filename: irlmp_frame.c
* Version: 0.9
* Description: IrLMP frame implementation
* Created at: Tue Aug 19 02:09:59 1997
* Modified at: Mon Dec 13 13:41:12 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
+ *
+ * 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.
*
********************************************************************/
#include <net/irda/irlmp_frame.h>
#include <net/irda/discovery.h>
-static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap,
+static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap,
__u8 slsap, int status, hashbin_t *);
inline void irlmp_send_data_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
* Send Link Control Frame to IrLAP
*/
void irlmp_send_lcf_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
- __u8 opcode, struct sk_buff *skb)
+ __u8 opcode, struct sk_buff *skb)
{
__u8 *frame;
-
+
IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
IRDA_ASSERT(skb != NULL, return;);
-
+
frame = skb->data;
-
+
frame[0] = dlsap | CONTROL_BIT;
frame[1] = slsap;
* Used by IrLAP to pass received data frames to IrLMP layer
*
*/
-void irlmp_link_data_indication(struct lap_cb *self, struct sk_buff *skb,
+void irlmp_link_data_indication(struct lap_cb *self, struct sk_buff *skb,
int unreliable)
{
struct lsap_cb *lsap;
__u8 slsap_sel; /* Source (this) LSAP address */
__u8 dlsap_sel; /* Destination LSAP address */
__u8 *fp;
-
+
IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
IRDA_ASSERT(self != NULL, return;);
fp = skb->data;
/*
- * The next statements may be confusing, but we do this so that
+ * The next statements may be confusing, but we do this so that
* destination LSAP of received frame is source LSAP in our view
*/
- slsap_sel = fp[0] & LSAP_MASK;
- dlsap_sel = fp[1];
+ slsap_sel = fp[0] & LSAP_MASK;
+ dlsap_sel = fp[1];
/*
* Check if this is an incoming connection, since we must deal with
IRDA_DEBUG(3, "%s(), incoming connection, "
"source LSAP=%d, dest LSAP=%d\n",
__FUNCTION__, slsap_sel, dlsap_sel);
-
+
/* Try to find LSAP among the unconnected LSAPs */
lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, CONNECT_CMD,
irlmp->unconnected_lsaps);
-
+
/* Maybe LSAP was already connected, so try one more time */
if (!lsap) {
IRDA_DEBUG(1, "%s(), incoming connection for LSAP already connected\n", __FUNCTION__);
self->lsaps);
}
} else
- lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
+ lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
self->lsaps);
-
+
if (lsap == NULL) {
IRDA_DEBUG(2, "IrLMP, Sorry, no LSAP for received frame!\n");
IRDA_DEBUG(2, "%s(), slsap_sel = %02x, dlsap_sel = %02x\n",
return;
}
- /*
- * Check if we received a control frame?
+ /*
+ * Check if we received a control frame?
*/
if (fp[0] & CONTROL_BIT) {
switch (fp[2]) {
case DISCONNECT:
IRDA_DEBUG(4, "%s(), Disconnect indication!\n",
__FUNCTION__);
- irlmp_do_lsap_event(lsap, LM_DISCONNECT_INDICATION,
+ irlmp_do_lsap_event(lsap, LM_DISCONNECT_INDICATION,
skb);
break;
case ACCESSMODE_CMD:
irlmp_udata_indication(lsap, skb);
else
irlmp_do_lsap_event(lsap, LM_UDATA_INDICATION, skb);
- } else {
+ } else {
/* Optimize and bypass the state machine if possible */
if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY)
irlmp_data_indication(lsap, skb);
/*
* Function irlmp_link_unitdata_indication (self, skb)
*
- *
+ *
*
*/
#ifdef CONFIG_IRDA_ULTRA
__u8 pid; /* Protocol identifier */
__u8 *fp;
unsigned long flags;
-
+
IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
IRDA_ASSERT(self != NULL, return;);
fp = skb->data;
/*
- * The next statements may be confusing, but we do this so that
+ * The next statements may be confusing, but we do this so that
* destination LSAP of received frame is source LSAP in our view
*/
- slsap_sel = fp[0] & LSAP_MASK;
+ slsap_sel = fp[0] & LSAP_MASK;
dlsap_sel = fp[1];
pid = fp[2];
-
+
if (pid & 0x80) {
IRDA_DEBUG(0, "%s(), extension in PID not supp!\n",
__FUNCTION__);
IRDA_DEBUG(0, "%s(), dropping frame!\n", __FUNCTION__);
return;
}
-
+
/* Search the connectionless LSAP */
spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags);
lsap = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps);
/*
* Check if source LSAP and dest LSAP selectors and PID match.
*/
- if ((lsap->slsap_sel == slsap_sel) &&
- (lsap->dlsap_sel == dlsap_sel) &&
- (lsap->pid == pid))
- {
+ if ((lsap->slsap_sel == slsap_sel) &&
+ (lsap->dlsap_sel == dlsap_sel) &&
+ (lsap->pid == pid))
+ {
break;
}
lsap = (struct lsap_cb *) hashbin_get_next(irlmp->unconnected_lsaps);
/*
* Function irlmp_link_disconnect_indication (reason, userdata)
*
- * IrLAP has disconnected
+ * IrLAP has disconnected
*
*/
-void irlmp_link_disconnect_indication(struct lap_cb *lap,
- struct irlap_cb *irlap,
- LAP_REASON reason,
+void irlmp_link_disconnect_indication(struct lap_cb *lap,
+ struct irlap_cb *irlap,
+ LAP_REASON reason,
struct sk_buff *skb)
{
IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
lap->reason = reason;
lap->daddr = DEV_ADDR_ANY;
- /* FIXME: must do something with the skb if any */
-
+ /* FIXME: must do something with the skb if any */
+
/*
* Inform station state machine
*/
* Incoming LAP connection!
*
*/
-void irlmp_link_connect_indication(struct lap_cb *self, __u32 saddr,
+void irlmp_link_connect_indication(struct lap_cb *self, __u32 saddr,
__u32 daddr, struct qos_info *qos,
- struct sk_buff *skb)
+ struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
* LAP connection confirmed!
*
*/
-void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos,
+void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos,
struct sk_buff *skb)
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
*
* Jean II
*/
-void irlmp_link_discovery_indication(struct lap_cb *self,
+void irlmp_link_discovery_indication(struct lap_cb *self,
discovery_t *discovery)
{
IRDA_ASSERT(self != NULL, return;);
/* Add to main log, cleanup */
irlmp_add_discovery(irlmp->cachelog, discovery);
-
+
/* Just handle it the same way as a discovery confirm,
* bypass the LM_LAP state machine (see below) */
irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_PASSIVE);
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
-
+
/* Add to main log, cleanup */
irlmp_add_discovery_log(irlmp->cachelog, log);
* Find handle associated with destination and source LSAP
*
* Any IrDA connection (LSAP/TSAP) is uniquely identified by
- * 3 parameters, the local lsap, the remote lsap and the remote address.
+ * 3 parameters, the local lsap, the remote lsap and the remote address.
* We may initiate multiple connections to the same remote service
* (they will have different local lsap), a remote device may initiate
* multiple connections to the same local service (they will have
*/
static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap_sel,
__u8 slsap_sel, int status,
- hashbin_t *queue)
+ hashbin_t *queue)
{
struct lsap_cb *lsap;
unsigned long flags;
-
- /*
+
+ /*
* Optimize for the common case. We assume that the last frame
* received is in the same connection as the last one, so check in
* cache first to avoid the linear search
*/
#ifdef CONFIG_IRDA_CACHE_LAST_LSAP
- if ((self->cache.valid) &&
- (self->cache.slsap_sel == slsap_sel) &&
- (self->cache.dlsap_sel == dlsap_sel))
+ if ((self->cache.valid) &&
+ (self->cache.slsap_sel == slsap_sel) &&
+ (self->cache.dlsap_sel == dlsap_sel))
{
return (self->cache.lsap);
}
lsap = (struct lsap_cb *) hashbin_get_first(queue);
while (lsap != NULL) {
- /*
- * If this is an incoming connection, then the destination
- * LSAP selector may have been specified as LM_ANY so that
+ /*
+ * If this is an incoming connection, then the destination
+ * LSAP selector may have been specified as LM_ANY so that
* any client can connect. In that case we only need to check
* if the source LSAP (in our view!) match!
*/
- if ((status == CONNECT_CMD) &&
- (lsap->slsap_sel == slsap_sel) &&
+ if ((status == CONNECT_CMD) &&
+ (lsap->slsap_sel == slsap_sel) &&
(lsap->dlsap_sel == LSAP_ANY)) {
/* This is where the dest lsap sel is set on incoming
* lsaps */
/*
* Check if source LSAP and dest LSAP selectors match.
*/
- if ((lsap->slsap_sel == slsap_sel) &&
- (lsap->dlsap_sel == dlsap_sel))
+ if ((lsap->slsap_sel == slsap_sel) &&
+ (lsap->dlsap_sel == dlsap_sel))
break;
lsap = (struct lsap_cb *) hashbin_get_next(queue);
/*********************************************************************
- *
+ *
* Filename: irmod.c
* Version: 0.9
* Description: IrDA stack main entry points
* Created at: Mon Dec 15 13:55:39 1997
* Modified at: Wed Jan 5 15:12:41 2000
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1997, 1999-2000 Dag Brattli, All Rights Reserved.
* Copyright (c) 2000-2004 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.
- *
+ *
********************************************************************/
/*
extern int irsock_init(void);
extern void irsock_cleanup(void);
/* irlap_frame.c */
-extern int irlap_driver_rcv(struct sk_buff *, struct net_device *,
+extern int irlap_driver_rcv(struct sk_buff *, struct net_device *,
struct packet_type *, struct net_device *);
/*
IRDA_DEBUG(0, "%s()\n", __FUNCTION__);
/* Lower layer of the stack */
- irlmp_init();
+ irlmp_init();
irlap_init();
-
+
/* Higher layers of the stack */
iriap_init();
- irttp_init();
+ irttp_init();
irsock_init();
-
+
/* Add IrDA packet type (Start receiving packets) */
- dev_add_pack(&irda_packet_type);
+ dev_add_pack(&irda_packet_type);
/* External APIs */
#ifdef CONFIG_PROC_FS
#endif
/* Driver/dongle support */
- irda_device_init();
+ irda_device_init();
return 0;
}
/* Remove External APIs */
#ifdef CONFIG_SYSCTL
irda_sysctl_unregister();
-#endif
+#endif
#ifdef CONFIG_PROC_FS
irda_proc_unregister();
#endif
/* Remove IrDA packet type (stop receiving packets) */
- dev_remove_pack(&irda_packet_type);
-
+ dev_remove_pack(&irda_packet_type);
+
/* Remove higher layers */
irsock_cleanup();
irttp_cleanup();
*/
subsys_initcall(irda_init);
module_exit(irda_cleanup);
-
+
MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no> & Jean Tourrilhes <jt@hpl.hp.com>");
-MODULE_DESCRIPTION("The Linux IrDA Protocol Stack");
+MODULE_DESCRIPTION("The Linux IrDA Protocol Stack");
MODULE_LICENSE("GPL");
MODULE_ALIAS_NETPROTO(PF_IRDA);
* the generic Linux PPP driver. Because IrNET depend on recent
* changes of the PPP driver interface, IrNET will work only with very
* recent kernel (2.3.99-pre6 and up).
- *
+ *
* The present implementation offer the following features :
* o simple user interface using pppd
* o efficient implementation (interface directly to PPP and IrTTP)
#define DEBUG_ASSERT 0 /* Verify all assertions */
-/*
+/*
* These are the macros we are using to actually print the debug
* statements. Don't look at it, it's ugly...
*
/* Open an IrTTP instance */
self->tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT,
- ¬ify);
+ ¬ify);
DABORT(self->tsap == NULL, -ENOMEM,
IRDA_SR_ERROR, "Unable to allocate TSAP !\n");
if(value->t.integer != -1)
/* Get the remote TSAP selector */
dtsap_sel = value->t.integer;
- else
+ else
self->errno = -EADDRNOTAVAIL;
break;
default:
}
/* Connect to remote device */
- err = irttp_connect_request(self->tsap, self->dtsap_sel,
- self->rsaddr, self->daddr, NULL,
+ err = irttp_connect_request(self->tsap, self->dtsap_sel,
+ self->rsaddr, self->daddr, NULL,
self->max_sdu_size_rx, NULL);
if(err != 0)
{
if(discoveries == NULL)
DRETURN(-ENETUNREACH, IRDA_SR_INFO, "Cachelog empty...\n");
- /*
+ /*
* Now, check all discovered devices (if any), and connect
* client only about the services that the client is
* interested in...
/* Unregister with LM-IAS */
if(self->iriap)
- {
+ {
iriap_close(self->iriap);
self->iriap = NULL;
}
/* Register with LM-IAS (so that people can connect to us) */
irnet_server.ias_obj = irias_new_object(IRNET_SERVICE_NAME, jiffies);
- irias_add_integer_attrib(irnet_server.ias_obj, IRNET_IAS_VALUE,
+ irias_add_integer_attrib(irnet_server.ias_obj, IRNET_IAS_VALUE,
irnet_server.s.stsap_sel, IAS_KERNEL_ATTR);
irias_insert_object(irnet_server.ias_obj);
*/
static void
irnet_disconnect_indication(void * instance,
- void * sap,
+ void * sap,
LM_REASON reason,
struct sk_buff *skb)
{
*/
static void
irnet_connect_confirm(void * instance,
- void * sap,
+ void * sap,
struct qos_info *qos,
__u32 max_sdu_size,
- __u8 max_header_size,
+ __u8 max_header_size,
struct sk_buff *skb)
{
irnet_socket * self = (irnet_socket *) instance;
static void
irnet_flow_indication(void * instance,
void * sap,
- LOCAL_FLOW flow)
+ LOCAL_FLOW flow)
{
irnet_socket * self = (irnet_socket *) instance;
LOCAL_FLOW oldflow = self->tx_flow;
* Some other node is attempting to connect to the IrNET service, and has
* sent a connection request on our server socket.
* We just redirect the connection to the relevant IrNET socket.
- *
+ *
* Note : we also make sure that between 2 irnet nodes, there can
* exist only one irnet connection.
*/
static void
irnet_connect_indication(void * instance,
- void * sap,
+ void * sap,
struct qos_info *qos,
__u32 max_sdu_size,
__u8 max_header_size,
*/
static void
irnet_getvalue_confirm(int result,
- __u16 obj_id,
+ __u16 obj_id,
struct ias_value *value,
void * priv)
{
*/
static void
irnet_discovervalue_confirm(int result,
- __u16 obj_id,
+ __u16 obj_id,
struct ias_value *value,
void * priv)
{
void * priv)
{
irnet_socket * self = &irnet_server.s;
-
+
DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self);
DASSERT(priv == &irnet_server, , IRDA_OCB_ERROR,
"Invalid instance (0x%p) !!!\n", priv);
void * priv)
{
irnet_socket * self = &irnet_server.s;
-
+
DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self);
DASSERT(priv == &irnet_server, , IRDA_OCB_ERROR,
"Invalid instance (0x%p) !!!\n", priv);
int i = 0;
len = 0;
-
+
/* Get the IrNET server information... */
len += sprintf(buf+len, "IrNET server - ");
len += sprintf(buf+len, "IrDA state: %s, ",
memset(&irnet_server, 0, sizeof(struct irnet_root));
/* Setup start of irnet instance list */
- irnet_server.list = hashbin_new(HB_NOLOCK);
+ irnet_server.list = hashbin_new(HB_NOLOCK);
DABORT(irnet_server.list == NULL, -ENOMEM,
MODULE_ERROR, "Can't allocate hashbin!\n");
/* Init spinlock for instance list */
void *);
static void
irnet_discovervalue_confirm(int,
- __u16,
+ __u16,
struct ias_value *,
void *);
#ifdef DISCOVERY_EVENTS
/* Check if we recognised one of the known command
* We can't use "switch" with strings, so hack with "continue" */
-
+
/* First command : name -> Requested IrDA nickname */
if(!strncmp(start, "name", 4))
{
break;
/* Set DTR/RTS */
- case TIOCMBIS:
+ case TIOCMBIS:
case TIOCMBIC:
/* Set exclusive/non-exclusive mode */
case TIOCEXCL:
ret = irttp_data_request(self->tsap, skb);
if(ret < 0)
{
- /*
+ /*
* > IrTTPs tx queue is full, so we just have to
* > drop the frame! You might think that we should
* > just return -1 and don't deallocate the frame,
* > we have replaced the original skb with a new
* > one with larger headroom, and that would really
* > confuse do_dev_queue_xmit() in dev.c! I have
- * > tried :-) DB
+ * > tried :-) DB
* Correction : we verify the flow control above (self->tx_flow),
* so we come here only if IrTTP doesn't like the packet (empty,
* too large, IrTTP not connected). In those rare cases, it's ok
module_init(irnet_init);
module_exit(irnet_cleanup);
MODULE_AUTHOR("Jean Tourrilhes <jt@hpl.hp.com>");
-MODULE_DESCRIPTION("IrNET : Synchronous PPP over IrDA");
+MODULE_DESCRIPTION("IrNET : Synchronous PPP over IrDA");
MODULE_LICENSE("GPL");
MODULE_ALIAS_CHARDEV(10, 187);
/*********************************************************************
- *
+ *
* Filename: irproc.c
* Version: 1.0
* Description: Various entries in the /proc file system
* Modified by: Dag Brattli <dagb@cs.uit.no>
*
* Copyright (c) 1998-1999, Dag Brattli <dagb@cs.uit.no>
- * Copyright (c) 1998, Thomas Davis, <ratbert@radiks.net>,
+ * Copyright (c) 1998, Thomas Davis, <ratbert@radiks.net>,
* All Rights Reserved.
- *
- * 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.
- *
- * I, Thomas Davis, provide no warranty for any of this software.
- * This material is provided "AS-IS" and at no charge.
- *
+ *
+ * I, Thomas Davis, provide no warranty for any of this software.
+ * This material is provided "AS-IS" and at no charge.
+ *
********************************************************************/
#include <linux/miscdevice.h>
struct proc_dir_entry *proc_irda;
EXPORT_SYMBOL(proc_irda);
-
+
static struct irda_entry irda_dirs[] = {
{"discovery", &discovery_seq_fops},
{"irttp", &irttp_seq_fops},
* Register irda entry in /proc file system
*
*/
-void __init irda_proc_register(void)
+void __init irda_proc_register(void)
{
int i;
struct proc_dir_entry *d;
for (i=0; i<ARRAY_SIZE(irda_dirs); i++) {
d = create_proc_entry(irda_dirs[i].name, 0, proc_irda);
- if (d)
+ if (d)
d->proc_fops = irda_dirs[i].fops;
}
}
* Unregister irda entry in /proc file system
*
*/
-void __exit irda_proc_unregister(void)
+void __exit irda_proc_unregister(void)
{
int i;
- if (proc_irda) {
-
for (i=0; i<ARRAY_SIZE(irda_dirs); i++)
- remove_proc_entry(irda_dirs[i].name, proc_irda);
+ if (proc_irda) {
+ for (i=0; i<ARRAY_SIZE(irda_dirs); i++)
+ remove_proc_entry(irda_dirs[i].name, proc_irda);
- remove_proc_entry("irda", proc_net);
- proc_irda = NULL;
- }
+ remove_proc_entry("irda", proc_net);
+ proc_irda = NULL;
+ }
}
/*********************************************************************
- *
+ *
* Filename: irqueue.c
* Version: 0.3
* Description: General queue implementation
* Modified by: Dag Brattli <dagb@cs.uit.no>
* Modified at: Thu Jan 4 14:29:10 CET 2001
* Modified by: Marc Zyngier <mzyngier@freesurf.fr>
- *
+ *
* Copyright (C) 1998-1999, Aage Kvalnes <aage@cs.uit.no>
- * Copyright (C) 1998, Dag Brattli,
+ * Copyright (C) 1998, Dag Brattli,
* All Rights Reserved.
*
* This code is taken from the Vortex Operating System written by Aage
* Kvalnes. Aage has agreed that this code can use the GPL licence,
* although he does not use that licence in his own code.
- *
+ *
* This copyright does however _not_ include the ELF hash() function
* which I currently don't know which licence or copyright it
* has. Please inform me if you know.
- *
- * 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.
- *
+ *
********************************************************************/
/*
{
__u32 h = 0;
__u32 g;
-
+
while(*name) {
h = (h<<4) + *name++;
if ((g = (h & 0xf0000000)))
*/
static void enqueue_first(irda_queue_t **queue, irda_queue_t* element)
{
-
+
IRDA_DEBUG( 4, "%s()\n", __FUNCTION__);
/*
* Queue is empty. Insert one element into the queue.
*/
element->q_next = element->q_prev = *queue = element;
-
+
} else {
/*
* Queue is not empty. Insert element into front of queue.
irda_queue_t *ret;
IRDA_DEBUG( 4, "dequeue_first()\n");
-
+
/*
* Set return value
*/
ret = *queue;
-
+
if ( *queue == NULL ) {
/*
* Queue was empty.
*/
} else if ( (*queue)->q_next == *queue ) {
- /*
+ /*
* Queue only contained a single element. It will now be
- * empty.
+ * empty.
*/
*queue = NULL;
} else {
(*queue)->q_next->q_prev = (*queue)->q_prev;
*queue = (*queue)->q_next;
}
-
+
/*
* Return the removed entry (or NULL of queue was empty).
*/
static irda_queue_t *dequeue_general(irda_queue_t **queue, irda_queue_t* element)
{
irda_queue_t *ret;
-
+
IRDA_DEBUG( 4, "dequeue_general()\n");
-
+
/*
* Set return value
*/
ret = *queue;
-
+
if ( *queue == NULL ) {
/*
* Queue was empty.
*/
} else if ( (*queue)->q_next == *queue ) {
- /*
+ /*
* Queue only contained a single element. It will now be
- * empty.
+ * empty.
*/
*queue = NULL;
-
+
} else {
/*
* Remove specific element.
if ( (*queue) == element)
(*queue) = element->q_next;
}
-
+
/*
* Return the removed entry (or NULL of queue was empty).
*/
hashbin_t *hashbin_new(int type)
{
hashbin_t* hashbin;
-
+
/*
* Allocate new hashbin
*/
/*
* Function hashbin_delete (hashbin, free_func)
*
- * Destroy hashbin, the free_func can be a user supplied special routine
- * for deallocating this structure if it's complex. If not the user can
+ * Destroy hashbin, the free_func can be a user supplied special routine
+ * for deallocating this structure if it's complex. If not the user can
* just supply kfree, which should take care of the job.
*/
int hashbin_delete( hashbin_t* hashbin, FREE_FUNC free_func)
IRDA_ASSERT(hashbin != NULL, return -1;);
IRDA_ASSERT(hashbin->magic == HB_MAGIC, return -1;);
-
+
/* Synchronize */
if ( hashbin->hb_type & HB_LOCK ) {
spin_lock_irqsave(&hashbin->hb_spinlock, flags);
while (queue ) {
if (free_func)
(*free_func)(queue);
- queue = dequeue_first(
+ queue = dequeue_first(
(irda_queue_t**) &hashbin->hb_queue[i]);
}
}
-
+
/* Cleanup local data */
hashbin->hb_current = NULL;
hashbin->magic = ~HB_MAGIC;
* Insert an entry into the hashbin
*
*/
-void hashbin_insert(hashbin_t* hashbin, irda_queue_t* entry, long hashv,
+void hashbin_insert(hashbin_t* hashbin, irda_queue_t* entry, long hashv,
const char* name)
{
unsigned long flags = 0;
if ( hashbin->hb_type & HB_LOCK ) {
spin_lock_irqsave(&hashbin->hb_spinlock, flags);
} /* Default is no-lock */
-
+
/*
* Store name and key
*/
entry->q_hash = hashv;
if ( name )
strlcpy( entry->q_name, name, sizeof(entry->q_name));
-
+
/*
* Insert new entry first
*/
}
EXPORT_SYMBOL(hashbin_insert);
-/*
+/*
* Function hashbin_remove_first (hashbin)
*
* Remove first entry of the hashbin
}
-/*
+/*
* Function hashbin_remove (hashbin, hashv, name)
*
* Remove entry with the given name
IRDA_ASSERT( hashbin != NULL, return NULL;);
IRDA_ASSERT( hashbin->magic == HB_MAGIC, return NULL;);
-
+
/*
* Locate hashbin
*/
entry = entry->q_next;
} while ( entry != hashbin->hb_queue[ bin ] );
}
-
+
/*
* If entry was found, dequeue it
*/
if ( hashbin->hb_type & HB_LOCK ) {
spin_unlock_irqrestore(&hashbin->hb_spinlock, flags);
} /* Default is no-lock */
-
-
+
+
/* Return */
- if ( found )
+ if ( found )
return entry;
else
return NULL;
-
+
}
EXPORT_SYMBOL(hashbin_remove);
-/*
+/*
* Function hashbin_remove_this (hashbin, entry)
*
* Remove entry with the given name
IRDA_ASSERT( hashbin != NULL, return NULL;);
IRDA_ASSERT( hashbin->magic == HB_MAGIC, return NULL;);
IRDA_ASSERT( entry != NULL, return NULL;);
-
+
/* Synchronize */
if ( hashbin->hb_type & HB_LOCK ) {
spin_lock_irqsave(&hashbin->hb_spinlock, flags);
if ( name )
hashv = hash( name );
bin = GET_HASHBIN( hashv );
-
+
/*
* Search for entry
*/
* called before any calls to hashbin_get_next()!
*
*/
-irda_queue_t *hashbin_get_first( hashbin_t* hashbin)
+irda_queue_t *hashbin_get_first( hashbin_t* hashbin)
{
irda_queue_t *entry;
int i;
* Get next item in hashbin. A series of hashbin_get_next() calls must
* be started by a call to hashbin_get_first(). The function returns
* NULL when all items have been traversed
- *
+ *
* The context of the search is stored within the hashbin, so you must
* protect yourself from concurrent enumerations. - Jean II
*/
if ( hashbin->hb_current == NULL) {
IRDA_ASSERT( hashbin->hb_current != NULL, return NULL;);
return NULL;
- }
+ }
entry = hashbin->hb_current->q_next;
bin = GET_HASHBIN( entry->q_hash);
- /*
+ /*
* Make sure that we are not back at the beginning of the queue
- * again
+ * again
*/
if ( entry != hashbin->hb_queue[ bin ]) {
hashbin->hb_current = entry;
*/
if ( bin >= HASHBIN_SIZE)
return NULL;
-
+
/*
* Move to next queue in hashbin
*/
entry = hashbin->hb_queue[ i];
if ( entry) {
hashbin->hb_current = entry;
-
+
return entry;
}
}
/*********************************************************************
- *
+ *
* Filename: irsysctl.c
* Version: 1.0
* Description: Sysctl interface for IrDA
* Created at: Sun May 24 22:12:06 1998
* Modified at: Fri Jun 4 02:50:15 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
+ *
* Copyright (c) 1997, 1999 Dag Brattli, 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.
- *
+ *
********************************************************************/
#include <linux/mm.h>
.strategy = &sysctl_string
},
#ifdef CONFIG_IRDA_DEBUG
- {
+ {
.ctl_name = DEBUG,
.procname = "debug",
.data = &irda_debug,
},
#endif
#ifdef CONFIG_IRDA_FAST_RR
- {
+ {
.ctl_name = FAST_POLL,
.procname = "fast_poll_increase",
.data = &sysctl_fast_poll_increase,
* Unregister our sysctl interface
*
*/
-void __exit irda_sysctl_unregister(void)
+void __exit irda_sysctl_unregister(void)
{
unregister_sysctl_table(irda_table_header);
}
/*********************************************************************
- *
+ *
* Filename: irttp.c
* Version: 1.2
* Description: Tiny Transport Protocol (TTP) implementation
* Created at: Sun Aug 31 20:14:31 1997
* Modified at: Wed Jan 5 11:31:27 2000
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
- * Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
+ *
+ * Copyright (c) 1998-2000 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
+ *
+ * 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.
*
********************************************************************/
static void __irttp_close_tsap(struct tsap_cb *self);
-static int irttp_data_indication(void *instance, void *sap,
+static int irttp_data_indication(void *instance, void *sap,
struct sk_buff *skb);
-static int irttp_udata_indication(void *instance, void *sap,
+static int irttp_udata_indication(void *instance, void *sap,
struct sk_buff *skb);
-static void irttp_disconnect_indication(void *instance, void *sap,
+static void irttp_disconnect_indication(void *instance, void *sap,
LM_REASON reason, struct sk_buff *);
-static void irttp_connect_indication(void *instance, void *sap,
+static void irttp_connect_indication(void *instance, void *sap,
struct qos_info *qos, __u32 max_sdu_size,
__u8 header_size, struct sk_buff *skb);
-static void irttp_connect_confirm(void *instance, void *sap,
- struct qos_info *qos, __u32 max_sdu_size,
+static void irttp_connect_confirm(void *instance, void *sap,
+ struct qos_info *qos, __u32 max_sdu_size,
__u8 header_size, struct sk_buff *skb);
static void irttp_run_tx_queue(struct tsap_cb *self);
static void irttp_run_rx_queue(struct tsap_cb *self);
static void irttp_fragment_skb(struct tsap_cb *self, struct sk_buff *skb);
static struct sk_buff *irttp_reassemble_skb(struct tsap_cb *self);
static void irttp_todo_expired(unsigned long data);
-static int irttp_param_max_sdu_size(void *instance, irda_param_t *param,
+static int irttp_param_max_sdu_size(void *instance, irda_param_t *param,
int get);
static void irttp_flow_indication(void *instance, void *sap, LOCAL_FLOW flow);
* Called by module destruction/cleanup code
*
*/
-void __exit irttp_cleanup(void)
+void __exit irttp_cleanup(void)
{
/* Check for main structure */
IRDA_ASSERT(irttp->magic == TTP_MAGIC, return;);
err = self->notify.udata_indication(self->notify.instance,
self,skb);
/* Same comment as in irttp_do_data_indication() */
- if (!err)
+ if (!err)
return 0;
}
/* Either no handler, or handler returns an error */
/*
* If the peer device has given us some credits and we didn't have
- * anyone from before, then we need to shedule the tx queue.
+ * anyone from before, then we need to shedule the tx queue.
* We need to do that because our Tx have stopped (so we may not
* get any LAP flow indication) and the user may be stopped as
* well. - Jean II
spin_lock_irq(&irttp->tsaps->hb_spinlock);
iter->id = 0;
- for (self = (struct tsap_cb *) hashbin_get_first(irttp->tsaps);
+ for (self = (struct tsap_cb *) hashbin_get_first(irttp->tsaps);
self != NULL;
self = (struct tsap_cb *) hashbin_get_next(irttp->tsaps)) {
if (iter->id == *pos)
break;
++iter->id;
}
-
+
return self;
}
* safe. Returns the number of bytes that was parsed
*
*/
-int irda_param_extract_all(void *self, __u8 *buf, int len,
+int irda_param_extract_all(void *self, __u8 *buf, int len,
pi_param_info_t *info)
{
int ret = -1;
/*********************************************************************
- *
+ *
* Filename: qos.c
* Version: 1.0
* Description: IrLAP QoS parameter negotiation
* Created at: Tue Sep 9 00:00:26 1997
* Modified at: Sun Jan 30 14:29:16 2000
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
- * Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
+ *
+ * Copyright (c) 1998-2000 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.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
+ *
********************************************************************/
#include <asm/byteorder.h>
unsigned sysctl_max_tx_window = 7;
static int irlap_param_baud_rate(void *instance, irda_param_t *param, int get);
-static int irlap_param_link_disconnect(void *instance, irda_param_t *parm,
+static int irlap_param_link_disconnect(void *instance, irda_param_t *parm,
int get);
-static int irlap_param_max_turn_time(void *instance, irda_param_t *param,
+static int irlap_param_max_turn_time(void *instance, irda_param_t *param,
int get);
static int irlap_param_data_size(void *instance, irda_param_t *param, int get);
-static int irlap_param_window_size(void *instance, irda_param_t *param,
+static int irlap_param_window_size(void *instance, irda_param_t *param,
int get);
-static int irlap_param_additional_bofs(void *instance, irda_param_t *parm,
+static int irlap_param_additional_bofs(void *instance, irda_param_t *parm,
int get);
-static int irlap_param_min_turn_time(void *instance, irda_param_t *param,
+static int irlap_param_min_turn_time(void *instance, irda_param_t *param,
int get);
#ifndef CONFIG_IRDA_DYNAMIC_WINDOW
#endif
static __u32 min_turn_times[] = { 10000, 5000, 1000, 500, 100, 50, 10, 0 }; /* us */
-static __u32 baud_rates[] = { 2400, 9600, 19200, 38400, 57600, 115200, 576000,
+static __u32 baud_rates[] = { 2400, 9600, 19200, 38400, 57600, 115200, 576000,
1152000, 4000000, 16000000 }; /* bps */
static __u32 data_sizes[] = { 64, 128, 256, 512, 1024, 2048 }; /* bytes */
static __u32 add_bofs[] = { 48, 24, 12, 5, 3, 2, 1, 0 }; /* bytes */
static inline int value_index(__u32 value, __u32 *array, int size)
{
int i;
-
+
for (i=0; i < size; i++)
if (array[i] == value)
break;
* Returns value to index in array, easy!
*
*/
-static inline __u32 index_value(int index, __u32 *array)
+static inline __u32 index_value(int index, __u32 *array)
{
return array[index];
}
* Returns index to most significant bit (MSB) in word
*
*/
-static int msb_index (__u16 word)
+static int msb_index (__u16 word)
{
__u16 msb = 0x8000;
int index = 15; /* Current MSB */
*
* The purpose of this function is for layers and drivers to be able to
* set the maximum QoS possible and then "and in" their own limitations
- *
+ *
*/
void irda_init_max_qos_capabilies(struct qos_info *qos)
{
int i;
- /*
+ /*
* These are the maximum supported values as specified on pages
* 39-43 in IrLAP
*/
qos->min_turn_time.value = sysctl_min_tx_turn_time;
}
- /*
+ /*
* Not allowed to use a max turn time less than 500 ms if the baudrate
* is less than 115200
*/
- if ((qos->baud_rate.value < 115200) &&
+ if ((qos->baud_rate.value < 115200) &&
(qos->max_turn_time.value < 500))
{
- IRDA_DEBUG(0,
+ IRDA_DEBUG(0,
"%s(), adjusting max turn time from %d to 500 ms\n",
__FUNCTION__, qos->max_turn_time.value);
qos->max_turn_time.value = 500;
}
-
+
/*
- * The data size must be adjusted according to the baud rate and max
+ * The data size must be adjusted according to the baud rate and max
* turn time
*/
index = value_index(qos->data_size.value, data_sizes, 6);
- line_capacity = irlap_max_line_capacity(qos->baud_rate.value,
+ line_capacity = irlap_max_line_capacity(qos->baud_rate.value,
qos->max_turn_time.value);
#ifdef CONFIG_IRDA_DYNAMIC_WINDOW
* We just set the QoS capabilities for the peer station
*
*/
-int irlap_qos_negotiate(struct irlap_cb *self, struct sk_buff *skb)
+int irlap_qos_negotiate(struct irlap_cb *self, struct sk_buff *skb)
{
int ret;
-
- ret = irda_param_extract_all(self, skb->data, skb->len,
+
+ ret = irda_param_extract_all(self, skb->data, skb->len,
&irlap_param_info);
-
+
/* Convert the negotiated bits to values */
irda_qos_bits_to_value(&self->qos_tx);
irda_qos_bits_to_value(&self->qos_rx);
irlap_adjust_qos_settings(&self->qos_tx);
- IRDA_DEBUG(2, "Setting BAUD_RATE to %d bps.\n",
+ IRDA_DEBUG(2, "Setting BAUD_RATE to %d bps.\n",
self->qos_tx.baud_rate.value);
IRDA_DEBUG(2, "Setting DATA_SIZE to %d bytes\n",
self->qos_tx.data_size.value);
- IRDA_DEBUG(2, "Setting WINDOW_SIZE to %d\n",
+ IRDA_DEBUG(2, "Setting WINDOW_SIZE to %d\n",
self->qos_tx.window_size.value);
- IRDA_DEBUG(2, "Setting XBOFS to %d\n",
+ IRDA_DEBUG(2, "Setting XBOFS to %d\n",
self->qos_tx.additional_bofs.value);
IRDA_DEBUG(2, "Setting MAX_TURN_TIME to %d ms.\n",
self->qos_tx.max_turn_time.value);
IRDA_DEBUG(2, "Setting MIN_TURN_TIME to %d usecs.\n",
self->qos_tx.min_turn_time.value);
- IRDA_DEBUG(2, "Setting LINK_DISC to %d secs.\n",
+ IRDA_DEBUG(2, "Setting LINK_DISC to %d secs.\n",
self->qos_tx.link_disc_time.value);
return ret;
}
* Insert QoS negotiaion pararameters into frame
*
*/
-int irlap_insert_qos_negotiation_params(struct irlap_cb *self,
+int irlap_insert_qos_negotiation_params(struct irlap_cb *self,
struct sk_buff *skb)
{
int ret;
/* Insert data rate */
- ret = irda_param_insert(self, PI_BAUD_RATE, skb->tail,
+ ret = irda_param_insert(self, PI_BAUD_RATE, skb->tail,
skb_tailroom(skb), &irlap_param_info);
if (ret < 0)
return ret;
skb_put(skb, ret);
/* Insert max turnaround time */
- ret = irda_param_insert(self, PI_MAX_TURN_TIME, skb->tail,
+ ret = irda_param_insert(self, PI_MAX_TURN_TIME, skb->tail,
skb_tailroom(skb), &irlap_param_info);
if (ret < 0)
return ret;
skb_put(skb, ret);
/* Insert data size */
- ret = irda_param_insert(self, PI_DATA_SIZE, skb->tail,
+ ret = irda_param_insert(self, PI_DATA_SIZE, skb->tail,
skb_tailroom(skb), &irlap_param_info);
if (ret < 0)
return ret;
skb_put(skb, ret);
/* Insert window size */
- ret = irda_param_insert(self, PI_WINDOW_SIZE, skb->tail,
+ ret = irda_param_insert(self, PI_WINDOW_SIZE, skb->tail,
skb_tailroom(skb), &irlap_param_info);
if (ret < 0)
return ret;
skb_put(skb, ret);
/* Insert additional BOFs */
- ret = irda_param_insert(self, PI_ADD_BOFS, skb->tail,
+ ret = irda_param_insert(self, PI_ADD_BOFS, skb->tail,
skb_tailroom(skb), &irlap_param_info);
if (ret < 0)
return ret;
skb_put(skb, ret);
/* Insert minimum turnaround time */
- ret = irda_param_insert(self, PI_MIN_TURN_TIME, skb->tail,
+ ret = irda_param_insert(self, PI_MIN_TURN_TIME, skb->tail,
skb_tailroom(skb), &irlap_param_info);
if (ret < 0)
return ret;
skb_put(skb, ret);
/* Insert link disconnect/threshold time */
- ret = irda_param_insert(self, PI_LINK_DISC, skb->tail,
+ ret = irda_param_insert(self, PI_LINK_DISC, skb->tail,
skb_tailroom(skb), &irlap_param_info);
if (ret < 0)
return ret;
if (get) {
param->pv.i = self->qos_rx.baud_rate.bits;
- IRDA_DEBUG(2, "%s(), baud rate = 0x%02x\n",
- __FUNCTION__, param->pv.i);
+ IRDA_DEBUG(2, "%s(), baud rate = 0x%02x\n",
+ __FUNCTION__, param->pv.i);
} else {
- /*
+ /*
* Stations must agree on baud rate, so calculate
- * intersection
+ * intersection
*/
IRDA_DEBUG(2, "Requested BAUD_RATE: 0x%04x\n", (__u16) param->pv.i);
final = (__u16) param->pv.i & self->qos_rx.baud_rate.bits;
/*
* Function irlap_param_link_disconnect (instance, param, get)
*
- * Negotiate link disconnect/threshold time.
+ * Negotiate link disconnect/threshold time.
*
*/
-static int irlap_param_link_disconnect(void *instance, irda_param_t *param,
+static int irlap_param_link_disconnect(void *instance, irda_param_t *param,
int get)
{
__u16 final;
-
+
struct irlap_cb *self = (struct irlap_cb *) instance;
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
-
+
if (get)
param->pv.i = self->qos_rx.link_disc_time.bits;
else {
- /*
- * Stations must agree on link disconnect/threshold
+ /*
+ * Stations must agree on link disconnect/threshold
* time.
*/
IRDA_DEBUG(2, "LINK_DISC: %02x\n", (__u8) param->pv.i);
* will be negotiated independently for each station
*
*/
-static int irlap_param_max_turn_time(void *instance, irda_param_t *param,
+static int irlap_param_max_turn_time(void *instance, irda_param_t *param,
int get)
{
struct irlap_cb *self = (struct irlap_cb *) instance;
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
-
+
if (get)
param->pv.i = self->qos_rx.max_turn_time.bits;
else
static int irlap_param_data_size(void *instance, irda_param_t *param, int get)
{
struct irlap_cb *self = (struct irlap_cb *) instance;
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
-
+
if (get)
param->pv.i = self->qos_rx.data_size.bits;
else
* will be negotiated independently for each station
*
*/
-static int irlap_param_window_size(void *instance, irda_param_t *param,
+static int irlap_param_window_size(void *instance, irda_param_t *param,
int get)
{
struct irlap_cb *self = (struct irlap_cb *) instance;
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
-
+
if (get)
param->pv.i = self->qos_rx.window_size.bits;
else
static int irlap_param_additional_bofs(void *instance, irda_param_t *param, int get)
{
struct irlap_cb *self = (struct irlap_cb *) instance;
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
-
+
if (get)
param->pv.i = self->qos_rx.additional_bofs.bits;
else
* Negotiate the minimum turn around time. This is a type 1 parameter and
* will be negotiated independently for each station
*/
-static int irlap_param_min_turn_time(void *instance, irda_param_t *param,
+static int irlap_param_min_turn_time(void *instance, irda_param_t *param,
int get)
{
struct irlap_cb *self = (struct irlap_cb *) instance;
-
+
IRDA_ASSERT(self != NULL, return -1;);
IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
-
+
if (get)
param->pv.i = self->qos_rx.min_turn_time.bits;
else
line_capacity = max_line_capacities[i][j];
- IRDA_DEBUG(2, "%s(), line capacity=%d bytes\n",
+ IRDA_DEBUG(2, "%s(), line capacity=%d bytes\n",
__FUNCTION__, line_capacity);
-
+
return line_capacity;
}
int index;
IRDA_ASSERT(qos != NULL, return;);
-
+
index = msb_index(qos->baud_rate.bits);
qos->baud_rate.value = baud_rates[index];
index = msb_index(qos->min_turn_time.bits);
qos->min_turn_time.value = min_turn_times[index];
-
+
index = msb_index(qos->max_turn_time.bits);
qos->max_turn_time.value = max_turn_times[index];
index = msb_index(qos->link_disc_time.bits);
qos->link_disc_time.value = link_disc_times[index];
-
+
index = msb_index(qos->additional_bofs.bits);
qos->additional_bofs.value = add_bofs[index];
}
/*********************************************************************
- *
+ *
* Filename: timer.c
- * Version:
- * Description:
+ * Version:
+ * Description:
* Status: Experimental.
* Author: Dag Brattli <dagb@cs.uit.no>
* Created at: Sat Aug 16 00:59:29 1997
* Modified at: Wed Dec 8 12:50:34 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
- *
- * Copyright (c) 1997, 1999 Dag Brattli <dagb@cs.uit.no>,
+ *
+ * Copyright (c) 1997, 1999 Dag Brattli <dagb@cs.uit.no>,
* All Rights Reserved.
* Copyright (c) 2000-2002 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.
*
********************************************************************/
static void irlap_final_timer_expired(void* data);
static void irlap_wd_timer_expired(void* data);
static void irlap_backoff_timer_expired(void* data);
-static void irlap_media_busy_expired(void* data);
+static void irlap_media_busy_expired(void* data);
void irlap_start_slot_timer(struct irlap_cb *self, int timeout)
{
- irda_start_timer(&self->slot_timer, timeout, (void *) self,
+ irda_start_timer(&self->slot_timer, timeout, (void *) self,
irlap_slot_timer_expired);
}
/* Set or re-set the timer. We reset the timer for each received
* discovery query, which allow us to automatically adjust to
* the speed of the peer discovery (faster or slower). Jean II */
- irda_start_timer( &self->query_timer, timeout, (void *) self,
+ irda_start_timer( &self->query_timer, timeout, (void *) self,
irlap_query_timer_expired);
}
void irlap_start_final_timer(struct irlap_cb *self, int timeout)
{
- irda_start_timer(&self->final_timer, timeout, (void *) self,
+ irda_start_timer(&self->final_timer, timeout, (void *) self,
irlap_final_timer_expired);
}
void irlap_start_wd_timer(struct irlap_cb *self, int timeout)
{
- irda_start_timer(&self->wd_timer, timeout, (void *) self,
+ irda_start_timer(&self->wd_timer, timeout, (void *) self,
irlap_wd_timer_expired);
}
void irlap_start_backoff_timer(struct irlap_cb *self, int timeout)
{
- irda_start_timer(&self->backoff_timer, timeout, (void *) self,
+ irda_start_timer(&self->backoff_timer, timeout, (void *) self,
irlap_backoff_timer_expired);
}
void irlap_start_mbusy_timer(struct irlap_cb *self, int timeout)
{
- irda_start_timer(&self->media_busy_timer, timeout,
+ irda_start_timer(&self->media_busy_timer, timeout,
(void *) self, irlap_media_busy_expired);
}
irlap_do_event(self, MEDIA_BUSY_TIMER_EXPIRED, NULL, NULL);
}
-void irlmp_start_watchdog_timer(struct lsap_cb *self, int timeout)
+void irlmp_start_watchdog_timer(struct lsap_cb *self, int timeout)
{
irda_start_timer(&self->watchdog_timer, timeout, (void *) self,
irlmp_watchdog_timer_expired);
}
-void irlmp_start_discovery_timer(struct irlmp_cb *self, int timeout)
+void irlmp_start_discovery_timer(struct irlmp_cb *self, int timeout)
{
irda_start_timer(&self->discovery_timer, timeout, (void *) self,
irlmp_discovery_timer_expired);
}
-void irlmp_start_idle_timer(struct lap_cb *self, int timeout)
+void irlmp_start_idle_timer(struct lap_cb *self, int timeout)
{
irda_start_timer(&self->idle_timer, timeout, (void *) self,
irlmp_idle_timer_expired);
}
-void irlmp_stop_idle_timer(struct lap_cb *self)
+void irlmp_stop_idle_timer(struct lap_cb *self)
{
/* If timer is activated, kill it! */
del_timer(&self->idle_timer);
IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
irlap_do_event(self, SLOT_TIMER_EXPIRED, NULL, NULL);
-}
+}
/*
* Function irlap_query_timer_expired (data)
IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
irlap_do_event(self, QUERY_TIMER_EXPIRED, NULL, NULL);
-}
+}
/*
* Function irda_final_timer_expired (data)
*
- *
+ *
*
*/
static void irlap_final_timer_expired(void *data)
/*
* Function irda_wd_timer_expired (data)
*
- *
+ *
*
*/
static void irlap_wd_timer_expired(void *data)
{
struct irlap_cb *self = (struct irlap_cb *) data;
-
+
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
-
+
irlap_do_event(self, WD_TIMER_EXPIRED, NULL, NULL);
}
/*
* Function irda_backoff_timer_expired (data)
*
- *
+ *
*
*/
static void irlap_backoff_timer_expired(void *data)
{
struct irlap_cb *self = (struct irlap_cb *) data;
-
+
IRDA_ASSERT(self != NULL, return;);
IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
-
+
irlap_do_event(self, BACKOFF_TIMER_EXPIRED, NULL, NULL);
}
/*
* Function irtty_media_busy_expired (data)
*
- *
+ *
*/
void irlap_media_busy_expired(void* data)
{
case OUTSIDE_FRAME:
case BEGIN_FRAME:
default:
- /* We may receive multiple BOF at the start of frame */
+ /* We may receive multiple BOF at the start of frame */
break;
}
projects / linux-2.6-omap-h63xx.git / commitdiff