1 /*********************************************************************
3 * Filename: ircomm_core.c
5 * Description: IrCOMM service interface
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sun Jun 6 20:37:34 1999
9 * Modified at: Tue Dec 21 13:26:41 1999
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
12 * Copyright (c) 1999 Dag Brattli, All Rights Reserved.
13 * Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License as
17 * published by the Free Software Foundation; either version 2 of
18 * the License, or (at your option) any later version.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
30 ********************************************************************/
32 #include <linux/module.h>
33 #include <linux/proc_fs.h>
34 #include <linux/seq_file.h>
35 #include <linux/init.h>
37 #include <net/irda/irda.h>
38 #include <net/irda/irmod.h>
39 #include <net/irda/irlmp.h>
40 #include <net/irda/iriap.h>
41 #include <net/irda/irttp.h>
42 #include <net/irda/irias_object.h>
44 #include <net/irda/ircomm_event.h>
45 #include <net/irda/ircomm_lmp.h>
46 #include <net/irda/ircomm_ttp.h>
47 #include <net/irda/ircomm_param.h>
48 #include <net/irda/ircomm_core.h>
50 static int __ircomm_close(struct ircomm_cb
*self
);
51 static void ircomm_control_indication(struct ircomm_cb
*self
,
52 struct sk_buff
*skb
, int clen
);
55 extern struct proc_dir_entry
*proc_irda
;
56 static int ircomm_seq_open(struct inode
*, struct file
*);
58 static const struct file_operations ircomm_proc_fops
= {
60 .open
= ircomm_seq_open
,
63 .release
= seq_release
,
65 #endif /* CONFIG_PROC_FS */
67 hashbin_t
*ircomm
= NULL
;
69 static int __init
ircomm_init(void)
71 ircomm
= hashbin_new(HB_LOCK
);
73 IRDA_ERROR("%s(), can't allocate hashbin!\n", __FUNCTION__
);
78 { struct proc_dir_entry
*ent
;
79 ent
= proc_create("ircomm", 0, proc_irda
, &ircomm_proc_fops
);
81 printk(KERN_ERR
"ircomm_init: can't create /proc entry!\n");
85 #endif /* CONFIG_PROC_FS */
87 IRDA_MESSAGE("IrCOMM protocol (Dag Brattli)\n");
92 static void __exit
ircomm_cleanup(void)
94 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
96 hashbin_delete(ircomm
, (FREE_FUNC
) __ircomm_close
);
99 remove_proc_entry("ircomm", proc_irda
);
100 #endif /* CONFIG_PROC_FS */
104 * Function ircomm_open (client_notify)
106 * Start a new IrCOMM instance
109 struct ircomm_cb
*ircomm_open(notify_t
*notify
, __u8 service_type
, int line
)
111 struct ircomm_cb
*self
= NULL
;
114 IRDA_DEBUG(2, "%s(), service_type=0x%02x\n", __FUNCTION__
,
117 IRDA_ASSERT(ircomm
!= NULL
, return NULL
;);
119 self
= kzalloc(sizeof(struct ircomm_cb
), GFP_ATOMIC
);
123 self
->notify
= *notify
;
124 self
->magic
= IRCOMM_MAGIC
;
126 /* Check if we should use IrLMP or IrTTP */
127 if (service_type
& IRCOMM_3_WIRE_RAW
) {
128 self
->flow_status
= FLOW_START
;
129 ret
= ircomm_open_lsap(self
);
131 ret
= ircomm_open_tsap(self
);
138 self
->service_type
= service_type
;
141 hashbin_insert(ircomm
, (irda_queue_t
*) self
, line
, NULL
);
143 ircomm_next_state(self
, IRCOMM_IDLE
);
148 EXPORT_SYMBOL(ircomm_open
);
151 * Function ircomm_close_instance (self)
153 * Remove IrCOMM instance
156 static int __ircomm_close(struct ircomm_cb
*self
)
158 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
160 /* Disconnect link if any */
161 ircomm_do_event(self
, IRCOMM_DISCONNECT_REQUEST
, NULL
, NULL
);
165 irttp_close_tsap(self
->tsap
);
171 irlmp_close_lsap(self
->lsap
);
182 * Function ircomm_close (self)
184 * Closes and removes the specified IrCOMM instance
187 int ircomm_close(struct ircomm_cb
*self
)
189 struct ircomm_cb
*entry
;
191 IRDA_ASSERT(self
!= NULL
, return -EIO
;);
192 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -EIO
;);
194 IRDA_DEBUG(0, "%s()\n", __FUNCTION__
);
196 entry
= hashbin_remove(ircomm
, self
->line
, NULL
);
198 IRDA_ASSERT(entry
== self
, return -1;);
200 return __ircomm_close(self
);
203 EXPORT_SYMBOL(ircomm_close
);
206 * Function ircomm_connect_request (self, service_type)
208 * Impl. of this function is differ from one of the reference. This
209 * function does discovery as well as sending connect request
212 int ircomm_connect_request(struct ircomm_cb
*self
, __u8 dlsap_sel
,
213 __u32 saddr
, __u32 daddr
, struct sk_buff
*skb
,
216 struct ircomm_info info
;
219 IRDA_DEBUG(2 , "%s()\n", __FUNCTION__
);
221 IRDA_ASSERT(self
!= NULL
, return -1;);
222 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -1;);
224 self
->service_type
= service_type
;
226 info
.dlsap_sel
= dlsap_sel
;
230 ret
= ircomm_do_event(self
, IRCOMM_CONNECT_REQUEST
, skb
, &info
);
235 EXPORT_SYMBOL(ircomm_connect_request
);
238 * Function ircomm_connect_indication (self, qos, skb)
240 * Notify user layer about the incoming connection
243 void ircomm_connect_indication(struct ircomm_cb
*self
, struct sk_buff
*skb
,
244 struct ircomm_info
*info
)
248 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
250 /* Check if the packet contains data on the control channel */
255 * If there are any data hiding in the control channel, we must
256 * deliver it first. The side effect is that the control channel
257 * will be removed from the skb
259 if (self
->notify
.connect_indication
)
260 self
->notify
.connect_indication(self
->notify
.instance
, self
,
261 info
->qos
, info
->max_data_size
,
262 info
->max_header_size
, skb
);
264 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__
);
269 * Function ircomm_connect_response (self, userdata, max_sdu_size)
271 * User accepts connection
274 int ircomm_connect_response(struct ircomm_cb
*self
, struct sk_buff
*userdata
)
278 IRDA_ASSERT(self
!= NULL
, return -1;);
279 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -1;);
281 IRDA_DEBUG(4, "%s()\n", __FUNCTION__
);
283 ret
= ircomm_do_event(self
, IRCOMM_CONNECT_RESPONSE
, userdata
, NULL
);
288 EXPORT_SYMBOL(ircomm_connect_response
);
291 * Function connect_confirm (self, skb)
293 * Notify user layer that the link is now connected
296 void ircomm_connect_confirm(struct ircomm_cb
*self
, struct sk_buff
*skb
,
297 struct ircomm_info
*info
)
299 IRDA_DEBUG(4, "%s()\n", __FUNCTION__
);
301 if (self
->notify
.connect_confirm
)
302 self
->notify
.connect_confirm(self
->notify
.instance
,
305 info
->max_header_size
, skb
);
307 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__
);
312 * Function ircomm_data_request (self, userdata)
314 * Send IrCOMM data to peer device
317 int ircomm_data_request(struct ircomm_cb
*self
, struct sk_buff
*skb
)
321 IRDA_DEBUG(4, "%s()\n", __FUNCTION__
);
323 IRDA_ASSERT(self
!= NULL
, return -EFAULT
;);
324 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -EFAULT
;);
325 IRDA_ASSERT(skb
!= NULL
, return -EFAULT
;);
327 ret
= ircomm_do_event(self
, IRCOMM_DATA_REQUEST
, skb
, NULL
);
332 EXPORT_SYMBOL(ircomm_data_request
);
335 * Function ircomm_data_indication (self, skb)
337 * Data arrived, so deliver it to user
340 void ircomm_data_indication(struct ircomm_cb
*self
, struct sk_buff
*skb
)
342 IRDA_DEBUG(4, "%s()\n", __FUNCTION__
);
344 IRDA_ASSERT(skb
->len
> 0, return;);
346 if (self
->notify
.data_indication
)
347 self
->notify
.data_indication(self
->notify
.instance
, self
, skb
);
349 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__
);
354 * Function ircomm_process_data (self, skb)
356 * Data arrived which may contain control channel data
359 void ircomm_process_data(struct ircomm_cb
*self
, struct sk_buff
*skb
)
363 IRDA_ASSERT(skb
->len
> 0, return;);
368 * Input validation check: a stir4200/mcp2150 combinations sometimes
369 * results in frames with clen > remaining packet size. These are
370 * illegal; if we throw away just this frame then it seems to carry on
373 if (unlikely(skb
->len
< (clen
+ 1))) {
374 IRDA_DEBUG(2, "%s() throwing away illegal frame\n",
380 * If there are any data hiding in the control channel, we must
381 * deliver it first. The side effect is that the control channel
382 * will be removed from the skb
385 ircomm_control_indication(self
, skb
, clen
);
387 /* Remove control channel from data channel */
388 skb_pull(skb
, clen
+1);
391 ircomm_data_indication(self
, skb
);
393 IRDA_DEBUG(4, "%s(), data was control info only!\n",
399 * Function ircomm_control_request (self, params)
401 * Send control data to peer device
404 int ircomm_control_request(struct ircomm_cb
*self
, struct sk_buff
*skb
)
408 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
410 IRDA_ASSERT(self
!= NULL
, return -EFAULT
;);
411 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -EFAULT
;);
412 IRDA_ASSERT(skb
!= NULL
, return -EFAULT
;);
414 ret
= ircomm_do_event(self
, IRCOMM_CONTROL_REQUEST
, skb
, NULL
);
419 EXPORT_SYMBOL(ircomm_control_request
);
422 * Function ircomm_control_indication (self, skb)
424 * Data has arrived on the control channel
427 static void ircomm_control_indication(struct ircomm_cb
*self
,
428 struct sk_buff
*skb
, int clen
)
430 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
432 /* Use udata for delivering data on the control channel */
433 if (self
->notify
.udata_indication
) {
434 struct sk_buff
*ctrl_skb
;
436 /* We don't own the skb, so clone it */
437 ctrl_skb
= skb_clone(skb
, GFP_ATOMIC
);
441 /* Remove data channel from control channel */
442 skb_trim(ctrl_skb
, clen
+1);
444 self
->notify
.udata_indication(self
->notify
.instance
, self
,
447 /* Drop reference count -
448 * see ircomm_tty_control_indication(). */
449 dev_kfree_skb(ctrl_skb
);
451 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__
);
456 * Function ircomm_disconnect_request (self, userdata, priority)
458 * User layer wants to disconnect the IrCOMM connection
461 int ircomm_disconnect_request(struct ircomm_cb
*self
, struct sk_buff
*userdata
)
463 struct ircomm_info info
;
466 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
468 IRDA_ASSERT(self
!= NULL
, return -1;);
469 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -1;);
471 ret
= ircomm_do_event(self
, IRCOMM_DISCONNECT_REQUEST
, userdata
,
476 EXPORT_SYMBOL(ircomm_disconnect_request
);
479 * Function disconnect_indication (self, skb)
481 * Tell user that the link has been disconnected
484 void ircomm_disconnect_indication(struct ircomm_cb
*self
, struct sk_buff
*skb
,
485 struct ircomm_info
*info
)
487 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
489 IRDA_ASSERT(info
!= NULL
, return;);
491 if (self
->notify
.disconnect_indication
) {
492 self
->notify
.disconnect_indication(self
->notify
.instance
, self
,
495 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__
);
500 * Function ircomm_flow_request (self, flow)
505 void ircomm_flow_request(struct ircomm_cb
*self
, LOCAL_FLOW flow
)
507 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
509 IRDA_ASSERT(self
!= NULL
, return;);
510 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return;);
512 if (self
->service_type
== IRCOMM_3_WIRE_RAW
)
515 irttp_flow_request(self
->tsap
, flow
);
518 EXPORT_SYMBOL(ircomm_flow_request
);
520 #ifdef CONFIG_PROC_FS
521 static void *ircomm_seq_start(struct seq_file
*seq
, loff_t
*pos
)
523 struct ircomm_cb
*self
;
526 spin_lock_irq(&ircomm
->hb_spinlock
);
528 for (self
= (struct ircomm_cb
*) hashbin_get_first(ircomm
);
530 self
= (struct ircomm_cb
*) hashbin_get_next(ircomm
)) {
538 static void *ircomm_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
542 return (void *) hashbin_get_next(ircomm
);
545 static void ircomm_seq_stop(struct seq_file
*seq
, void *v
)
547 spin_unlock_irq(&ircomm
->hb_spinlock
);
550 static int ircomm_seq_show(struct seq_file
*seq
, void *v
)
552 const struct ircomm_cb
*self
= v
;
554 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -EINVAL
; );
556 if(self
->line
< 0x10)
557 seq_printf(seq
, "ircomm%d", self
->line
);
559 seq_printf(seq
, "irlpt%d", self
->line
- 0x10);
562 " state: %s, slsap_sel: %#02x, dlsap_sel: %#02x, mode:",
563 ircomm_state
[ self
->state
],
564 self
->slsap_sel
, self
->dlsap_sel
);
566 if(self
->service_type
& IRCOMM_3_WIRE_RAW
)
567 seq_printf(seq
, " 3-wire-raw");
568 if(self
->service_type
& IRCOMM_3_WIRE
)
569 seq_printf(seq
, " 3-wire");
570 if(self
->service_type
& IRCOMM_9_WIRE
)
571 seq_printf(seq
, " 9-wire");
572 if(self
->service_type
& IRCOMM_CENTRONICS
)
573 seq_printf(seq
, " Centronics");
579 static const struct seq_operations ircomm_seq_ops
= {
580 .start
= ircomm_seq_start
,
581 .next
= ircomm_seq_next
,
582 .stop
= ircomm_seq_stop
,
583 .show
= ircomm_seq_show
,
586 static int ircomm_seq_open(struct inode
*inode
, struct file
*file
)
588 return seq_open(file
, &ircomm_seq_ops
);
590 #endif /* CONFIG_PROC_FS */
592 MODULE_AUTHOR("Dag Brattli <dag@brattli.net>");
593 MODULE_DESCRIPTION("IrCOMM protocol");
594 MODULE_LICENSE("GPL");
596 module_init(ircomm_init
);
597 module_exit(ircomm_cleanup
);