1 /*********************************************************************
3 * Filename: ircomm_tty_attach.c
5 * Description: Code for attaching the serial driver to IrCOMM
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sat Jun 5 17:42:00 1999
9 * Modified at: Tue Jan 4 14:20:49 2000
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
12 * Copyright (c) 1999-2000 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/sched.h>
33 #include <linux/init.h>
35 #include <net/irda/irda.h>
36 #include <net/irda/irlmp.h>
37 #include <net/irda/iriap.h>
38 #include <net/irda/irttp.h>
39 #include <net/irda/irias_object.h>
40 #include <net/irda/parameters.h>
42 #include <net/irda/ircomm_core.h>
43 #include <net/irda/ircomm_param.h>
44 #include <net/irda/ircomm_event.h>
46 #include <net/irda/ircomm_tty.h>
47 #include <net/irda/ircomm_tty_attach.h>
49 static void ircomm_tty_ias_register(struct ircomm_tty_cb *self);
50 static void ircomm_tty_discovery_indication(discinfo_t *discovery,
53 static void ircomm_tty_getvalue_confirm(int result, __u16 obj_id,
54 struct ias_value *value, void *priv);
55 static void ircomm_tty_start_watchdog_timer(struct ircomm_tty_cb *self,
57 static void ircomm_tty_watchdog_timer_expired(void *data);
59 static int ircomm_tty_state_idle(struct ircomm_tty_cb *self,
60 IRCOMM_TTY_EVENT event,
62 struct ircomm_tty_info *info);
63 static int ircomm_tty_state_search(struct ircomm_tty_cb *self,
64 IRCOMM_TTY_EVENT event,
66 struct ircomm_tty_info *info);
67 static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self,
68 IRCOMM_TTY_EVENT event,
70 struct ircomm_tty_info *info);
71 static int ircomm_tty_state_query_lsap_sel(struct ircomm_tty_cb *self,
72 IRCOMM_TTY_EVENT event,
74 struct ircomm_tty_info *info);
75 static int ircomm_tty_state_setup(struct ircomm_tty_cb *self,
76 IRCOMM_TTY_EVENT event,
78 struct ircomm_tty_info *info);
79 static int ircomm_tty_state_ready(struct ircomm_tty_cb *self,
80 IRCOMM_TTY_EVENT event,
82 struct ircomm_tty_info *info);
84 char *ircomm_tty_state[] = {
87 "IRCOMM_TTY_QUERY_PARAMETERS",
88 "IRCOMM_TTY_QUERY_LSAP_SEL",
94 #ifdef CONFIG_IRDA_DEBUG
95 static char *ircomm_tty_event[] = {
96 "IRCOMM_TTY_ATTACH_CABLE",
97 "IRCOMM_TTY_DETACH_CABLE",
98 "IRCOMM_TTY_DATA_REQUEST",
99 "IRCOMM_TTY_DATA_INDICATION",
100 "IRCOMM_TTY_DISCOVERY_REQUEST",
101 "IRCOMM_TTY_DISCOVERY_INDICATION",
102 "IRCOMM_TTY_CONNECT_CONFIRM",
103 "IRCOMM_TTY_CONNECT_INDICATION",
104 "IRCOMM_TTY_DISCONNECT_REQUEST",
105 "IRCOMM_TTY_DISCONNECT_INDICATION",
106 "IRCOMM_TTY_WD_TIMER_EXPIRED",
107 "IRCOMM_TTY_GOT_PARAMETERS",
108 "IRCOMM_TTY_GOT_LSAPSEL",
111 #endif /* CONFIG_IRDA_DEBUG */
113 static int (*state[])(struct ircomm_tty_cb *self, IRCOMM_TTY_EVENT event,
114 struct sk_buff *skb, struct ircomm_tty_info *info) =
116 ircomm_tty_state_idle,
117 ircomm_tty_state_search,
118 ircomm_tty_state_query_parameters,
119 ircomm_tty_state_query_lsap_sel,
120 ircomm_tty_state_setup,
121 ircomm_tty_state_ready,
125 * Function ircomm_tty_attach_cable (driver)
127 * Try to attach cable (IrCOMM link). This function will only return
128 * when the link has been connected, or if an error condition occurs.
129 * If success, the return value is the resulting service type.
131 int ircomm_tty_attach_cable(struct ircomm_tty_cb *self)
133 IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
135 ASSERT(self != NULL, return -1;);
136 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
138 /* Check if somebody has already connected to us */
139 if (ircomm_is_connected(self->ircomm)) {
140 IRDA_DEBUG(0, "%s(), already connected!\n", __FUNCTION__ );
144 /* Make sure nobody tries to write before the link is up */
145 self->tty->hw_stopped = 1;
147 ircomm_tty_ias_register(self);
149 ircomm_tty_do_event(self, IRCOMM_TTY_ATTACH_CABLE, NULL, NULL);
155 * Function ircomm_detach_cable (driver)
157 * Detach cable, or cable has been detached by peer
160 void ircomm_tty_detach_cable(struct ircomm_tty_cb *self)
162 IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
164 ASSERT(self != NULL, return;);
165 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
167 del_timer(&self->watchdog_timer);
169 /* Remove discovery handler */
171 irlmp_unregister_client(self->ckey);
174 /* Remove IrCOMM hint bits */
176 irlmp_unregister_service(self->skey);
181 iriap_close(self->iriap);
185 /* Remove LM-IAS object */
187 irias_delete_object(self->obj);
191 ircomm_tty_do_event(self, IRCOMM_TTY_DETACH_CABLE, NULL, NULL);
193 /* Reset some values */
194 self->daddr = self->saddr = 0;
195 self->dlsap_sel = self->slsap_sel = 0;
197 memset(&self->settings, 0, sizeof(struct ircomm_params));
201 * Function ircomm_tty_ias_register (self)
203 * Register with LM-IAS depending on which service type we are
206 static void ircomm_tty_ias_register(struct ircomm_tty_cb *self)
211 IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
213 ASSERT(self != NULL, return;);
214 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
216 /* Compute hint bits based on service */
217 hints = irlmp_service_to_hint(S_COMM);
218 if (self->service_type & IRCOMM_3_WIRE_RAW)
219 hints |= irlmp_service_to_hint(S_PRINTER);
221 /* Advertise IrCOMM hint bit in discovery */
223 self->skey = irlmp_register_service(hints);
224 /* Set up a discovery handler */
226 self->ckey = irlmp_register_client(hints,
227 ircomm_tty_discovery_indication,
228 NULL, (void *) self);
230 /* If already done, no need to do it again */
234 if (self->service_type & IRCOMM_3_WIRE_RAW) {
235 /* Register IrLPT with LM-IAS */
236 self->obj = irias_new_object("IrLPT", IAS_IRLPT_ID);
237 irias_add_integer_attrib(self->obj, "IrDA:IrLMP:LsapSel",
238 self->slsap_sel, IAS_KERNEL_ATTR);
240 /* Register IrCOMM with LM-IAS */
241 self->obj = irias_new_object("IrDA:IrCOMM", IAS_IRCOMM_ID);
242 irias_add_integer_attrib(self->obj, "IrDA:TinyTP:LsapSel",
243 self->slsap_sel, IAS_KERNEL_ATTR);
245 /* Code the parameters into the buffer */
246 irda_param_pack(oct_seq, "bbbbbb",
247 IRCOMM_SERVICE_TYPE, 1, self->service_type,
248 IRCOMM_PORT_TYPE, 1, IRCOMM_SERIAL);
250 /* Register parameters with LM-IAS */
251 irias_add_octseq_attrib(self->obj, "Parameters", oct_seq, 6,
254 irias_insert_object(self->obj);
258 * Function ircomm_tty_ias_unregister (self)
260 * Remove our IAS object and client hook while connected.
263 static void ircomm_tty_ias_unregister(struct ircomm_tty_cb *self)
265 /* Remove LM-IAS object now so it is not reused.
266 * IrCOMM deals very poorly with multiple incoming connections.
267 * It should looks a lot more like IrNET, and "dup" a server TSAP
268 * to the application TSAP (based on various rules).
269 * This is a cheap workaround allowing multiple clients to
270 * connect to us. It will not always work.
271 * Each IrCOMM socket has an IAS entry. Incoming connection will
272 * pick the first one found. So, when we are fully connected,
273 * we remove our IAS entries so that the next IAS entry is used.
274 * We do that for *both* client and server, because a server
275 * can also create client instances.
278 irias_delete_object(self->obj);
283 /* Remove discovery handler.
284 * While we are connected, we no longer need to receive
285 * discovery events. This would be the case if there is
286 * multiple IrLAP interfaces. Jean II */
288 irlmp_unregister_client(self->ckey);
295 * Function ircomm_send_initial_parameters (self)
297 * Send initial parameters to the remote IrCOMM device. These parameters
298 * must be sent before any data.
300 int ircomm_tty_send_initial_parameters(struct ircomm_tty_cb *self)
302 ASSERT(self != NULL, return -1;);
303 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
305 if (self->service_type & IRCOMM_3_WIRE_RAW)
309 * Set default values, but only if the application for some reason
310 * haven't set them already
312 IRDA_DEBUG(2, "%s(), data-rate = %d\n", __FUNCTION__ ,
313 self->settings.data_rate);
314 if (!self->settings.data_rate)
315 self->settings.data_rate = 9600;
316 IRDA_DEBUG(2, "%s(), data-format = %d\n", __FUNCTION__ ,
317 self->settings.data_format);
318 if (!self->settings.data_format)
319 self->settings.data_format = IRCOMM_WSIZE_8; /* 8N1 */
321 IRDA_DEBUG(2, "%s(), flow-control = %d\n", __FUNCTION__ ,
322 self->settings.flow_control);
323 /*self->settings.flow_control = IRCOMM_RTS_CTS_IN|IRCOMM_RTS_CTS_OUT;*/
325 /* Do not set delta values for the initial parameters */
326 self->settings.dte = IRCOMM_DTR | IRCOMM_RTS;
328 /* Only send service type parameter when we are the client */
330 ircomm_param_request(self, IRCOMM_SERVICE_TYPE, FALSE);
331 ircomm_param_request(self, IRCOMM_DATA_RATE, FALSE);
332 ircomm_param_request(self, IRCOMM_DATA_FORMAT, FALSE);
334 /* For a 3 wire service, we just flush the last parameter and return */
335 if (self->settings.service_type == IRCOMM_3_WIRE) {
336 ircomm_param_request(self, IRCOMM_FLOW_CONTROL, TRUE);
340 /* Only 9-wire service types continue here */
341 ircomm_param_request(self, IRCOMM_FLOW_CONTROL, FALSE);
343 ircomm_param_request(self, IRCOMM_XON_XOFF, FALSE);
344 ircomm_param_request(self, IRCOMM_ENQ_ACK, FALSE);
346 /* Notify peer that we are ready to receive data */
347 ircomm_param_request(self, IRCOMM_DTE, TRUE);
353 * Function ircomm_tty_discovery_indication (discovery)
355 * Remote device is discovered, try query the remote IAS to see which
356 * device it is, and which services it has.
359 static void ircomm_tty_discovery_indication(discinfo_t *discovery,
363 struct ircomm_tty_cb *self;
364 struct ircomm_tty_info info;
366 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
369 * We need to drop all passive discoveries.
370 * The LSAP management of IrComm is deficient and doesn't deal
371 * with the case of two instance connecting to each other
372 * simultaneously (it will deadlock in LMP).
373 * The proper fix would be to use the same technique as in IrNET,
374 * to have one server socket and separate instances for the
375 * connecting/connected socket.
376 * The workaround is to drop passive discovery, which drastically
377 * reduce the probability of this happening.
379 if(mode == DISCOVERY_PASSIVE)
382 info.daddr = discovery->daddr;
383 info.saddr = discovery->saddr;
385 /* FIXME. We have a locking problem on the hashbin here.
386 * We probably need to use hashbin_find_next(), but we first
387 * need to ensure that "line" is unique. - Jean II */
388 self = (struct ircomm_tty_cb *) hashbin_get_first(ircomm_tty);
389 while (self != NULL) {
390 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
392 ircomm_tty_do_event(self, IRCOMM_TTY_DISCOVERY_INDICATION,
395 self = (struct ircomm_tty_cb *) hashbin_get_next(ircomm_tty);
400 * Function ircomm_tty_disconnect_indication (instance, sap, reason, skb)
405 void ircomm_tty_disconnect_indication(void *instance, void *sap,
409 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
411 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
413 ASSERT(self != NULL, return;);
414 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
419 /* This will stop control data transfers */
420 self->flow = FLOW_STOP;
422 /* Stop data transfers */
423 self->tty->hw_stopped = 1;
425 ircomm_tty_do_event(self, IRCOMM_TTY_DISCONNECT_INDICATION, NULL,
430 * Function ircomm_tty_getvalue_confirm (result, obj_id, value, priv)
432 * Got result from the IAS query we make
435 static void ircomm_tty_getvalue_confirm(int result, __u16 obj_id,
436 struct ias_value *value,
439 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) priv;
441 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
443 ASSERT(self != NULL, return;);
444 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
446 /* We probably don't need to make any more queries */
447 iriap_close(self->iriap);
450 /* Check if request succeeded */
451 if (result != IAS_SUCCESS) {
452 IRDA_DEBUG(4, "%s(), got NULL value!\n", __FUNCTION__ );
456 switch (value->type) {
458 IRDA_DEBUG(2, "%s(), got octet sequence\n", __FUNCTION__ );
460 irda_param_extract_all(self, value->t.oct_seq, value->len,
463 ircomm_tty_do_event(self, IRCOMM_TTY_GOT_PARAMETERS, NULL,
467 /* Got LSAP selector */
468 IRDA_DEBUG(2, "%s(), got lsapsel = %d\n", __FUNCTION__ ,
471 if (value->t.integer == -1) {
472 IRDA_DEBUG(0, "%s(), invalid value!\n", __FUNCTION__ );
474 self->dlsap_sel = value->t.integer;
476 ircomm_tty_do_event(self, IRCOMM_TTY_GOT_LSAPSEL, NULL, NULL);
479 IRDA_DEBUG(0, "%s(), got IAS_MISSING\n", __FUNCTION__ );
482 IRDA_DEBUG(0, "%s(), got unknown type!\n", __FUNCTION__ );
485 irias_delete_value(value);
489 * Function ircomm_tty_connect_confirm (instance, sap, qos, max_sdu_size, skb)
491 * Connection confirmed
494 void ircomm_tty_connect_confirm(void *instance, void *sap,
495 struct qos_info *qos,
497 __u8 max_header_size,
500 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
502 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
504 ASSERT(self != NULL, return;);
505 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
508 self->max_data_size = max_data_size;
509 self->max_header_size = max_header_size;
510 self->flow = FLOW_START;
512 ircomm_tty_do_event(self, IRCOMM_TTY_CONNECT_CONFIRM, NULL, NULL);
514 /* No need to kfree_skb - see ircomm_ttp_connect_confirm() */
518 * Function ircomm_tty_connect_indication (instance, sap, qos, max_sdu_size,
521 * we are discovered and being requested to connect by remote device !
524 void ircomm_tty_connect_indication(void *instance, void *sap,
525 struct qos_info *qos,
527 __u8 max_header_size,
530 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
533 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
535 ASSERT(self != NULL, return;);
536 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
538 self->client = FALSE;
539 self->max_data_size = max_data_size;
540 self->max_header_size = max_header_size;
541 self->flow = FLOW_START;
545 irda_param_extract_all(self, skb->data+1,
546 IRDA_MIN(skb->len, clen),
549 ircomm_tty_do_event(self, IRCOMM_TTY_CONNECT_INDICATION, NULL, NULL);
551 /* No need to kfree_skb - see ircomm_ttp_connect_indication() */
555 * Function ircomm_tty_link_established (self)
557 * Called when the IrCOMM link is established
560 void ircomm_tty_link_established(struct ircomm_tty_cb *self)
562 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
564 ASSERT(self != NULL, return;);
565 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
570 del_timer(&self->watchdog_timer);
573 * IrCOMM link is now up, and if we are not using hardware
574 * flow-control, then declare the hardware as running. Otherwise we
575 * will have to wait for the peer device (DCE) to raise the CTS
578 if ((self->flags & ASYNC_CTS_FLOW) && ((self->settings.dce & IRCOMM_CTS) == 0)) {
579 IRDA_DEBUG(0, "%s(), waiting for CTS ...\n", __FUNCTION__ );
582 IRDA_DEBUG(1, "%s(), starting hardware!\n", __FUNCTION__ );
584 self->tty->hw_stopped = 0;
586 /* Wake up processes blocked on open */
587 wake_up_interruptible(&self->open_wait);
590 schedule_work(&self->tqueue);
594 * Function ircomm_tty_start_watchdog_timer (self, timeout)
596 * Start the watchdog timer. This timer is used to make sure that any
597 * connection attempt is successful, and if not, we will retry after
600 static void ircomm_tty_start_watchdog_timer(struct ircomm_tty_cb *self,
603 ASSERT(self != NULL, return;);
604 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
606 irda_start_timer(&self->watchdog_timer, timeout, (void *) self,
607 ircomm_tty_watchdog_timer_expired);
611 * Function ircomm_tty_watchdog_timer_expired (data)
613 * Called when the connect procedure have taken to much time.
616 static void ircomm_tty_watchdog_timer_expired(void *data)
618 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) data;
620 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
622 ASSERT(self != NULL, return;);
623 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
625 ircomm_tty_do_event(self, IRCOMM_TTY_WD_TIMER_EXPIRED, NULL, NULL);
630 * Function ircomm_tty_do_event (self, event, skb)
635 int ircomm_tty_do_event(struct ircomm_tty_cb *self, IRCOMM_TTY_EVENT event,
636 struct sk_buff *skb, struct ircomm_tty_info *info)
638 ASSERT(self != NULL, return -1;);
639 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
641 IRDA_DEBUG(2, "%s: state=%s, event=%s\n", __FUNCTION__ ,
642 ircomm_tty_state[self->state], ircomm_tty_event[event]);
644 return (*state[self->state])(self, event, skb, info);
648 * Function ircomm_tty_next_state (self, state)
653 static inline void ircomm_tty_next_state(struct ircomm_tty_cb *self, IRCOMM_TTY_STATE state)
656 ASSERT(self != NULL, return;);
657 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
659 IRDA_DEBUG(2, "%s: next state=%s, service type=%d\n", __FUNCTION__ ,
660 ircomm_tty_state[self->state], self->service_type);
666 * Function ircomm_tty_state_idle (self, event, skb, info)
668 * Just hanging around
671 static int ircomm_tty_state_idle(struct ircomm_tty_cb *self,
672 IRCOMM_TTY_EVENT event,
674 struct ircomm_tty_info *info)
678 IRDA_DEBUG(2, "%s: state=%s, event=%s\n", __FUNCTION__ ,
679 ircomm_tty_state[self->state], ircomm_tty_event[event]);
681 case IRCOMM_TTY_ATTACH_CABLE:
682 /* Try to discover any remote devices */
683 ircomm_tty_start_watchdog_timer(self, 3*HZ);
684 ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH);
686 irlmp_discovery_request(DISCOVERY_DEFAULT_SLOTS);
688 case IRCOMM_TTY_DISCOVERY_INDICATION:
689 self->daddr = info->daddr;
690 self->saddr = info->saddr;
693 WARNING("%s(), busy with a previous query\n", __FUNCTION__);
697 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
698 ircomm_tty_getvalue_confirm);
700 iriap_getvaluebyclass_request(self->iriap,
701 self->saddr, self->daddr,
702 "IrDA:IrCOMM", "Parameters");
704 ircomm_tty_start_watchdog_timer(self, 3*HZ);
705 ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_PARAMETERS);
707 case IRCOMM_TTY_CONNECT_INDICATION:
708 del_timer(&self->watchdog_timer);
710 /* Accept connection */
711 ircomm_connect_response(self->ircomm, NULL);
712 ircomm_tty_next_state(self, IRCOMM_TTY_READY);
714 case IRCOMM_TTY_WD_TIMER_EXPIRED:
717 case IRCOMM_TTY_DETACH_CABLE:
718 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE);
721 IRDA_DEBUG(2, "%s(), unknown event: %s\n", __FUNCTION__ ,
722 ircomm_tty_event[event]);
729 * Function ircomm_tty_state_search (self, event, skb, info)
731 * Trying to discover an IrCOMM device
734 static int ircomm_tty_state_search(struct ircomm_tty_cb *self,
735 IRCOMM_TTY_EVENT event,
737 struct ircomm_tty_info *info)
741 IRDA_DEBUG(2, "%s: state=%s, event=%s\n", __FUNCTION__ ,
742 ircomm_tty_state[self->state], ircomm_tty_event[event]);
745 case IRCOMM_TTY_DISCOVERY_INDICATION:
746 self->daddr = info->daddr;
747 self->saddr = info->saddr;
750 WARNING("%s(), busy with a previous query\n", __FUNCTION__);
754 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
755 ircomm_tty_getvalue_confirm);
757 if (self->service_type == IRCOMM_3_WIRE_RAW) {
758 iriap_getvaluebyclass_request(self->iriap, self->saddr,
759 self->daddr, "IrLPT",
760 "IrDA:IrLMP:LsapSel");
761 ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_LSAP_SEL);
763 iriap_getvaluebyclass_request(self->iriap, self->saddr,
768 ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_PARAMETERS);
770 ircomm_tty_start_watchdog_timer(self, 3*HZ);
772 case IRCOMM_TTY_CONNECT_INDICATION:
773 del_timer(&self->watchdog_timer);
774 ircomm_tty_ias_unregister(self);
776 /* Accept connection */
777 ircomm_connect_response(self->ircomm, NULL);
778 ircomm_tty_next_state(self, IRCOMM_TTY_READY);
780 case IRCOMM_TTY_WD_TIMER_EXPIRED:
784 /* Try to discover any remote devices */
785 ircomm_tty_start_watchdog_timer(self, 3*HZ);
786 irlmp_discovery_request(DISCOVERY_DEFAULT_SLOTS);
789 case IRCOMM_TTY_DETACH_CABLE:
790 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE);
793 IRDA_DEBUG(2, "%s(), unknown event: %s\n", __FUNCTION__ ,
794 ircomm_tty_event[event]);
801 * Function ircomm_tty_state_query (self, event, skb, info)
803 * Querying the remote LM-IAS for IrCOMM parameters
806 static int ircomm_tty_state_query_parameters(struct ircomm_tty_cb *self,
807 IRCOMM_TTY_EVENT event,
809 struct ircomm_tty_info *info)
813 IRDA_DEBUG(2, "%s: state=%s, event=%s\n", __FUNCTION__ ,
814 ircomm_tty_state[self->state], ircomm_tty_event[event]);
817 case IRCOMM_TTY_GOT_PARAMETERS:
819 WARNING("%s(), busy with a previous query\n", __FUNCTION__);
823 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
824 ircomm_tty_getvalue_confirm);
826 iriap_getvaluebyclass_request(self->iriap, self->saddr,
827 self->daddr, "IrDA:IrCOMM",
828 "IrDA:TinyTP:LsapSel");
830 ircomm_tty_start_watchdog_timer(self, 3*HZ);
831 ircomm_tty_next_state(self, IRCOMM_TTY_QUERY_LSAP_SEL);
833 case IRCOMM_TTY_WD_TIMER_EXPIRED:
834 /* Go back to search mode */
835 ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH);
836 ircomm_tty_start_watchdog_timer(self, 3*HZ);
838 case IRCOMM_TTY_CONNECT_INDICATION:
839 del_timer(&self->watchdog_timer);
840 ircomm_tty_ias_unregister(self);
842 /* Accept connection */
843 ircomm_connect_response(self->ircomm, NULL);
844 ircomm_tty_next_state(self, IRCOMM_TTY_READY);
846 case IRCOMM_TTY_DETACH_CABLE:
847 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE);
850 IRDA_DEBUG(2, "%s(), unknown event: %s\n", __FUNCTION__ ,
851 ircomm_tty_event[event]);
858 * Function ircomm_tty_state_query_lsap_sel (self, event, skb, info)
860 * Query remote LM-IAS for the LSAP selector which we can connect to
863 static int ircomm_tty_state_query_lsap_sel(struct ircomm_tty_cb *self,
864 IRCOMM_TTY_EVENT event,
866 struct ircomm_tty_info *info)
870 IRDA_DEBUG(2, "%s: state=%s, event=%s\n", __FUNCTION__ ,
871 ircomm_tty_state[self->state], ircomm_tty_event[event]);
874 case IRCOMM_TTY_GOT_LSAPSEL:
875 /* Connect to remote device */
876 ret = ircomm_connect_request(self->ircomm, self->dlsap_sel,
877 self->saddr, self->daddr,
878 NULL, self->service_type);
879 ircomm_tty_start_watchdog_timer(self, 3*HZ);
880 ircomm_tty_next_state(self, IRCOMM_TTY_SETUP);
882 case IRCOMM_TTY_WD_TIMER_EXPIRED:
883 /* Go back to search mode */
884 ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH);
885 ircomm_tty_start_watchdog_timer(self, 3*HZ);
887 case IRCOMM_TTY_CONNECT_INDICATION:
888 del_timer(&self->watchdog_timer);
889 ircomm_tty_ias_unregister(self);
891 /* Accept connection */
892 ircomm_connect_response(self->ircomm, NULL);
893 ircomm_tty_next_state(self, IRCOMM_TTY_READY);
895 case IRCOMM_TTY_DETACH_CABLE:
896 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE);
899 IRDA_DEBUG(2, "%s(), unknown event: %s\n", __FUNCTION__ ,
900 ircomm_tty_event[event]);
907 * Function ircomm_tty_state_setup (self, event, skb, info)
912 static int ircomm_tty_state_setup(struct ircomm_tty_cb *self,
913 IRCOMM_TTY_EVENT event,
915 struct ircomm_tty_info *info)
919 IRDA_DEBUG(2, "%s: state=%s, event=%s\n", __FUNCTION__ ,
920 ircomm_tty_state[self->state], ircomm_tty_event[event]);
923 case IRCOMM_TTY_CONNECT_CONFIRM:
924 del_timer(&self->watchdog_timer);
925 ircomm_tty_ias_unregister(self);
928 * Send initial parameters. This will also send out queued
929 * parameters waiting for the connection to come up
931 ircomm_tty_send_initial_parameters(self);
932 ircomm_tty_link_established(self);
933 ircomm_tty_next_state(self, IRCOMM_TTY_READY);
935 case IRCOMM_TTY_CONNECT_INDICATION:
936 del_timer(&self->watchdog_timer);
937 ircomm_tty_ias_unregister(self);
939 /* Accept connection */
940 ircomm_connect_response(self->ircomm, NULL);
941 ircomm_tty_next_state(self, IRCOMM_TTY_READY);
943 case IRCOMM_TTY_WD_TIMER_EXPIRED:
944 /* Go back to search mode */
945 ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH);
946 ircomm_tty_start_watchdog_timer(self, 3*HZ);
948 case IRCOMM_TTY_DETACH_CABLE:
949 /* ircomm_disconnect_request(self->ircomm, NULL); */
950 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE);
953 IRDA_DEBUG(2, "%s(), unknown event: %s\n", __FUNCTION__ ,
954 ircomm_tty_event[event]);
961 * Function ircomm_tty_state_ready (self, event, skb, info)
963 * IrCOMM is now connected
966 static int ircomm_tty_state_ready(struct ircomm_tty_cb *self,
967 IRCOMM_TTY_EVENT event,
969 struct ircomm_tty_info *info)
974 case IRCOMM_TTY_DATA_REQUEST:
975 ret = ircomm_data_request(self->ircomm, skb);
977 case IRCOMM_TTY_DETACH_CABLE:
978 ircomm_disconnect_request(self->ircomm, NULL);
979 ircomm_tty_next_state(self, IRCOMM_TTY_IDLE);
981 case IRCOMM_TTY_DISCONNECT_INDICATION:
982 ircomm_tty_ias_register(self);
983 ircomm_tty_next_state(self, IRCOMM_TTY_SEARCH);
984 ircomm_tty_start_watchdog_timer(self, 3*HZ);
986 if (self->flags & ASYNC_CHECK_CD) {
988 self->settings.dce = IRCOMM_DELTA_CD;
989 ircomm_tty_check_modem_status(self);
991 IRDA_DEBUG(0, "%s(), hanging up!\n", __FUNCTION__ );
993 tty_hangup(self->tty);
997 IRDA_DEBUG(2, "%s(), unknown event: %s\n", __FUNCTION__ ,
998 ircomm_tty_event[event]);