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/sched.h>
34 #include <linux/proc_fs.h>
35 #include <linux/seq_file.h>
36 #include <linux/init.h>
38 #include <net/irda/irda.h>
39 #include <net/irda/irmod.h>
40 #include <net/irda/irlmp.h>
41 #include <net/irda/iriap.h>
42 #include <net/irda/irttp.h>
43 #include <net/irda/irias_object.h>
45 #include <net/irda/ircomm_event.h>
46 #include <net/irda/ircomm_lmp.h>
47 #include <net/irda/ircomm_ttp.h>
48 #include <net/irda/ircomm_param.h>
49 #include <net/irda/ircomm_core.h>
51 static int __ircomm_close(struct ircomm_cb
*self
);
52 static void ircomm_control_indication(struct ircomm_cb
*self
,
53 struct sk_buff
*skb
, int clen
);
56 extern struct proc_dir_entry
*proc_irda
;
57 static int ircomm_seq_open(struct inode
*, struct file
*);
59 static const struct file_operations ircomm_proc_fops
= {
61 .open
= ircomm_seq_open
,
64 .release
= seq_release
,
66 #endif /* CONFIG_PROC_FS */
68 hashbin_t
*ircomm
= NULL
;
70 static int __init
ircomm_init(void)
72 ircomm
= hashbin_new(HB_LOCK
);
74 IRDA_ERROR("%s(), can't allocate hashbin!\n", __FUNCTION__
);
79 { struct proc_dir_entry
*ent
;
80 ent
= create_proc_entry("ircomm", 0, proc_irda
);
82 ent
->proc_fops
= &ircomm_proc_fops
;
84 #endif /* CONFIG_PROC_FS */
86 IRDA_MESSAGE("IrCOMM protocol (Dag Brattli)\n");
91 static void __exit
ircomm_cleanup(void)
93 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
95 hashbin_delete(ircomm
, (FREE_FUNC
) __ircomm_close
);
98 remove_proc_entry("ircomm", proc_irda
);
99 #endif /* CONFIG_PROC_FS */
103 * Function ircomm_open (client_notify)
105 * Start a new IrCOMM instance
108 struct ircomm_cb
*ircomm_open(notify_t
*notify
, __u8 service_type
, int line
)
110 struct ircomm_cb
*self
= NULL
;
113 IRDA_DEBUG(2, "%s(), service_type=0x%02x\n", __FUNCTION__
,
116 IRDA_ASSERT(ircomm
!= NULL
, return NULL
;);
118 self
= kzalloc(sizeof(struct ircomm_cb
), GFP_ATOMIC
);
122 self
->notify
= *notify
;
123 self
->magic
= IRCOMM_MAGIC
;
125 /* Check if we should use IrLMP or IrTTP */
126 if (service_type
& IRCOMM_3_WIRE_RAW
) {
127 self
->flow_status
= FLOW_START
;
128 ret
= ircomm_open_lsap(self
);
130 ret
= ircomm_open_tsap(self
);
137 self
->service_type
= service_type
;
140 hashbin_insert(ircomm
, (irda_queue_t
*) self
, line
, NULL
);
142 ircomm_next_state(self
, IRCOMM_IDLE
);
147 EXPORT_SYMBOL(ircomm_open
);
150 * Function ircomm_close_instance (self)
152 * Remove IrCOMM instance
155 static int __ircomm_close(struct ircomm_cb
*self
)
157 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
159 /* Disconnect link if any */
160 ircomm_do_event(self
, IRCOMM_DISCONNECT_REQUEST
, NULL
, NULL
);
164 irttp_close_tsap(self
->tsap
);
170 irlmp_close_lsap(self
->lsap
);
181 * Function ircomm_close (self)
183 * Closes and removes the specified IrCOMM instance
186 int ircomm_close(struct ircomm_cb
*self
)
188 struct ircomm_cb
*entry
;
190 IRDA_ASSERT(self
!= NULL
, return -EIO
;);
191 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -EIO
;);
193 IRDA_DEBUG(0, "%s()\n", __FUNCTION__
);
195 entry
= hashbin_remove(ircomm
, self
->line
, NULL
);
197 IRDA_ASSERT(entry
== self
, return -1;);
199 return __ircomm_close(self
);
202 EXPORT_SYMBOL(ircomm_close
);
205 * Function ircomm_connect_request (self, service_type)
207 * Impl. of this function is differ from one of the reference. This
208 * function does discovery as well as sending connect request
211 int ircomm_connect_request(struct ircomm_cb
*self
, __u8 dlsap_sel
,
212 __u32 saddr
, __u32 daddr
, struct sk_buff
*skb
,
215 struct ircomm_info info
;
218 IRDA_DEBUG(2 , "%s()\n", __FUNCTION__
);
220 IRDA_ASSERT(self
!= NULL
, return -1;);
221 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -1;);
223 self
->service_type
= service_type
;
225 info
.dlsap_sel
= dlsap_sel
;
229 ret
= ircomm_do_event(self
, IRCOMM_CONNECT_REQUEST
, skb
, &info
);
234 EXPORT_SYMBOL(ircomm_connect_request
);
237 * Function ircomm_connect_indication (self, qos, skb)
239 * Notify user layer about the incoming connection
242 void ircomm_connect_indication(struct ircomm_cb
*self
, struct sk_buff
*skb
,
243 struct ircomm_info
*info
)
247 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
249 /* Check if the packet contains data on the control channel */
254 * If there are any data hiding in the control channel, we must
255 * deliver it first. The side effect is that the control channel
256 * will be removed from the skb
258 if (self
->notify
.connect_indication
)
259 self
->notify
.connect_indication(self
->notify
.instance
, self
,
260 info
->qos
, info
->max_data_size
,
261 info
->max_header_size
, skb
);
263 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__
);
268 * Function ircomm_connect_response (self, userdata, max_sdu_size)
270 * User accepts connection
273 int ircomm_connect_response(struct ircomm_cb
*self
, struct sk_buff
*userdata
)
277 IRDA_ASSERT(self
!= NULL
, return -1;);
278 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -1;);
280 IRDA_DEBUG(4, "%s()\n", __FUNCTION__
);
282 ret
= ircomm_do_event(self
, IRCOMM_CONNECT_RESPONSE
, userdata
, NULL
);
287 EXPORT_SYMBOL(ircomm_connect_response
);
290 * Function connect_confirm (self, skb)
292 * Notify user layer that the link is now connected
295 void ircomm_connect_confirm(struct ircomm_cb
*self
, struct sk_buff
*skb
,
296 struct ircomm_info
*info
)
298 IRDA_DEBUG(4, "%s()\n", __FUNCTION__
);
300 if (self
->notify
.connect_confirm
)
301 self
->notify
.connect_confirm(self
->notify
.instance
,
304 info
->max_header_size
, skb
);
306 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__
);
311 * Function ircomm_data_request (self, userdata)
313 * Send IrCOMM data to peer device
316 int ircomm_data_request(struct ircomm_cb
*self
, struct sk_buff
*skb
)
320 IRDA_DEBUG(4, "%s()\n", __FUNCTION__
);
322 IRDA_ASSERT(self
!= NULL
, return -EFAULT
;);
323 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -EFAULT
;);
324 IRDA_ASSERT(skb
!= NULL
, return -EFAULT
;);
326 ret
= ircomm_do_event(self
, IRCOMM_DATA_REQUEST
, skb
, NULL
);
331 EXPORT_SYMBOL(ircomm_data_request
);
334 * Function ircomm_data_indication (self, skb)
336 * Data arrived, so deliver it to user
339 void ircomm_data_indication(struct ircomm_cb
*self
, struct sk_buff
*skb
)
341 IRDA_DEBUG(4, "%s()\n", __FUNCTION__
);
343 IRDA_ASSERT(skb
->len
> 0, return;);
345 if (self
->notify
.data_indication
)
346 self
->notify
.data_indication(self
->notify
.instance
, self
, skb
);
348 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__
);
353 * Function ircomm_process_data (self, skb)
355 * Data arrived which may contain control channel data
358 void ircomm_process_data(struct ircomm_cb
*self
, struct sk_buff
*skb
)
362 IRDA_ASSERT(skb
->len
> 0, return;);
367 * If there are any data hiding in the control channel, we must
368 * deliver it first. The side effect is that the control channel
369 * will be removed from the skb
372 ircomm_control_indication(self
, skb
, clen
);
374 /* Remove control channel from data channel */
375 skb_pull(skb
, clen
+1);
378 ircomm_data_indication(self
, skb
);
380 IRDA_DEBUG(4, "%s(), data was control info only!\n",
386 * Function ircomm_control_request (self, params)
388 * Send control data to peer device
391 int ircomm_control_request(struct ircomm_cb
*self
, struct sk_buff
*skb
)
395 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
397 IRDA_ASSERT(self
!= NULL
, return -EFAULT
;);
398 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -EFAULT
;);
399 IRDA_ASSERT(skb
!= NULL
, return -EFAULT
;);
401 ret
= ircomm_do_event(self
, IRCOMM_CONTROL_REQUEST
, skb
, NULL
);
406 EXPORT_SYMBOL(ircomm_control_request
);
409 * Function ircomm_control_indication (self, skb)
411 * Data has arrived on the control channel
414 static void ircomm_control_indication(struct ircomm_cb
*self
,
415 struct sk_buff
*skb
, int clen
)
417 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
419 /* Use udata for delivering data on the control channel */
420 if (self
->notify
.udata_indication
) {
421 struct sk_buff
*ctrl_skb
;
423 /* We don't own the skb, so clone it */
424 ctrl_skb
= skb_clone(skb
, GFP_ATOMIC
);
428 /* Remove data channel from control channel */
429 skb_trim(ctrl_skb
, clen
+1);
431 self
->notify
.udata_indication(self
->notify
.instance
, self
,
434 /* Drop reference count -
435 * see ircomm_tty_control_indication(). */
436 dev_kfree_skb(ctrl_skb
);
438 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__
);
443 * Function ircomm_disconnect_request (self, userdata, priority)
445 * User layer wants to disconnect the IrCOMM connection
448 int ircomm_disconnect_request(struct ircomm_cb
*self
, struct sk_buff
*userdata
)
450 struct ircomm_info info
;
453 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
455 IRDA_ASSERT(self
!= NULL
, return -1;);
456 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -1;);
458 ret
= ircomm_do_event(self
, IRCOMM_DISCONNECT_REQUEST
, userdata
,
463 EXPORT_SYMBOL(ircomm_disconnect_request
);
466 * Function disconnect_indication (self, skb)
468 * Tell user that the link has been disconnected
471 void ircomm_disconnect_indication(struct ircomm_cb
*self
, struct sk_buff
*skb
,
472 struct ircomm_info
*info
)
474 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
476 IRDA_ASSERT(info
!= NULL
, return;);
478 if (self
->notify
.disconnect_indication
) {
479 self
->notify
.disconnect_indication(self
->notify
.instance
, self
,
482 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__
);
487 * Function ircomm_flow_request (self, flow)
492 void ircomm_flow_request(struct ircomm_cb
*self
, LOCAL_FLOW flow
)
494 IRDA_DEBUG(2, "%s()\n", __FUNCTION__
);
496 IRDA_ASSERT(self
!= NULL
, return;);
497 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return;);
499 if (self
->service_type
== IRCOMM_3_WIRE_RAW
)
502 irttp_flow_request(self
->tsap
, flow
);
505 EXPORT_SYMBOL(ircomm_flow_request
);
507 #ifdef CONFIG_PROC_FS
508 static void *ircomm_seq_start(struct seq_file
*seq
, loff_t
*pos
)
510 struct ircomm_cb
*self
;
513 spin_lock_irq(&ircomm
->hb_spinlock
);
515 for (self
= (struct ircomm_cb
*) hashbin_get_first(ircomm
);
517 self
= (struct ircomm_cb
*) hashbin_get_next(ircomm
)) {
525 static void *ircomm_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
529 return (void *) hashbin_get_next(ircomm
);
532 static void ircomm_seq_stop(struct seq_file
*seq
, void *v
)
534 spin_unlock_irq(&ircomm
->hb_spinlock
);
537 static int ircomm_seq_show(struct seq_file
*seq
, void *v
)
539 const struct ircomm_cb
*self
= v
;
541 IRDA_ASSERT(self
->magic
== IRCOMM_MAGIC
, return -EINVAL
; );
543 if(self
->line
< 0x10)
544 seq_printf(seq
, "ircomm%d", self
->line
);
546 seq_printf(seq
, "irlpt%d", self
->line
- 0x10);
549 " state: %s, slsap_sel: %#02x, dlsap_sel: %#02x, mode:",
550 ircomm_state
[ self
->state
],
551 self
->slsap_sel
, self
->dlsap_sel
);
553 if(self
->service_type
& IRCOMM_3_WIRE_RAW
)
554 seq_printf(seq
, " 3-wire-raw");
555 if(self
->service_type
& IRCOMM_3_WIRE
)
556 seq_printf(seq
, " 3-wire");
557 if(self
->service_type
& IRCOMM_9_WIRE
)
558 seq_printf(seq
, " 9-wire");
559 if(self
->service_type
& IRCOMM_CENTRONICS
)
560 seq_printf(seq
, " Centronics");
566 static struct seq_operations ircomm_seq_ops
= {
567 .start
= ircomm_seq_start
,
568 .next
= ircomm_seq_next
,
569 .stop
= ircomm_seq_stop
,
570 .show
= ircomm_seq_show
,
573 static int ircomm_seq_open(struct inode
*inode
, struct file
*file
)
575 return seq_open(file
, &ircomm_seq_ops
);
577 #endif /* CONFIG_PROC_FS */
579 MODULE_AUTHOR("Dag Brattli <dag@brattli.net>");
580 MODULE_DESCRIPTION("IrCOMM protocol");
581 MODULE_LICENSE("GPL");
583 module_init(ircomm_init
);
584 module_exit(ircomm_cleanup
);