From 6819bc2e1e46c71711a8dddf4040e706b02973c0 Mon Sep 17 00:00:00 2001 From: YOSHIFUJI Hideaki Date: Fri, 9 Feb 2007 23:24:53 +0900 Subject: [NET] IRDA: Fix whitespace errors. Signed-off-by: YOSHIFUJI Hideaki Signed-off-by: David S. Miller --- net/irda/ircomm/ircomm_core.c | 98 ++++++------ net/irda/ircomm/ircomm_event.c | 72 ++++----- net/irda/ircomm/ircomm_lmp.c | 110 +++++++------- net/irda/ircomm/ircomm_param.c | 94 ++++++------ net/irda/ircomm/ircomm_ttp.c | 88 +++++------ net/irda/ircomm/ircomm_tty.c | 288 ++++++++++++++++++------------------ net/irda/ircomm/ircomm_tty_attach.c | 236 ++++++++++++++--------------- net/irda/ircomm/ircomm_tty_ioctl.c | 86 +++++------ 8 files changed, 536 insertions(+), 536 deletions(-) (limited to 'net/irda/ircomm') diff --git a/net/irda/ircomm/ircomm_core.c b/net/irda/ircomm/ircomm_core.c index ad6b6af3dd97..c28ee7bce26a 100644 --- a/net/irda/ircomm/ircomm_core.c +++ b/net/irda/ircomm/ircomm_core.c @@ -1,5 +1,5 @@ /********************************************************************* - * + * * Filename: ircomm_core.c * Version: 1.0 * Description: IrCOMM service interface @@ -8,25 +8,25 @@ * Created at: Sun Jun 6 20:37:34 1999 * Modified at: Tue Dec 21 13:26:41 1999 * Modified by: Dag Brattli - * + * * Copyright (c) 1999 Dag Brattli, All Rights Reserved. * Copyright (c) 2000-2003 Jean Tourrilhes - * - * 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 @@ -49,7 +49,7 @@ #include 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 @@ -69,22 +69,22 @@ hashbin_t *ircomm = NULL; 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; } @@ -139,7 +139,7 @@ struct ircomm_cb *ircomm_open(notify_t *notify, __u8 service_type, int line) hashbin_insert(ircomm, (irda_queue_t *) self, line, NULL); - ircomm_next_state(self, IRCOMM_IDLE); + ircomm_next_state(self, IRCOMM_IDLE); return self; } @@ -195,8 +195,8 @@ int ircomm_close(struct ircomm_cb *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); @@ -206,9 +206,9 @@ 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) { @@ -243,20 +243,20 @@ void ircomm_connect_indication(struct ircomm_cb *self, struct sk_buff *skb, 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 { @@ -282,7 +282,7 @@ int ircomm_connect_response(struct ircomm_cb *self, struct sk_buff *userdata) ret = ircomm_do_event(self, IRCOMM_CONNECT_RESPONSE, userdata, NULL); return ret; -} +} EXPORT_SYMBOL(ircomm_connect_response); @@ -299,7 +299,7 @@ void ircomm_connect_confirm(struct ircomm_cb *self, struct sk_buff *skb, 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 { @@ -322,7 +322,7 @@ int ircomm_data_request(struct ircomm_cb *self, struct sk_buff *skb) 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; @@ -337,7 +337,7 @@ EXPORT_SYMBOL(ircomm_data_request); * */ void ircomm_data_indication(struct ircomm_cb *self, struct sk_buff *skb) -{ +{ IRDA_DEBUG(4, "%s()\n", __FUNCTION__ ); IRDA_ASSERT(skb->len > 0, return;); @@ -363,9 +363,9 @@ void ircomm_process_data(struct ircomm_cb *self, struct sk_buff *skb) 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) @@ -375,7 +375,7 @@ void ircomm_process_data(struct ircomm_cb *self, struct sk_buff *skb) 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__ ); @@ -391,13 +391,13 @@ void ircomm_process_data(struct ircomm_cb *self, struct sk_buff *skb) 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; @@ -411,10 +411,10 @@ EXPORT_SYMBOL(ircomm_control_request); * 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) { @@ -427,8 +427,8 @@ static void ircomm_control_indication(struct ircomm_cb *self, /* 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 - @@ -455,7 +455,7 @@ int ircomm_disconnect_request(struct ircomm_cb *self, struct sk_buff *userdata) 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; } @@ -472,7 +472,7 @@ void ircomm_disconnect_indication(struct ircomm_cb *self, struct sk_buff *skb, struct ircomm_info *info) { IRDA_DEBUG(2, "%s()\n", __FUNCTION__ ); - + IRDA_ASSERT(info != NULL, return;); if (self->notify.disconnect_indication) { @@ -486,7 +486,7 @@ void ircomm_disconnect_indication(struct ircomm_cb *self, struct sk_buff *skb, /* * Function ircomm_flow_request (self, flow) * - * + * * */ void ircomm_flow_request(struct ircomm_cb *self, LOCAL_FLOW flow) @@ -517,7 +517,7 @@ static void *ircomm_seq_start(struct seq_file *seq, loff_t *pos) self = (struct ircomm_cb *) hashbin_get_next(ircomm)) { if (off++ == *pos) break; - + } return self; } @@ -535,7 +535,7 @@ static void ircomm_seq_stop(struct seq_file *seq, void *v) } 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; ); @@ -548,7 +548,7 @@ static int ircomm_seq_show(struct seq_file *seq, void *v) 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"); diff --git a/net/irda/ircomm/ircomm_event.c b/net/irda/ircomm/ircomm_event.c index 01f4e801a1ba..23d0468794e2 100644 --- a/net/irda/ircomm/ircomm_event.c +++ b/net/irda/ircomm/ircomm_event.c @@ -1,5 +1,5 @@ /********************************************************************* - * + * * Filename: ircomm_event.c * Version: 1.0 * Description: IrCOMM layer state machine @@ -8,24 +8,24 @@ * Created at: Sun Jun 6 20:33:11 1999 * Modified at: Sun Dec 12 13:44:32 1999 * Modified by: Dag Brattli - * + * * 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 @@ -41,13 +41,13 @@ #include #include -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[] = { @@ -60,26 +60,26 @@ 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, @@ -93,14 +93,14 @@ static int (*state[])(struct ircomm_cb *self, IRCOMM_EVENT event, * 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: @@ -119,10 +119,10 @@ static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event, /* * 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; @@ -152,8 +152,8 @@ static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event, * 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; @@ -185,7 +185,7 @@ static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event, * 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; @@ -228,7 +228,7 @@ static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event, * */ 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]); @@ -245,7 +245,7 @@ int ircomm_do_event(struct ircomm_cb *self, 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); } diff --git a/net/irda/ircomm/ircomm_lmp.c b/net/irda/ircomm/ircomm_lmp.c index c8e0d89ee11f..22bd75299104 100644 --- a/net/irda/ircomm/ircomm_lmp.c +++ b/net/irda/ircomm/ircomm_lmp.c @@ -1,5 +1,5 @@ /********************************************************************* - * + * * Filename: ircomm_lmp.c * Version: 1.0 * Description: Interface between IrCOMM and IrLMP @@ -9,25 +9,25 @@ * Modified at: Sun Dec 12 13:44:17 1999 * Modified by: Dag Brattli * Sources: Previous IrLPT work by Thomas Davis - * + * * Copyright (c) 1999 Dag Brattli, All Rights Reserved. * Copyright (c) 2000-2003 Jean Tourrilhes - * - * 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 @@ -45,11 +45,11 @@ /* * 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; @@ -61,14 +61,14 @@ static int ircomm_lmp_connect_request(struct ircomm_cb *self, 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, @@ -78,7 +78,7 @@ 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); @@ -88,8 +88,8 @@ static int ircomm_lmp_connect_response(struct ircomm_cb *self, /* 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, @@ -105,22 +105,22 @@ static int ircomm_lmp_connect_response(struct ircomm_cb *self, 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 */ @@ -136,7 +136,7 @@ static int ircomm_lmp_disconnect_request(struct ircomm_cb *self, * 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) @@ -150,29 +150,29 @@ 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) * @@ -180,7 +180,7 @@ static void ircomm_lmp_flow_control(struct sk_buff *skb) * */ 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; @@ -189,8 +189,8 @@ static int ircomm_lmp_data_request(struct ircomm_cb *self, 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__ ); @@ -199,13 +199,13 @@ static int ircomm_lmp_data_request(struct ircomm_cb *self, 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__); @@ -227,11 +227,11 @@ static int ircomm_lmp_data_indication(void *instance, void *sap, 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(). */ @@ -241,15 +241,15 @@ static int ircomm_lmp_data_indication(void *instance, void *sap, } /* - * 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) { @@ -312,7 +312,7 @@ static void ircomm_lmp_connect_indication(void *instance, void *sap, * 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) { diff --git a/net/irda/ircomm/ircomm_param.c b/net/irda/ircomm/ircomm_param.c index a39f5735a90b..fbac13e95b28 100644 --- a/net/irda/ircomm/ircomm_param.c +++ b/net/irda/ircomm/ircomm_param.c @@ -1,5 +1,5 @@ /********************************************************************* - * + * * Filename: ircomm_param.c * Version: 1.0 * Description: Parameter handling for the IrCOMM protocol @@ -8,24 +8,24 @@ * Created at: Mon Jun 7 10:25:11 1999 * Modified at: Sun Jan 30 14:32:03 2000 * Modified by: Dag Brattli - * + * * 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 @@ -41,23 +41,23 @@ #include -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); @@ -85,7 +85,7 @@ static pi_minor_info_t pi_minor_call_table_9_wire[] = { 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 } */ }; @@ -119,20 +119,20 @@ int ircomm_param_request(struct ircomm_tty_cb *self, __u8 pi, int flush) 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); @@ -162,7 +162,7 @@ int ircomm_param_request(struct ircomm_tty_cb *self, __u8 pi, int flush) * 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; @@ -179,7 +179,7 @@ static int ircomm_param_service_type(void *instance, irda_param_t *param, /* 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; } @@ -198,12 +198,12 @@ static int ircomm_param_service_type(void *instance, irda_param_t *param, 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 @@ -235,13 +235,13 @@ static int ircomm_param_port_type(void *instance, irda_param_t *param, int get) 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; @@ -256,7 +256,7 @@ 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, 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;); @@ -279,7 +279,7 @@ static int ircomm_param_port_name(void *instance, irda_param_t *param, int get) 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;); @@ -287,7 +287,7 @@ static int ircomm_param_data_rate(void *instance, irda_param_t *param, int get) 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; @@ -299,7 +299,7 @@ static int ircomm_param_data_rate(void *instance, irda_param_t *param, int get) * 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; @@ -311,7 +311,7 @@ static int ircomm_param_data_format(void *instance, irda_param_t *param, param->pv.i = self->settings.data_format; else self->settings.data_format = (__u8) param->pv.i; - + return 0; } @@ -321,14 +321,14 @@ static int ircomm_param_data_format(void *instance, irda_param_t *param, * 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 @@ -351,7 +351,7 @@ static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get) 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; @@ -360,7 +360,7 @@ static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get) 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; @@ -378,7 +378,7 @@ static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get) 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; @@ -396,10 +396,10 @@ static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get) /* * 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__ ); @@ -427,7 +427,7 @@ static int ircomm_param_dte(void *instance, irda_param_t *param, int get) dte = (__u8) param->pv.i; self->settings.dce = 0; - + if (dte & IRCOMM_DELTA_DTR) self->settings.dce |= (IRCOMM_DELTA_DSR| IRCOMM_DELTA_RI | @@ -436,7 +436,7 @@ static int ircomm_param_dte(void *instance, irda_param_t *param, int get) self->settings.dce |= (IRCOMM_DSR| IRCOMM_RI | IRCOMM_CD); - + if (dte & IRCOMM_DELTA_RTS) self->settings.dce |= IRCOMM_DELTA_CTS; if (dte & IRCOMM_RTS) @@ -455,7 +455,7 @@ static int ircomm_param_dte(void *instance, irda_param_t *param, int get) /* * Function ircomm_param_dce (instance, param) * - * + * * */ static int ircomm_param_dce(void *instance, irda_param_t *param, int get) diff --git a/net/irda/ircomm/ircomm_ttp.c b/net/irda/ircomm/ircomm_ttp.c index d98bf3570d29..bb06ebaadd16 100644 --- a/net/irda/ircomm/ircomm_ttp.c +++ b/net/irda/ircomm/ircomm_ttp.c @@ -1,5 +1,5 @@ /********************************************************************* - * + * * Filename: ircomm_ttp.c * Version: 1.0 * Description: Interface between IrCOMM and IrTTP @@ -8,25 +8,25 @@ * Created at: Sun Jun 6 20:48:27 1999 * Modified at: Mon Dec 13 11:35:13 1999 * Modified by: Dag Brattli - * + * * Copyright (c) 1999 Dag Brattli, All Rights Reserved. * Copyright (c) 2000-2003 Jean Tourrilhes - * - * 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 @@ -43,8 +43,8 @@ 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, @@ -54,25 +54,25 @@ 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) @@ -113,11 +113,11 @@ 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; @@ -129,16 +129,16 @@ static int ircomm_ttp_connect_request(struct ircomm_cb *self, 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, @@ -147,7 +147,7 @@ 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); @@ -160,14 +160,14 @@ static int ircomm_ttp_connect_response(struct ircomm_cb *self, /* * 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; @@ -176,7 +176,7 @@ static int ircomm_ttp_data_request(struct ircomm_cb *self, 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 */ @@ -210,7 +210,7 @@ static int ircomm_ttp_data_indication(void *instance, void *sap, 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;); @@ -224,8 +224,8 @@ static int ircomm_ttp_data_indication(void *instance, void *sap, } 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) { @@ -261,7 +261,7 @@ out: * 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, @@ -301,11 +301,11 @@ out: /* * 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; @@ -322,10 +322,10 @@ static int ircomm_ttp_disconnect_request(struct ircomm_cb *self, /* * 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) { @@ -361,7 +361,7 @@ static void ircomm_ttp_flow_indication(void *instance, void *sap, 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); } diff --git a/net/irda/ircomm/ircomm_tty.c b/net/irda/ircomm/ircomm_tty.c index 262bda808d96..3d241e415a2a 100644 --- a/net/irda/ircomm/ircomm_tty.c +++ b/net/irda/ircomm/ircomm_tty.c @@ -1,5 +1,5 @@ /********************************************************************* - * + * * Filename: ircomm_tty.c * Version: 1.0 * Description: IrCOMM serial TTY driver @@ -9,25 +9,25 @@ * Modified at: Wed Feb 23 00:09:02 2000 * Modified by: Dag Brattli * 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 - * - * 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 @@ -69,7 +69,7 @@ static int ircomm_tty_data_indication(void *instance, void *sap, 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, @@ -113,7 +113,7 @@ static int __init ircomm_tty_init(void) 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); @@ -163,11 +163,11 @@ static void __exit ircomm_tty_cleanup(void) { 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; } @@ -179,7 +179,7 @@ static void __exit ircomm_tty_cleanup(void) /* * Function ircomm_startup (self) * - * + * * */ static int ircomm_tty_startup(struct ircomm_tty_cb *self) @@ -203,17 +203,17 @@ 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) @@ -237,10 +237,10 @@ err: /* * 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); @@ -248,7 +248,7 @@ static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self, int do_clocal = 0, extra_count = 0; unsigned long flags; struct tty_struct *tty; - + IRDA_DEBUG(2, "%s()\n", __FUNCTION__ ); tty = self->tty; @@ -256,7 +256,7 @@ static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self, /* * 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; @@ -268,17 +268,17 @@ static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self, 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 ); @@ -290,7 +290,7 @@ static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self, } 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 @@ -298,45 +298,45 @@ static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self, * 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); @@ -344,14 +344,14 @@ static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self, 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; } /* @@ -384,7 +384,7 @@ static int ircomm_tty_open(struct tty_struct *tty, struct file *filp) IRDA_ERROR("%s(), kmalloc failed!\n", __FUNCTION__); return -ENOMEM; } - + self->magic = IRCOMM_TTY_MAGIC; self->flow = FLOW_STOP; @@ -398,13 +398,13 @@ static int ircomm_tty_open(struct tty_struct *tty, struct file *filp) /* 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; @@ -420,7 +420,7 @@ static int ircomm_tty_open(struct tty_struct *tty, struct file *filp) 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 */ @@ -473,7 +473,7 @@ static int ircomm_tty_open(struct tty_struct *tty, struct file *filp) 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); @@ -519,7 +519,7 @@ static void ircomm_tty_close(struct tty_struct *tty, struct file *filp) * 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; } @@ -546,7 +546,7 @@ static void ircomm_tty_close(struct tty_struct *tty, struct file *filp) 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; @@ -576,7 +576,7 @@ static void ircomm_tty_close(struct tty_struct *tty, struct file *filp) /* * Function ircomm_tty_flush_buffer (tty) * - * + * * */ static void ircomm_tty_flush_buffer(struct tty_struct *tty) @@ -586,9 +586,9 @@ 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); } @@ -597,7 +597,7 @@ static void ircomm_tty_flush_buffer(struct tty_struct *tty) * 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) @@ -638,7 +638,7 @@ 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; @@ -650,9 +650,9 @@ static void ircomm_tty_do_softint(struct work_struct *work) /* 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); @@ -717,12 +717,12 @@ static int ircomm_tty_write(struct tty_struct *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) { @@ -731,16 +731,16 @@ static int ircomm_tty_write(struct tty_struct *tty, /* 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 @@ -751,8 +751,8 @@ static int ircomm_tty_write(struct tty_struct *tty, 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; @@ -782,15 +782,15 @@ static int ircomm_tty_write(struct tty_struct *tty, 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; } @@ -846,7 +846,7 @@ static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout) 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;); @@ -876,7 +876,7 @@ static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout) * * 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) { @@ -890,16 +890,16 @@ 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); } /* @@ -930,7 +930,7 @@ static void ircomm_tty_unthrottle(struct tty_struct *tty) 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); } /* @@ -975,7 +975,7 @@ static void ircomm_tty_shutdown(struct ircomm_tty_cb *self) spin_lock_irqsave(&self->spinlock, flags); del_timer(&self->watchdog_timer); - + /* Free parameter buffer */ if (self->ctrl_skb) { dev_kfree_skb(self->ctrl_skb); @@ -1001,7 +1001,7 @@ static void ircomm_tty_shutdown(struct ircomm_tty_cb *self) * * This routine notifies the tty driver that it should hangup the tty * device. - * + * */ static void ircomm_tty_hangup(struct tty_struct *tty) { @@ -1044,7 +1044,7 @@ static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch) * 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) { @@ -1057,9 +1057,9 @@ 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; @@ -1094,14 +1094,14 @@ void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self) /*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); @@ -1113,10 +1113,10 @@ void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self) 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); @@ -1125,7 +1125,7 @@ void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self) } } else { if (!(status & IRCOMM_CTS)) { - IRDA_DEBUG(2, + IRDA_DEBUG(2, "%s(), CTS tx stop...\n", __FUNCTION__ ); tty->hw_stopped = 1; } @@ -1145,7 +1145,7 @@ static int ircomm_tty_data_indication(void *instance, void *sap, 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;); @@ -1155,10 +1155,10 @@ static int ircomm_tty_data_indication(void *instance, void *sap, 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)) { @@ -1170,9 +1170,9 @@ static int ircomm_tty_data_indication(void *instance, void *sap, 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); @@ -1195,14 +1195,14 @@ static int ircomm_tty_control_indication(void *instance, void *sap, 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() */ @@ -1217,7 +1217,7 @@ static int ircomm_tty_control_indication(void *instance, void *sap, * 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; @@ -1247,7 +1247,7 @@ static void ircomm_tty_flow_indication(void *instance, void *sap, 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]); @@ -1260,37 +1260,37 @@ static int ircomm_tty_line_info(struct ircomm_tty_cb *self, char *buf) 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); @@ -1314,7 +1314,7 @@ static int ircomm_tty_line_info(struct ircomm_tty_cb *self, char *buf) 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) @@ -1333,25 +1333,25 @@ static int ircomm_tty_line_info(struct ircomm_tty_cb *self, char *buf) 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 @@ -1359,8 +1359,8 @@ static int ircomm_tty_read_proc(char *buf, char **start, off_t offset, int len, 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); @@ -1370,25 +1370,25 @@ static int ircomm_tty_read_proc(char *buf, char **start, off_t offset, int len, 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 */ diff --git a/net/irda/ircomm/ircomm_tty_attach.c b/net/irda/ircomm/ircomm_tty_attach.c index 99f5eddbb4b7..8d7ba93e4e09 100644 --- a/net/irda/ircomm/ircomm_tty_attach.c +++ b/net/irda/ircomm/ircomm_tty_attach.c @@ -1,32 +1,32 @@ /********************************************************************* - * + * * Filename: ircomm_tty_attach.c - * Version: + * Version: * Description: Code for attaching the serial driver to IrCOMM * Status: Experimental. * Author: Dag Brattli * Created at: Sat Jun 5 17:42:00 1999 * Modified at: Tue Jan 4 14:20:49 2000 * Modified by: Dag Brattli - * + * * Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved. * Copyright (c) 2000-2003 Jean Tourrilhes - * - * 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 @@ -50,35 +50,35 @@ static void ircomm_tty_ias_register(struct ircomm_tty_cb *self); 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[] = { @@ -111,7 +111,7 @@ static char *ircomm_tty_event[] = { #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, @@ -125,7 +125,7 @@ static int (*state[])(struct ircomm_tty_cb *self, IRCOMM_TTY_EVENT event, * 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) @@ -135,7 +135,7 @@ 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; @@ -177,7 +177,7 @@ void ircomm_tty_detach_cable(struct ircomm_tty_cb *self) self->skey = NULL; } - if (self->iriap) { + if (self->iriap) { iriap_close(self->iriap); self->iriap = NULL; } @@ -212,7 +212,7 @@ static void ircomm_tty_ias_register(struct ircomm_tty_cb *self) 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) @@ -234,19 +234,19 @@ static void ircomm_tty_ias_register(struct ircomm_tty_cb *self) 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); @@ -302,23 +302,23 @@ int ircomm_tty_send_initial_parameters(struct ircomm_tty_cb *self) 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;*/ @@ -330,7 +330,7 @@ int ircomm_tty_send_initial_parameters(struct ircomm_tty_cb *self) 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); @@ -342,10 +342,10 @@ int ircomm_tty_send_initial_parameters(struct ircomm_tty_cb *self) #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; } @@ -388,8 +388,8 @@ static void ircomm_tty_discovery_indication(discinfo_t *discovery, 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); @@ -402,7 +402,7 @@ static void ircomm_tty_discovery_indication(discinfo_t *discovery, * 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) { @@ -422,7 +422,7 @@ void ircomm_tty_disconnect_indication(void *instance, void *sap, /* 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); } @@ -432,8 +432,8 @@ void ircomm_tty_disconnect_indication(void *instance, void *sap, * 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; @@ -454,18 +454,18 @@ static void ircomm_tty_getvalue_confirm(int result, __u16 obj_id, } 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) { @@ -491,10 +491,10 @@ static void ircomm_tty_getvalue_confirm(int result, __u16 obj_id, * 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; @@ -515,16 +515,16 @@ void ircomm_tty_connect_confirm(void *instance, void *sap, } /* - * 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; @@ -542,8 +542,8 @@ void ircomm_tty_connect_indication(void *instance, void *sap, 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); @@ -566,14 +566,14 @@ void ircomm_tty_link_established(struct ircomm_tty_cb *self) 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__ ); @@ -582,7 +582,7 @@ void ircomm_tty_link_established(struct ircomm_tty_cb *self) 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); } @@ -593,8 +593,8 @@ void ircomm_tty_link_established(struct ircomm_tty_cb *self) /* * 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, @@ -616,7 +616,7 @@ 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;); @@ -633,14 +633,14 @@ static void ircomm_tty_watchdog_timer_expired(void *data) * */ 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); } @@ -656,7 +656,7 @@ static inline void ircomm_tty_next_state(struct ircomm_tty_cb *self, IRCOMM_TTY_ 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; @@ -668,9 +668,9 @@ static inline void ircomm_tty_next_state(struct ircomm_tty_cb *self, IRCOMM_TTY_ * 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; @@ -679,10 +679,10 @@ static int ircomm_tty_state_idle(struct ircomm_tty_cb *self, 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: @@ -701,7 +701,7 @@ static int ircomm_tty_state_idle(struct ircomm_tty_cb *self, 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; @@ -732,9 +732,9 @@ static int ircomm_tty_state_idle(struct ircomm_tty_cb *self, * 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; @@ -752,19 +752,19 @@ static int ircomm_tty_state_search(struct ircomm_tty_cb *self, __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); @@ -783,7 +783,7 @@ static int ircomm_tty_state_search(struct ircomm_tty_cb *self, #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 @@ -805,9 +805,9 @@ static int ircomm_tty_state_search(struct ircomm_tty_cb *self, * 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; @@ -822,12 +822,12 @@ static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self, __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); @@ -836,7 +836,7 @@ static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self, 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); @@ -863,9 +863,9 @@ static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self, * 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; @@ -877,7 +877,7 @@ static int ircomm_tty_state_query_lsap_sel(struct ircomm_tty_cb *self, 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); @@ -912,9 +912,9 @@ static int ircomm_tty_state_query_lsap_sel(struct ircomm_tty_cb *self, * 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; @@ -926,10 +926,10 @@ static int ircomm_tty_state_setup(struct ircomm_tty_cb *self, 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); @@ -938,7 +938,7 @@ static int ircomm_tty_state_setup(struct ircomm_tty_cb *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); @@ -966,9 +966,9 @@ static int ircomm_tty_state_setup(struct ircomm_tty_cb *self, * 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; @@ -976,7 +976,7 @@ static int ircomm_tty_state_ready(struct ircomm_tty_cb *self, 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); diff --git a/net/irda/ircomm/ircomm_tty_ioctl.c b/net/irda/ircomm/ircomm_tty_ioctl.c index 75e39ea599d8..a5174e6e7ad3 100644 --- a/net/irda/ircomm/ircomm_tty_ioctl.c +++ b/net/irda/ircomm/ircomm_tty_ioctl.c @@ -1,31 +1,31 @@ /********************************************************************* - * + * * Filename: ircomm_tty_ioctl.c - * Version: - * Description: + * Version: + * Description: * Status: Experimental. * Author: Dag Brattli * Created at: Thu Jun 10 14:39:09 1999 * Modified at: Wed Jan 5 14:45:43 2000 * Modified by: Dag Brattli - * + * * 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 @@ -75,7 +75,7 @@ static void ircomm_tty_change_speed(struct ircomm_tty_cb *self) } if (cflag & CSTOPB) cval |= IRCOMM_2_STOP_BIT; - + if (cflag & PARENB) cval |= IRCOMM_PARITY_ENABLE; if (!(cflag & PARODD)) @@ -88,7 +88,7 @@ static void ircomm_tty_change_speed(struct ircomm_tty_cb *self) 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; @@ -104,7 +104,7 @@ static void ircomm_tty_change_speed(struct ircomm_tty_cb *self) self->flags &= ~ASYNC_CHECK_CD; else self->flags |= ASYNC_CHECK_CD; -#if 0 +#if 0 /* * Set up parity check flag */ @@ -113,7 +113,7 @@ static void ircomm_tty_change_speed(struct ircomm_tty_cb *self) 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 */ @@ -124,17 +124,17 @@ static void ircomm_tty_change_speed(struct ircomm_tty_cb *self) 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); } /* @@ -145,7 +145,7 @@ static void ircomm_tty_change_speed(struct ircomm_tty_cb *self) * 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; @@ -153,8 +153,8 @@ void ircomm_tty_set_termios(struct tty_struct *tty, 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; @@ -168,21 +168,21 @@ void ircomm_tty_set_termios(struct tty_struct *tty, 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); @@ -192,7 +192,7 @@ void ircomm_tty_set_termios(struct tty_struct *tty, /* * Function ircomm_tty_tiocmget (tty, file) * - * + * * */ int ircomm_tty_tiocmget(struct tty_struct *tty, struct file *file) @@ -217,12 +217,12 @@ 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__ ); @@ -249,21 +249,21 @@ int ircomm_tty_tiocmset(struct tty_struct *tty, struct file *file, 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; @@ -277,11 +277,11 @@ static int ircomm_tty_get_serial_info(struct ircomm_tty_cb *self, 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))) @@ -293,7 +293,7 @@ static int ircomm_tty_get_serial_info(struct ircomm_tty_cb *self, /* * Function set_serial_info (driver, new_info) * - * + * * */ static int ircomm_tty_set_serial_info(struct ircomm_tty_cb *self, @@ -311,7 +311,7 @@ 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) || @@ -368,10 +368,10 @@ static int ircomm_tty_set_serial_info(struct ircomm_tty_cb *self, /* * 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; @@ -416,7 +416,7 @@ int ircomm_tty_ioctl(struct tty_struct *tty, struct file *file, 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 */ -- cgit v1.2.3-59-g8ed1b