2 * IrNET protocol module : Synchronous PPP over an IrDA socket.
4 * Jean II - HPL `00 - <jt@hpl.hp.com>
6 * This file implement the IRDA interface of IrNET.
7 * Basically, we sit on top of IrTTP. We set up IrTTP, IrIAS properly,
8 * and exchange frames with IrTTP.
11 #include "irnet_irda.h" /* Private header */
12 #include <linux/seq_file.h>
15 * PPP disconnect work: we need to make sure we're in
16 * process context when calling ppp_unregister_channel().
18 static void irnet_ppp_disconnect(struct work_struct
*work
)
21 container_of(work
, irnet_socket
, disconnect_work
);
26 * If we were connected, cleanup & close the PPP
27 * channel, which will kill pppd (hangup) and the rest.
29 if (self
->ppp_open
&& !self
->ttp_open
&& !self
->ttp_connect
) {
30 ppp_unregister_channel(&self
->chan
);
35 /************************* CONTROL CHANNEL *************************/
37 * When ppp is not active, /dev/irnet act as a control channel.
38 * Writing allow to set up the IrDA destination of the IrNET channel,
39 * and any application may be read events happening on IrNET...
42 /*------------------------------------------------------------------*/
44 * Post an event to the control channel...
45 * Put the event in the log, and then wait all process blocked on read
46 * so they can read the log...
49 irnet_post_event(irnet_socket
* ap
,
56 int index
; /* In the log */
58 DENTER(CTRL_TRACE
, "(ap=0x%p, event=%d, daddr=%08x, name=``%s'')\n",
59 ap
, event
, daddr
, name
);
61 /* Protect this section via spinlock.
62 * Note : as we are the only event producer, we only need to exclude
63 * ourself when touching the log, which is nice and easy.
65 spin_lock_bh(&irnet_events
.spinlock
);
67 /* Copy the event in the log */
68 index
= irnet_events
.index
;
69 irnet_events
.log
[index
].event
= event
;
70 irnet_events
.log
[index
].daddr
= daddr
;
71 irnet_events
.log
[index
].saddr
= saddr
;
72 /* Try to copy IrDA nickname */
74 strcpy(irnet_events
.log
[index
].name
, name
);
76 irnet_events
.log
[index
].name
[0] = '\0';
78 irnet_events
.log
[index
].hints
.word
= hints
;
79 /* Try to get ppp unit number */
80 if((ap
!= (irnet_socket
*) NULL
) && (ap
->ppp_open
))
81 irnet_events
.log
[index
].unit
= ppp_unit_number(&ap
->chan
);
83 irnet_events
.log
[index
].unit
= -1;
85 /* Increment the index
86 * Note that we increment the index only after the event is written,
87 * to make sure that the readers don't get garbage... */
88 irnet_events
.index
= (index
+ 1) % IRNET_MAX_EVENTS
;
90 DEBUG(CTRL_INFO
, "New event index is %d\n", irnet_events
.index
);
93 spin_unlock_bh(&irnet_events
.spinlock
);
95 /* Now : wake up everybody waiting for events... */
96 wake_up_interruptible_all(&irnet_events
.rwait
);
98 DEXIT(CTRL_TRACE
, "\n");
101 /************************* IRDA SUBROUTINES *************************/
103 * These are a bunch of subroutines called from other functions
104 * down there, mostly common code or to improve readability...
106 * Note : we duplicate quite heavily some routines of af_irda.c,
107 * because our input structure (self) is quite different
108 * (struct irnet instead of struct irda_sock), which make sharing
109 * the same code impossible (at least, without templates).
112 /*------------------------------------------------------------------*/
114 * Function irda_open_tsap (self)
116 * Open local Transport Service Access Point (TSAP)
118 * Create a IrTTP instance for us and set all the IrTTP callbacks.
121 irnet_open_tsap(irnet_socket
* self
)
123 notify_t notify
; /* Callback structure */
125 DENTER(IRDA_SR_TRACE
, "(self=0x%p)\n", self
);
127 DABORT(self
->tsap
!= NULL
, -EBUSY
, IRDA_SR_ERROR
, "Already busy !\n");
129 /* Initialize IrTTP callbacks to be used by the IrDA stack */
130 irda_notify_init(¬ify
);
131 notify
.connect_confirm
= irnet_connect_confirm
;
132 notify
.connect_indication
= irnet_connect_indication
;
133 notify
.disconnect_indication
= irnet_disconnect_indication
;
134 notify
.data_indication
= irnet_data_indication
;
135 /*notify.udata_indication = NULL;*/
136 notify
.flow_indication
= irnet_flow_indication
;
137 notify
.status_indication
= irnet_status_indication
;
138 notify
.instance
= self
;
139 strlcpy(notify
.name
, IRNET_NOTIFY_NAME
, sizeof(notify
.name
));
141 /* Open an IrTTP instance */
142 self
->tsap
= irttp_open_tsap(LSAP_ANY
, DEFAULT_INITIAL_CREDIT
,
144 DABORT(self
->tsap
== NULL
, -ENOMEM
,
145 IRDA_SR_ERROR
, "Unable to allocate TSAP !\n");
147 /* Remember which TSAP selector we actually got */
148 self
->stsap_sel
= self
->tsap
->stsap_sel
;
150 DEXIT(IRDA_SR_TRACE
, " - tsap=0x%p, sel=0x%X\n",
151 self
->tsap
, self
->stsap_sel
);
155 /*------------------------------------------------------------------*/
157 * Function irnet_ias_to_tsap (self, result, value)
159 * Examine an IAS object and extract TSAP
161 * We do an IAP query to find the TSAP associated with the IrNET service.
162 * When IrIAP pass us the result of the query, this function look at
163 * the return values to check for failures and extract the TSAP if
165 * Also deallocate value
166 * The failure is in self->errno
170 irnet_ias_to_tsap(irnet_socket
* self
,
172 struct ias_value
* value
)
174 __u8 dtsap_sel
= 0; /* TSAP we are looking for */
176 DENTER(IRDA_SR_TRACE
, "(self=0x%p)\n", self
);
178 /* By default, no error */
181 /* Check if request succeeded */
184 /* Standard errors : service not available */
185 case IAS_CLASS_UNKNOWN
:
186 case IAS_ATTRIB_UNKNOWN
:
187 DEBUG(IRDA_SR_INFO
, "IAS object doesn't exist ! (%d)\n", result
);
188 self
->errno
= -EADDRNOTAVAIL
;
191 /* Other errors, most likely IrDA stack failure */
193 DEBUG(IRDA_SR_INFO
, "IAS query failed ! (%d)\n", result
);
194 self
->errno
= -EHOSTUNREACH
;
197 /* Success : we got what we wanted */
202 /* Check what was returned to us */
205 /* What type of argument have we got ? */
209 DEBUG(IRDA_SR_INFO
, "result=%d\n", value
->t
.integer
);
210 if(value
->t
.integer
!= -1)
211 /* Get the remote TSAP selector */
212 dtsap_sel
= value
->t
.integer
;
214 self
->errno
= -EADDRNOTAVAIL
;
217 self
->errno
= -EADDRNOTAVAIL
;
218 DERROR(IRDA_SR_ERROR
, "bad type ! (0x%X)\n", value
->type
);
223 irias_delete_value(value
);
225 else /* value == NULL */
227 /* Nothing returned to us - usually result != SUCCESS */
230 DERROR(IRDA_SR_ERROR
,
231 "IrDA bug : result == SUCCESS && value == NULL\n");
232 self
->errno
= -EHOSTUNREACH
;
235 DEXIT(IRDA_SR_TRACE
, "\n");
237 /* Return the TSAP */
241 /*------------------------------------------------------------------*/
243 * Function irnet_find_lsap_sel (self)
245 * Try to lookup LSAP selector in remote LM-IAS
247 * Basically, we start a IAP query, and then go to sleep. When the query
248 * return, irnet_getvalue_confirm will wake us up, and we can examine the
249 * result of the query...
250 * Note that in some case, the query fail even before we go to sleep,
251 * creating some races...
254 irnet_find_lsap_sel(irnet_socket
* self
)
256 DENTER(IRDA_SR_TRACE
, "(self=0x%p)\n", self
);
258 /* This should not happen */
259 DABORT(self
->iriap
, -EBUSY
, IRDA_SR_ERROR
, "busy with a previous query.\n");
261 /* Create an IAP instance, will be closed in irnet_getvalue_confirm() */
262 self
->iriap
= iriap_open(LSAP_ANY
, IAS_CLIENT
, self
,
263 irnet_getvalue_confirm
);
265 /* Treat unexpected signals as disconnect */
266 self
->errno
= -EHOSTUNREACH
;
268 /* Query remote LM-IAS */
269 iriap_getvaluebyclass_request(self
->iriap
, self
->rsaddr
, self
->daddr
,
270 IRNET_SERVICE_NAME
, IRNET_IAS_VALUE
);
272 /* The above request is non-blocking.
273 * After a while, IrDA will call us back in irnet_getvalue_confirm()
274 * We will then call irnet_ias_to_tsap() and finish the
275 * connection procedure */
277 DEXIT(IRDA_SR_TRACE
, "\n");
281 /*------------------------------------------------------------------*/
283 * Function irnet_connect_tsap (self)
285 * Initialise the TTP socket and initiate TTP connection
289 irnet_connect_tsap(irnet_socket
* self
)
293 DENTER(IRDA_SR_TRACE
, "(self=0x%p)\n", self
);
295 /* Open a local TSAP (an IrTTP instance) */
296 err
= irnet_open_tsap(self
);
299 clear_bit(0, &self
->ttp_connect
);
300 DERROR(IRDA_SR_ERROR
, "connect aborted!\n");
304 /* Connect to remote device */
305 err
= irttp_connect_request(self
->tsap
, self
->dtsap_sel
,
306 self
->rsaddr
, self
->daddr
, NULL
,
307 self
->max_sdu_size_rx
, NULL
);
310 clear_bit(0, &self
->ttp_connect
);
311 DERROR(IRDA_SR_ERROR
, "connect aborted!\n");
315 /* The above call is non-blocking.
316 * After a while, the IrDA stack will either call us back in
317 * irnet_connect_confirm() or irnet_disconnect_indication()
318 * See you there ;-) */
320 DEXIT(IRDA_SR_TRACE
, "\n");
324 /*------------------------------------------------------------------*/
326 * Function irnet_discover_next_daddr (self)
328 * Query the IrNET TSAP of the next device in the log.
330 * Used in the TSAP discovery procedure.
333 irnet_discover_next_daddr(irnet_socket
* self
)
335 /* Close the last instance of IrIAP, and open a new one.
336 * We can't reuse the IrIAP instance in the IrIAP callback */
339 iriap_close(self
->iriap
);
342 /* Create a new IAP instance */
343 self
->iriap
= iriap_open(LSAP_ANY
, IAS_CLIENT
, self
,
344 irnet_discovervalue_confirm
);
345 if(self
->iriap
== NULL
)
348 /* Next discovery - before the call to avoid races */
351 /* Check if we have one more address to try */
352 if(self
->disco_index
< self
->disco_number
)
354 /* Query remote LM-IAS */
355 iriap_getvaluebyclass_request(self
->iriap
,
356 self
->discoveries
[self
->disco_index
].saddr
,
357 self
->discoveries
[self
->disco_index
].daddr
,
358 IRNET_SERVICE_NAME
, IRNET_IAS_VALUE
);
359 /* The above request is non-blocking.
360 * After a while, IrDA will call us back in irnet_discovervalue_confirm()
361 * We will then call irnet_ias_to_tsap() and come back here again... */
368 /*------------------------------------------------------------------*/
370 * Function irnet_discover_daddr_and_lsap_sel (self)
372 * This try to find a device with the requested service.
374 * Initiate a TSAP discovery procedure.
375 * It basically look into the discovery log. For each address in the list,
376 * it queries the LM-IAS of the device to find if this device offer
377 * the requested service.
378 * If there is more than one node supporting the service, we complain
379 * to the user (it should move devices around).
380 * If we find one node which have the requested TSAP, we connect to it.
382 * This function just start the whole procedure. It request the discovery
383 * log and submit the first IAS query.
384 * The bulk of the job is handled in irnet_discovervalue_confirm()
386 * Note : this procedure fails if there is more than one device in range
387 * on the same dongle, because IrLMP doesn't disconnect the LAP when the
388 * last LSAP is closed. Moreover, we would need to wait the LAP
392 irnet_discover_daddr_and_lsap_sel(irnet_socket
* self
)
396 DENTER(IRDA_SR_TRACE
, "(self=0x%p)\n", self
);
398 /* Ask lmp for the current discovery log */
399 self
->discoveries
= irlmp_get_discoveries(&self
->disco_number
, self
->mask
,
400 DISCOVERY_DEFAULT_SLOTS
);
402 /* Check if the we got some results */
403 if(self
->discoveries
== NULL
)
405 self
->disco_number
= -1;
406 clear_bit(0, &self
->ttp_connect
);
407 DRETURN(-ENETUNREACH
, IRDA_SR_INFO
, "No Cachelog...\n");
409 DEBUG(IRDA_SR_INFO
, "Got the log (0x%p), size is %d\n",
410 self
->discoveries
, self
->disco_number
);
412 /* Start with the first discovery */
413 self
->disco_index
= -1;
414 self
->daddr
= DEV_ADDR_ANY
;
416 /* This will fail if the log is empty - this is non-blocking */
417 ret
= irnet_discover_next_daddr(self
);
422 iriap_close(self
->iriap
);
425 /* Cleanup our copy of the discovery log */
426 kfree(self
->discoveries
);
427 self
->discoveries
= NULL
;
429 clear_bit(0, &self
->ttp_connect
);
430 DRETURN(-ENETUNREACH
, IRDA_SR_INFO
, "Cachelog empty...\n");
433 /* Follow me in irnet_discovervalue_confirm() */
435 DEXIT(IRDA_SR_TRACE
, "\n");
439 /*------------------------------------------------------------------*/
441 * Function irnet_dname_to_daddr (self)
443 * Convert an IrDA nickname to a valid IrDA address
445 * It basically look into the discovery log until there is a match.
448 irnet_dname_to_daddr(irnet_socket
* self
)
450 struct irda_device_info
*discoveries
; /* Copy of the discovery log */
451 int number
; /* Number of nodes in the log */
454 DENTER(IRDA_SR_TRACE
, "(self=0x%p)\n", self
);
456 /* Ask lmp for the current discovery log */
457 discoveries
= irlmp_get_discoveries(&number
, 0xffff,
458 DISCOVERY_DEFAULT_SLOTS
);
459 /* Check if the we got some results */
460 if(discoveries
== NULL
)
461 DRETURN(-ENETUNREACH
, IRDA_SR_INFO
, "Cachelog empty...\n");
464 * Now, check all discovered devices (if any), and connect
465 * client only about the services that the client is
468 for(i
= 0; i
< number
; i
++)
470 /* Does the name match ? */
471 if(!strncmp(discoveries
[i
].info
, self
->rname
, NICKNAME_MAX_LEN
))
473 /* Yes !!! Get it.. */
474 self
->daddr
= discoveries
[i
].daddr
;
475 DEBUG(IRDA_SR_INFO
, "discovered device ``%s'' at address 0x%08x.\n",
476 self
->rname
, self
->daddr
);
478 DEXIT(IRDA_SR_TRACE
, "\n");
483 DEBUG(IRDA_SR_INFO
, "cannot discover device ``%s'' !!!\n", self
->rname
);
485 return(-EADDRNOTAVAIL
);
489 /************************* SOCKET ROUTINES *************************/
491 * This are the main operations on IrNET sockets, basically to create
492 * and destroy IrNET sockets. These are called from the PPP part...
495 /*------------------------------------------------------------------*/
497 * Create a IrNET instance : just initialise some parameters...
500 irda_irnet_create(irnet_socket
* self
)
502 DENTER(IRDA_SOCK_TRACE
, "(self=0x%p)\n", self
);
504 self
->magic
= IRNET_MAGIC
; /* Paranoia */
506 self
->ttp_open
= 0; /* Prevent higher layer from accessing IrTTP */
507 self
->ttp_connect
= 0; /* Not connecting yet */
508 self
->rname
[0] = '\0'; /* May be set via control channel */
509 self
->rdaddr
= DEV_ADDR_ANY
; /* May be set via control channel */
510 self
->rsaddr
= DEV_ADDR_ANY
; /* May be set via control channel */
511 self
->daddr
= DEV_ADDR_ANY
; /* Until we get connected */
512 self
->saddr
= DEV_ADDR_ANY
; /* Until we get connected */
513 self
->max_sdu_size_rx
= TTP_SAR_UNBOUND
;
515 /* Register as a client with IrLMP */
516 self
->ckey
= irlmp_register_client(0, NULL
, NULL
, NULL
);
517 #ifdef DISCOVERY_NOMASK
518 self
->mask
= 0xffff; /* For W2k compatibility */
519 #else /* DISCOVERY_NOMASK */
520 self
->mask
= irlmp_service_to_hint(S_LAN
);
521 #endif /* DISCOVERY_NOMASK */
522 self
->tx_flow
= FLOW_START
; /* Flow control from IrTTP */
524 INIT_WORK(&self
->disconnect_work
, irnet_ppp_disconnect
);
526 DEXIT(IRDA_SOCK_TRACE
, "\n");
530 /*------------------------------------------------------------------*/
532 * Connect to the other side :
533 * o convert device name to an address
534 * o find the socket number (dlsap)
535 * o Establish the connection
537 * Note : We no longer mimic af_irda. The IAS query for finding the TSAP
538 * is done asynchronously, like the TTP connection. This allow us to
539 * call this function from any context (not only process).
540 * The downside is that following what's happening in there is tricky
541 * because it involve various functions all over the place...
544 irda_irnet_connect(irnet_socket
* self
)
548 DENTER(IRDA_SOCK_TRACE
, "(self=0x%p)\n", self
);
550 /* Check if we are already trying to connect.
551 * Because irda_irnet_connect() can be called directly by pppd plus
552 * packet retries in ppp_generic and connect may take time, plus we may
553 * race with irnet_connect_indication(), we need to be careful there... */
554 if(test_and_set_bit(0, &self
->ttp_connect
))
555 DRETURN(-EBUSY
, IRDA_SOCK_INFO
, "Already connecting...\n");
556 if((self
->iriap
!= NULL
) || (self
->tsap
!= NULL
))
557 DERROR(IRDA_SOCK_ERROR
, "Socket not cleaned up...\n");
559 /* Insert ourselves in the hashbin so that the IrNET server can find us.
560 * Notes : 4th arg is string of 32 char max and must be null terminated
561 * When 4th arg is used (string), 3rd arg isn't (int)
562 * Can't re-insert (MUST remove first) so check for that... */
563 if((irnet_server
.running
) && (self
->q
.q_next
== NULL
))
565 spin_lock_bh(&irnet_server
.spinlock
);
566 hashbin_insert(irnet_server
.list
, (irda_queue_t
*) self
, 0, self
->rname
);
567 spin_unlock_bh(&irnet_server
.spinlock
);
568 DEBUG(IRDA_SOCK_INFO
, "Inserted ``%s'' in hashbin...\n", self
->rname
);
571 /* If we don't have anything (no address, no name) */
572 if((self
->rdaddr
== DEV_ADDR_ANY
) && (self
->rname
[0] == '\0'))
574 /* Try to find a suitable address */
575 if((err
= irnet_discover_daddr_and_lsap_sel(self
)) != 0)
576 DRETURN(err
, IRDA_SOCK_INFO
, "auto-connect failed!\n");
577 /* In most cases, the call above is non-blocking */
581 /* If we have only the name (no address), try to get an address */
582 if(self
->rdaddr
== DEV_ADDR_ANY
)
584 if((err
= irnet_dname_to_daddr(self
)) != 0)
585 DRETURN(err
, IRDA_SOCK_INFO
, "name connect failed!\n");
588 /* Use the requested destination address */
589 self
->daddr
= self
->rdaddr
;
591 /* Query remote LM-IAS to find LSAP selector */
592 irnet_find_lsap_sel(self
);
593 /* The above call is non blocking */
596 /* At this point, we are waiting for the IrDA stack to call us back,
597 * or we have already failed.
598 * We will finish the connection procedure in irnet_connect_tsap().
600 DEXIT(IRDA_SOCK_TRACE
, "\n");
604 /*------------------------------------------------------------------*/
606 * Function irda_irnet_destroy(self)
608 * Destroy irnet instance
610 * Note : this need to be called from a process context.
613 irda_irnet_destroy(irnet_socket
* self
)
615 DENTER(IRDA_SOCK_TRACE
, "(self=0x%p)\n", self
);
619 /* Remove ourselves from hashbin (if we are queued in hashbin)
620 * Note : `irnet_server.running' protect us from calls in hashbin_delete() */
621 if((irnet_server
.running
) && (self
->q
.q_next
!= NULL
))
623 struct irnet_socket
* entry
;
624 DEBUG(IRDA_SOCK_INFO
, "Removing from hash..\n");
625 spin_lock_bh(&irnet_server
.spinlock
);
626 entry
= hashbin_remove_this(irnet_server
.list
, (irda_queue_t
*) self
);
627 self
->q
.q_next
= NULL
;
628 spin_unlock_bh(&irnet_server
.spinlock
);
629 DASSERT(entry
== self
, , IRDA_SOCK_ERROR
, "Can't remove from hash.\n");
632 /* If we were connected, post a message */
633 if(test_bit(0, &self
->ttp_open
))
635 /* Note : as the disconnect comes from ppp_generic, the unit number
636 * doesn't exist anymore when we post the event, so we need to pass
637 * NULL as the first arg... */
638 irnet_post_event(NULL
, IRNET_DISCONNECT_TO
,
639 self
->saddr
, self
->daddr
, self
->rname
, 0);
642 /* Prevent various IrDA callbacks from messing up things
643 * Need to be first */
644 clear_bit(0, &self
->ttp_connect
);
646 /* Prevent higher layer from accessing IrTTP */
647 clear_bit(0, &self
->ttp_open
);
649 /* Unregister with IrLMP */
650 irlmp_unregister_client(self
->ckey
);
652 /* Unregister with LM-IAS */
655 iriap_close(self
->iriap
);
659 /* Cleanup eventual discoveries from connection attempt or control channel */
660 if(self
->discoveries
!= NULL
)
662 /* Cleanup our copy of the discovery log */
663 kfree(self
->discoveries
);
664 self
->discoveries
= NULL
;
667 /* Close our IrTTP connection */
670 DEBUG(IRDA_SOCK_INFO
, "Closing our TTP connection.\n");
671 irttp_disconnect_request(self
->tsap
, NULL
, P_NORMAL
);
672 irttp_close_tsap(self
->tsap
);
677 DEXIT(IRDA_SOCK_TRACE
, "\n");
682 /************************** SERVER SOCKET **************************/
684 * The IrNET service is composed of one server socket and a variable
685 * number of regular IrNET sockets. The server socket is supposed to
686 * handle incoming connections and redirect them to one IrNET sockets.
687 * It's a superset of the regular IrNET socket, but has a very distinct
691 /*------------------------------------------------------------------*/
693 * Function irnet_daddr_to_dname (self)
695 * Convert an IrDA address to a IrDA nickname
697 * It basically look into the discovery log until there is a match.
700 irnet_daddr_to_dname(irnet_socket
* self
)
702 struct irda_device_info
*discoveries
; /* Copy of the discovery log */
703 int number
; /* Number of nodes in the log */
706 DENTER(IRDA_SERV_TRACE
, "(self=0x%p)\n", self
);
708 /* Ask lmp for the current discovery log */
709 discoveries
= irlmp_get_discoveries(&number
, 0xffff,
710 DISCOVERY_DEFAULT_SLOTS
);
711 /* Check if the we got some results */
712 if (discoveries
== NULL
)
713 DRETURN(-ENETUNREACH
, IRDA_SERV_INFO
, "Cachelog empty...\n");
715 /* Now, check all discovered devices (if any) */
716 for(i
= 0; i
< number
; i
++)
718 /* Does the name match ? */
719 if(discoveries
[i
].daddr
== self
->daddr
)
721 /* Yes !!! Get it.. */
722 strlcpy(self
->rname
, discoveries
[i
].info
, sizeof(self
->rname
));
723 self
->rname
[sizeof(self
->rname
) - 1] = '\0';
724 DEBUG(IRDA_SERV_INFO
, "Device 0x%08x is in fact ``%s''.\n",
725 self
->daddr
, self
->rname
);
727 DEXIT(IRDA_SERV_TRACE
, "\n");
732 DEXIT(IRDA_SERV_INFO
, ": cannot discover device 0x%08x !!!\n", self
->daddr
);
734 return(-EADDRNOTAVAIL
);
737 /*------------------------------------------------------------------*/
739 * Function irda_find_socket (self)
741 * Find the correct IrNET socket
743 * Look into the list of IrNET sockets and finds one with the right
746 static inline irnet_socket
*
747 irnet_find_socket(irnet_socket
* self
)
749 irnet_socket
* new = (irnet_socket
*) NULL
;
752 DENTER(IRDA_SERV_TRACE
, "(self=0x%p)\n", self
);
754 /* Get the addresses of the requester */
755 self
->daddr
= irttp_get_daddr(self
->tsap
);
756 self
->saddr
= irttp_get_saddr(self
->tsap
);
758 /* Try to get the IrDA nickname of the requester */
759 err
= irnet_daddr_to_dname(self
);
761 /* Protect access to the instance list */
762 spin_lock_bh(&irnet_server
.spinlock
);
764 /* So now, try to get an socket having specifically
765 * requested that nickname */
768 new = (irnet_socket
*) hashbin_find(irnet_server
.list
,
771 DEBUG(IRDA_SERV_INFO
, "Socket 0x%p matches rname ``%s''.\n",
775 /* If no name matches, try to find an socket by the destination address */
776 /* It can be either the requested destination address (set via the
777 * control channel), or the current destination address if the
778 * socket is in the middle of a connection request */
779 if(new == (irnet_socket
*) NULL
)
781 new = (irnet_socket
*) hashbin_get_first(irnet_server
.list
);
782 while(new !=(irnet_socket
*) NULL
)
784 /* Does it have the same address ? */
785 if((new->rdaddr
== self
->daddr
) || (new->daddr
== self
->daddr
))
787 /* Yes !!! Get it.. */
788 DEBUG(IRDA_SERV_INFO
, "Socket 0x%p matches daddr %#08x.\n",
792 new = (irnet_socket
*) hashbin_get_next(irnet_server
.list
);
796 /* If we don't have any socket, get the first unconnected socket */
797 if(new == (irnet_socket
*) NULL
)
799 new = (irnet_socket
*) hashbin_get_first(irnet_server
.list
);
800 while(new !=(irnet_socket
*) NULL
)
802 /* Is it available ? */
803 if(!(test_bit(0, &new->ttp_open
)) && (new->rdaddr
== DEV_ADDR_ANY
) &&
804 (new->rname
[0] == '\0') && (new->ppp_open
))
806 /* Yes !!! Get it.. */
807 DEBUG(IRDA_SERV_INFO
, "Socket 0x%p is free.\n",
811 new = (irnet_socket
*) hashbin_get_next(irnet_server
.list
);
816 spin_unlock_bh(&irnet_server
.spinlock
);
818 DEXIT(IRDA_SERV_TRACE
, " - new = 0x%p\n", new);
822 /*------------------------------------------------------------------*/
824 * Function irda_connect_socket (self)
826 * Connect an incoming connection to the socket
830 irnet_connect_socket(irnet_socket
* server
,
832 struct qos_info
* qos
,
834 __u8 max_header_size
)
836 DENTER(IRDA_SERV_TRACE
, "(server=0x%p, new=0x%p)\n",
839 /* Now attach up the new socket */
840 new->tsap
= irttp_dup(server
->tsap
, new);
841 DABORT(new->tsap
== NULL
, -1, IRDA_SERV_ERROR
, "dup failed!\n");
843 /* Set up all the relevant parameters on the new socket */
844 new->stsap_sel
= new->tsap
->stsap_sel
;
845 new->dtsap_sel
= new->tsap
->dtsap_sel
;
846 new->saddr
= irttp_get_saddr(new->tsap
);
847 new->daddr
= irttp_get_daddr(new->tsap
);
849 new->max_header_size
= max_header_size
;
850 new->max_sdu_size_tx
= max_sdu_size
;
851 new->max_data_size
= max_sdu_size
;
853 /* If we want to receive "stream sockets" */
854 if(max_sdu_size
== 0)
855 new->max_data_size
= irttp_get_max_seg_size(new->tsap
);
856 #endif /* STREAM_COMPAT */
858 /* Clean up the original one to keep it in listen state */
859 irttp_listen(server
->tsap
);
861 /* Send a connection response on the new socket */
862 irttp_connect_response(new->tsap
, new->max_sdu_size_rx
, NULL
);
864 /* Allow PPP to send its junk over the new socket... */
865 set_bit(0, &new->ttp_open
);
867 /* Not connecting anymore, and clean up last possible remains
868 * of connection attempts on the socket */
869 clear_bit(0, &new->ttp_connect
);
872 iriap_close(new->iriap
);
875 if(new->discoveries
!= NULL
)
877 kfree(new->discoveries
);
878 new->discoveries
= NULL
;
881 #ifdef CONNECT_INDIC_KICK
882 /* As currently we don't block packets in ppp_irnet_send() while passive,
883 * this is not really needed...
884 * Also, not doing it give IrDA a chance to finish the setup properly
885 * before being swamped with packets... */
886 ppp_output_wakeup(&new->chan
);
887 #endif /* CONNECT_INDIC_KICK */
889 /* Notify the control channel */
890 irnet_post_event(new, IRNET_CONNECT_FROM
,
891 new->saddr
, new->daddr
, server
->rname
, 0);
893 DEXIT(IRDA_SERV_TRACE
, "\n");
897 /*------------------------------------------------------------------*/
899 * Function irda_disconnect_server (self)
901 * Cleanup the server socket when the incoming connection abort
905 irnet_disconnect_server(irnet_socket
* self
,
908 DENTER(IRDA_SERV_TRACE
, "(self=0x%p)\n", self
);
910 /* Put the received packet in the black hole */
913 #ifdef FAIL_SEND_DISCONNECT
914 /* Tell the other party we don't want to be connected */
915 /* Hum... Is it the right thing to do ? And do we need to send
916 * a connect response before ? It looks ok without this... */
917 irttp_disconnect_request(self
->tsap
, NULL
, P_NORMAL
);
918 #endif /* FAIL_SEND_DISCONNECT */
920 /* Notify the control channel (see irnet_find_socket()) */
921 irnet_post_event(NULL
, IRNET_REQUEST_FROM
,
922 self
->saddr
, self
->daddr
, self
->rname
, 0);
924 /* Clean up the server to keep it in listen state */
925 irttp_listen(self
->tsap
);
927 DEXIT(IRDA_SERV_TRACE
, "\n");
931 /*------------------------------------------------------------------*/
933 * Function irda_setup_server (self)
935 * Create a IrTTP server and set it up...
937 * Register the IrLAN hint bit, create a IrTTP instance for us,
938 * set all the IrTTP callbacks and create an IrIAS entry...
941 irnet_setup_server(void)
945 DENTER(IRDA_SERV_TRACE
, "()\n");
947 /* Initialise the regular socket part of the server */
948 irda_irnet_create(&irnet_server
.s
);
950 /* Open a local TSAP (an IrTTP instance) for the server */
951 irnet_open_tsap(&irnet_server
.s
);
954 irnet_server
.s
.ppp_open
= 0;
955 irnet_server
.s
.chan
.private = NULL
;
956 irnet_server
.s
.file
= NULL
;
958 /* Get the hint bit corresponding to IrLAN */
959 /* Note : we overload the IrLAN hint bit. As it is only a "hint", and as
960 * we provide roughly the same functionality as IrLAN, this is ok.
961 * In fact, the situation is similar as JetSend overloading the Obex hint
963 hints
= irlmp_service_to_hint(S_LAN
);
965 #ifdef ADVERTISE_HINT
966 /* Register with IrLMP as a service (advertise our hint bit) */
967 irnet_server
.skey
= irlmp_register_service(hints
);
968 #endif /* ADVERTISE_HINT */
970 /* Register with LM-IAS (so that people can connect to us) */
971 irnet_server
.ias_obj
= irias_new_object(IRNET_SERVICE_NAME
, jiffies
);
972 irias_add_integer_attrib(irnet_server
.ias_obj
, IRNET_IAS_VALUE
,
973 irnet_server
.s
.stsap_sel
, IAS_KERNEL_ATTR
);
974 irias_insert_object(irnet_server
.ias_obj
);
976 #ifdef DISCOVERY_EVENTS
977 /* Tell IrLMP we want to be notified of newly discovered nodes */
978 irlmp_update_client(irnet_server
.s
.ckey
, hints
,
979 irnet_discovery_indication
, irnet_expiry_indication
,
980 (void *) &irnet_server
.s
);
983 DEXIT(IRDA_SERV_TRACE
, " - self=0x%p\n", &irnet_server
.s
);
987 /*------------------------------------------------------------------*/
989 * Function irda_destroy_server (self)
991 * Destroy the IrTTP server...
993 * Reverse of the previous function...
996 irnet_destroy_server(void)
998 DENTER(IRDA_SERV_TRACE
, "()\n");
1000 #ifdef ADVERTISE_HINT
1001 /* Unregister with IrLMP */
1002 irlmp_unregister_service(irnet_server
.skey
);
1003 #endif /* ADVERTISE_HINT */
1005 /* Unregister with LM-IAS */
1006 if(irnet_server
.ias_obj
)
1007 irias_delete_object(irnet_server
.ias_obj
);
1009 /* Cleanup the socket part */
1010 irda_irnet_destroy(&irnet_server
.s
);
1012 DEXIT(IRDA_SERV_TRACE
, "\n");
1017 /************************ IRDA-TTP CALLBACKS ************************/
1019 * When we create a IrTTP instance, we pass to it a set of callbacks
1020 * that IrTTP will call in case of various events.
1021 * We take care of those events here.
1024 /*------------------------------------------------------------------*/
1026 * Function irnet_data_indication (instance, sap, skb)
1028 * Received some data from TinyTP. Just queue it on the receive queue
1032 irnet_data_indication(void * instance
,
1034 struct sk_buff
*skb
)
1036 irnet_socket
* ap
= (irnet_socket
*) instance
;
1040 DENTER(IRDA_TCB_TRACE
, "(self/ap=0x%p, skb=0x%p)\n",
1042 DASSERT(skb
!= NULL
, 0, IRDA_CB_ERROR
, "skb is NULL !!!\n");
1044 /* Check is ppp is ready to receive our packet */
1047 DERROR(IRDA_CB_ERROR
, "PPP not ready, dropping packet...\n");
1048 /* When we return error, TTP will need to requeue the skb and
1049 * will stop the sender. IrTTP will stall until we send it a
1050 * flow control request... */
1054 /* strip address/control field if present */
1056 if((p
[0] == PPP_ALLSTATIONS
) && (p
[1] == PPP_UI
))
1058 /* chop off address/control */
1061 p
= skb_pull(skb
, 2);
1064 /* decompress protocol field if compressed */
1067 /* protocol is compressed */
1068 skb_push(skb
, 1)[0] = 0;
1074 /* pass to generic ppp layer */
1075 /* Note : how do I know if ppp can accept or not the packet ? This is
1076 * essential if I want to manage flow control smoothly... */
1077 ppp_input(&ap
->chan
, skb
);
1079 DEXIT(IRDA_TCB_TRACE
, "\n");
1083 DERROR(IRDA_CB_ERROR
, "Packet too small, dropping...\n");
1085 ppp_input_error(&ap
->chan
, code
);
1086 return 0; /* Don't return an error code, only for flow control... */
1089 /*------------------------------------------------------------------*/
1091 * Function irnet_disconnect_indication (instance, sap, reason, skb)
1093 * Connection has been closed. Chech reason to find out why
1095 * Note : there are many cases where we come here :
1096 * o attempted to connect, timeout
1097 * o connected, link is broken, LAP has timeout
1098 * o connected, other side close the link
1099 * o connection request on the server not handled
1102 irnet_disconnect_indication(void * instance
,
1105 struct sk_buff
*skb
)
1107 irnet_socket
* self
= (irnet_socket
*) instance
;
1111 DENTER(IRDA_TCB_TRACE
, "(self=0x%p)\n", self
);
1112 DASSERT(self
!= NULL
, , IRDA_CB_ERROR
, "Self is NULL !!!\n");
1114 /* Don't care about it, but let's not leak it */
1118 /* Prevent higher layer from accessing IrTTP */
1119 test_open
= test_and_clear_bit(0, &self
->ttp_open
);
1120 /* Not connecting anymore...
1121 * (note : TSAP is open, so IAP callbacks are no longer pending...) */
1122 test_connect
= test_and_clear_bit(0, &self
->ttp_connect
);
1124 /* If both self->ttp_open and self->ttp_connect are NULL, it mean that we
1125 * have a race condition with irda_irnet_destroy() or
1126 * irnet_connect_indication(), so don't mess up tsap...
1128 if(!(test_open
|| test_connect
))
1130 DERROR(IRDA_CB_ERROR
, "Race condition detected...\n");
1134 /* If we were active, notify the control channel */
1136 irnet_post_event(self
, IRNET_DISCONNECT_FROM
,
1137 self
->saddr
, self
->daddr
, self
->rname
, 0);
1139 /* If we were trying to connect, notify the control channel */
1140 if((self
->tsap
) && (self
!= &irnet_server
.s
))
1141 irnet_post_event(self
, IRNET_NOANSWER_FROM
,
1142 self
->saddr
, self
->daddr
, self
->rname
, 0);
1144 /* Close our IrTTP connection, cleanup tsap */
1145 if((self
->tsap
) && (self
!= &irnet_server
.s
))
1147 DEBUG(IRDA_CB_INFO
, "Closing our TTP connection.\n");
1148 irttp_close_tsap(self
->tsap
);
1151 /* Cleanup the socket in case we want to reconnect in ppp_output_wakeup() */
1152 self
->stsap_sel
= 0;
1153 self
->daddr
= DEV_ADDR_ANY
;
1154 self
->tx_flow
= FLOW_START
;
1156 /* Deal with the ppp instance if it's still alive */
1161 /* ppp_unregister_channel() wants a user context. */
1162 schedule_work(&self
->disconnect_work
);
1166 /* If we were trying to connect, flush (drain) ppp_generic
1167 * Tx queue (most often we have blocked it), which will
1168 * trigger an other attempt to connect. If we are passive,
1169 * this will empty the Tx queue after last try. */
1170 ppp_output_wakeup(&self
->chan
);
1174 DEXIT(IRDA_TCB_TRACE
, "\n");
1177 /*------------------------------------------------------------------*/
1179 * Function irnet_connect_confirm (instance, sap, qos, max_sdu_size, skb)
1181 * Connections has been confirmed by the remote device
1185 irnet_connect_confirm(void * instance
,
1187 struct qos_info
*qos
,
1189 __u8 max_header_size
,
1190 struct sk_buff
*skb
)
1192 irnet_socket
* self
= (irnet_socket
*) instance
;
1194 DENTER(IRDA_TCB_TRACE
, "(self=0x%p)\n", self
);
1196 /* Check if socket is closing down (via irda_irnet_destroy()) */
1197 if(! test_bit(0, &self
->ttp_connect
))
1199 DERROR(IRDA_CB_ERROR
, "Socket no longer connecting. Ouch !\n");
1203 /* How much header space do we need to reserve */
1204 self
->max_header_size
= max_header_size
;
1206 /* IrTTP max SDU size in transmit direction */
1207 self
->max_sdu_size_tx
= max_sdu_size
;
1208 self
->max_data_size
= max_sdu_size
;
1209 #ifdef STREAM_COMPAT
1210 if(max_sdu_size
== 0)
1211 self
->max_data_size
= irttp_get_max_seg_size(self
->tsap
);
1212 #endif /* STREAM_COMPAT */
1214 /* At this point, IrLMP has assigned our source address */
1215 self
->saddr
= irttp_get_saddr(self
->tsap
);
1217 /* Allow higher layer to access IrTTP */
1218 set_bit(0, &self
->ttp_open
);
1219 clear_bit(0, &self
->ttp_connect
); /* Not racy, IrDA traffic is serial */
1220 /* Give a kick in the ass of ppp_generic so that he sends us some data */
1221 ppp_output_wakeup(&self
->chan
);
1223 /* Check size of received packet */
1226 #ifdef PASS_CONNECT_PACKETS
1227 DEBUG(IRDA_CB_INFO
, "Passing connect packet to PPP.\n");
1228 /* Try to pass it to PPP */
1229 irnet_data_indication(instance
, sap
, skb
);
1230 #else /* PASS_CONNECT_PACKETS */
1231 DERROR(IRDA_CB_ERROR
, "Dropping non empty packet.\n");
1232 kfree_skb(skb
); /* Note : will be optimised with other kfree... */
1233 #endif /* PASS_CONNECT_PACKETS */
1238 /* Notify the control channel */
1239 irnet_post_event(self
, IRNET_CONNECT_TO
,
1240 self
->saddr
, self
->daddr
, self
->rname
, 0);
1242 DEXIT(IRDA_TCB_TRACE
, "\n");
1245 /*------------------------------------------------------------------*/
1247 * Function irnet_flow_indication (instance, sap, flow)
1249 * Used by TinyTP to tell us if it can accept more data or not
1253 irnet_flow_indication(void * instance
,
1257 irnet_socket
* self
= (irnet_socket
*) instance
;
1258 LOCAL_FLOW oldflow
= self
->tx_flow
;
1260 DENTER(IRDA_TCB_TRACE
, "(self=0x%p, flow=%d)\n", self
, flow
);
1262 /* Update our state */
1263 self
->tx_flow
= flow
;
1265 /* Check what IrTTP want us to do... */
1269 DEBUG(IRDA_CB_INFO
, "IrTTP wants us to start again\n");
1270 /* Check if we really need to wake up PPP */
1271 if(oldflow
== FLOW_STOP
)
1272 ppp_output_wakeup(&self
->chan
);
1274 DEBUG(IRDA_CB_INFO
, "But we were already transmitting !!!\n");
1277 DEBUG(IRDA_CB_INFO
, "IrTTP wants us to slow down\n");
1280 DEBUG(IRDA_CB_INFO
, "Unknown flow command!\n");
1284 DEXIT(IRDA_TCB_TRACE
, "\n");
1287 /*------------------------------------------------------------------*/
1289 * Function irnet_status_indication (instance, sap, reason, skb)
1291 * Link (IrLAP) status report.
1295 irnet_status_indication(void * instance
,
1299 irnet_socket
* self
= (irnet_socket
*) instance
;
1301 DENTER(IRDA_TCB_TRACE
, "(self=0x%p)\n", self
);
1302 DASSERT(self
!= NULL
, , IRDA_CB_ERROR
, "Self is NULL !!!\n");
1304 /* We can only get this event if we are connected */
1307 case STATUS_NO_ACTIVITY
:
1308 irnet_post_event(self
, IRNET_BLOCKED_LINK
,
1309 self
->saddr
, self
->daddr
, self
->rname
, 0);
1312 DEBUG(IRDA_CB_INFO
, "Unknown status...\n");
1315 DEXIT(IRDA_TCB_TRACE
, "\n");
1318 /*------------------------------------------------------------------*/
1320 * Function irnet_connect_indication(instance, sap, qos, max_sdu_size, userdata)
1322 * Incoming connection
1324 * In theory, this function is called only on the server socket.
1325 * Some other node is attempting to connect to the IrNET service, and has
1326 * sent a connection request on our server socket.
1327 * We just redirect the connection to the relevant IrNET socket.
1329 * Note : we also make sure that between 2 irnet nodes, there can
1330 * exist only one irnet connection.
1333 irnet_connect_indication(void * instance
,
1335 struct qos_info
*qos
,
1337 __u8 max_header_size
,
1338 struct sk_buff
*skb
)
1340 irnet_socket
* server
= &irnet_server
.s
;
1341 irnet_socket
* new = (irnet_socket
*) NULL
;
1343 DENTER(IRDA_TCB_TRACE
, "(server=0x%p)\n", server
);
1344 DASSERT(instance
== &irnet_server
, , IRDA_CB_ERROR
,
1345 "Invalid instance (0x%p) !!!\n", instance
);
1346 DASSERT(sap
== irnet_server
.s
.tsap
, , IRDA_CB_ERROR
, "Invalid sap !!!\n");
1348 /* Try to find the most appropriate IrNET socket */
1349 new = irnet_find_socket(server
);
1351 /* After all this hard work, do we have an socket ? */
1352 if(new == (irnet_socket
*) NULL
)
1354 DEXIT(IRDA_CB_INFO
, ": No socket waiting for this connection.\n");
1355 irnet_disconnect_server(server
, skb
);
1359 /* Is the socket already busy ? */
1360 if(test_bit(0, &new->ttp_open
))
1362 DEXIT(IRDA_CB_INFO
, ": Socket already connected.\n");
1363 irnet_disconnect_server(server
, skb
);
1367 /* The following code is a bit tricky, so need comments ;-)
1369 /* If ttp_connect is set, the socket is trying to connect to the other
1370 * end and may have sent a IrTTP connection request and is waiting for
1371 * a connection response (that may never come).
1372 * Now, the pain is that the socket may have opened a tsap and is
1373 * waiting on it, while the other end is trying to connect to it on
1375 * Because IrNET can be peer to peer, we need to workaround this.
1376 * Furthermore, the way the irnetd script is implemented, the
1377 * target will create a second IrNET connection back to the
1378 * originator and expect the originator to bind this new connection
1379 * to the original PPPD instance.
1380 * And of course, if we don't use irnetd, we can have a race when
1381 * both side try to connect simultaneously, which could leave both
1382 * connections half closed (yuck).
1384 * 1) The "originator" must accept the new connection and get rid
1385 * of the old one so that irnetd works
1386 * 2) One side must deny the new connection to avoid races,
1387 * but both side must agree on which side it is...
1388 * Most often, the originator is primary at the LAP layer.
1391 /* Now, let's look at the way I wrote the test...
1392 * We need to clear up the ttp_connect flag atomically to prevent
1393 * irnet_disconnect_indication() to mess up the tsap we are going to close.
1394 * We want to clear the ttp_connect flag only if we close the tsap,
1395 * otherwise we will never close it, so we need to check for primary
1396 * *before* doing the test on the flag.
1397 * And of course, ALLOW_SIMULT_CONNECT can disable this entirely...
1401 /* Socket already connecting ? On primary ? */
1403 #ifdef ALLOW_SIMULT_CONNECT
1404 || ((irttp_is_primary(server
->tsap
) == 1) /* primary */
1405 && (test_and_clear_bit(0, &new->ttp_connect
)))
1406 #endif /* ALLOW_SIMULT_CONNECT */
1409 DERROR(IRDA_CB_ERROR
, "Socket already connecting, but going to reuse it !\n");
1411 /* Cleanup the old TSAP if necessary - IrIAP will be cleaned up later */
1412 if(new->tsap
!= NULL
)
1414 /* Close the old connection the new socket was attempting,
1415 * so that we can hook it up to the new connection.
1416 * It's now safe to do it... */
1417 irttp_close_tsap(new->tsap
);
1424 * 1) socket was not connecting or connected : ttp_connect should be 0.
1425 * 2) we don't want to connect the socket because we are secondary or
1426 * ALLOW_SIMULT_CONNECT is undefined. ttp_connect should be 1.
1427 * 3) we are half way in irnet_disconnect_indication(), and it's a
1428 * nice race condition... Fortunately, we can detect that by checking
1429 * if tsap is still alive. On the other hand, we can't be in
1430 * irda_irnet_destroy() otherwise we would not have found this
1431 * socket in the hashbin.
1433 if((test_bit(0, &new->ttp_connect
)) || (new->tsap
!= NULL
))
1435 /* Don't mess this socket, somebody else in in charge... */
1436 DERROR(IRDA_CB_ERROR
, "Race condition detected, socket in use, abort connect...\n");
1437 irnet_disconnect_server(server
, skb
);
1442 /* So : at this point, we have a socket, and it is idle. Good ! */
1443 irnet_connect_socket(server
, new, qos
, max_sdu_size
, max_header_size
);
1445 /* Check size of received packet */
1448 #ifdef PASS_CONNECT_PACKETS
1449 DEBUG(IRDA_CB_INFO
, "Passing connect packet to PPP.\n");
1450 /* Try to pass it to PPP */
1451 irnet_data_indication(new, new->tsap
, skb
);
1452 #else /* PASS_CONNECT_PACKETS */
1453 DERROR(IRDA_CB_ERROR
, "Dropping non empty packet.\n");
1454 kfree_skb(skb
); /* Note : will be optimised with other kfree... */
1455 #endif /* PASS_CONNECT_PACKETS */
1460 DEXIT(IRDA_TCB_TRACE
, "\n");
1464 /********************** IRDA-IAS/LMP CALLBACKS **********************/
1466 * These are the callbacks called by other layers of the IrDA stack,
1467 * mainly LMP for discovery and IAS for name queries.
1470 /*------------------------------------------------------------------*/
1472 * Function irnet_getvalue_confirm (result, obj_id, value, priv)
1474 * Got answer from remote LM-IAS, just connect
1476 * This is the reply to a IAS query we were doing to find the TSAP of
1477 * the device we want to connect to.
1478 * If we have found a valid TSAP, just initiate the TTP connection
1482 irnet_getvalue_confirm(int result
,
1484 struct ias_value
*value
,
1487 irnet_socket
* self
= (irnet_socket
*) priv
;
1489 DENTER(IRDA_OCB_TRACE
, "(self=0x%p)\n", self
);
1490 DASSERT(self
!= NULL
, , IRDA_OCB_ERROR
, "Self is NULL !!!\n");
1492 /* Check if already connected (via irnet_connect_socket())
1493 * or socket is closing down (via irda_irnet_destroy()) */
1494 if(! test_bit(0, &self
->ttp_connect
))
1496 DERROR(IRDA_OCB_ERROR
, "Socket no longer connecting. Ouch !\n");
1500 /* We probably don't need to make any more queries */
1501 iriap_close(self
->iriap
);
1504 /* Post process the IAS reply */
1505 self
->dtsap_sel
= irnet_ias_to_tsap(self
, result
, value
);
1507 /* If error, just go out */
1510 clear_bit(0, &self
->ttp_connect
);
1511 DERROR(IRDA_OCB_ERROR
, "IAS connect failed ! (0x%X)\n", self
->errno
);
1515 DEBUG(IRDA_OCB_INFO
, "daddr = %08x, lsap = %d, starting IrTTP connection\n",
1516 self
->daddr
, self
->dtsap_sel
);
1518 /* Start up TTP - non blocking */
1519 irnet_connect_tsap(self
);
1521 DEXIT(IRDA_OCB_TRACE
, "\n");
1524 /*------------------------------------------------------------------*/
1526 * Function irnet_discovervalue_confirm (result, obj_id, value, priv)
1528 * Handle the TSAP discovery procedure state machine.
1529 * Got answer from remote LM-IAS, try next device
1531 * We are doing a TSAP discovery procedure, and we got an answer to
1532 * a IAS query we were doing to find the TSAP on one of the address
1533 * in the discovery log.
1535 * If we have found a valid TSAP for the first time, save it. If it's
1536 * not the first time we found one, complain.
1538 * If we have more addresses in the log, just initiate a new query.
1539 * Note that those query may fail (see irnet_discover_daddr_and_lsap_sel())
1541 * Otherwise, wrap up the procedure (cleanup), check if we have found
1542 * any device and connect to it.
1545 irnet_discovervalue_confirm(int result
,
1547 struct ias_value
*value
,
1550 irnet_socket
* self
= (irnet_socket
*) priv
;
1551 __u8 dtsap_sel
; /* TSAP we are looking for */
1553 DENTER(IRDA_OCB_TRACE
, "(self=0x%p)\n", self
);
1554 DASSERT(self
!= NULL
, , IRDA_OCB_ERROR
, "Self is NULL !!!\n");
1556 /* Check if already connected (via irnet_connect_socket())
1557 * or socket is closing down (via irda_irnet_destroy()) */
1558 if(! test_bit(0, &self
->ttp_connect
))
1560 DERROR(IRDA_OCB_ERROR
, "Socket no longer connecting. Ouch !\n");
1564 /* Post process the IAS reply */
1565 dtsap_sel
= irnet_ias_to_tsap(self
, result
, value
);
1567 /* Have we got something ? */
1568 if(self
->errno
== 0)
1570 /* We found the requested service */
1571 if(self
->daddr
!= DEV_ADDR_ANY
)
1573 DERROR(IRDA_OCB_ERROR
, "More than one device in range supports IrNET...\n");
1577 /* First time we found that one, save it ! */
1578 self
->daddr
= self
->discoveries
[self
->disco_index
].daddr
;
1579 self
->dtsap_sel
= dtsap_sel
;
1584 if((self
->errno
== -EADDRNOTAVAIL
) || (self
->errno
== 0))
1588 /* Search the next node */
1589 ret
= irnet_discover_next_daddr(self
);
1592 /* In this case, the above request was non-blocking.
1593 * We will return here after a while... */
1596 /* In this case, we have processed the last discovery item */
1599 /* No more queries to be done (failure or last one) */
1601 /* We probably don't need to make any more queries */
1602 iriap_close(self
->iriap
);
1605 /* No more items : remove the log and signal termination */
1606 DEBUG(IRDA_OCB_INFO
, "Cleaning up log (0x%p)\n",
1608 if(self
->discoveries
!= NULL
)
1610 /* Cleanup our copy of the discovery log */
1611 kfree(self
->discoveries
);
1612 self
->discoveries
= NULL
;
1614 self
->disco_number
= -1;
1616 /* Check out what we found */
1617 if(self
->daddr
== DEV_ADDR_ANY
)
1619 self
->daddr
= DEV_ADDR_ANY
;
1620 clear_bit(0, &self
->ttp_connect
);
1621 DEXIT(IRDA_OCB_TRACE
, ": cannot discover IrNET in any device !!!\n");
1625 /* We have a valid address - just connect */
1627 DEBUG(IRDA_OCB_INFO
, "daddr = %08x, lsap = %d, starting IrTTP connection\n",
1628 self
->daddr
, self
->dtsap_sel
);
1630 /* Start up TTP - non blocking */
1631 irnet_connect_tsap(self
);
1633 DEXIT(IRDA_OCB_TRACE
, "\n");
1636 #ifdef DISCOVERY_EVENTS
1637 /*------------------------------------------------------------------*/
1639 * Function irnet_discovery_indication (discovery)
1641 * Got a discovery indication from IrLMP, post an event
1643 * Note : IrLMP take care of matching the hint mask for us, and also
1644 * check if it is a "new" node for us...
1646 * As IrLMP filter on the IrLAN hint bit, we get both IrLAN and IrNET
1647 * nodes, so it's only at connection time that we will know if the
1648 * node support IrNET, IrLAN or both. The other solution is to check
1649 * in IAS the PNP ids and service name.
1650 * Note : even if a node support IrNET (or IrLAN), it's no guarantee
1651 * that we will be able to connect to it, the node might already be
1654 * One last thing : in some case, this function will trigger duplicate
1655 * discovery events. On the other hand, we should catch all
1656 * discoveries properly (i.e. not miss one). Filtering duplicate here
1657 * is to messy, so we leave that to user space...
1660 irnet_discovery_indication(discinfo_t
* discovery
,
1661 DISCOVERY_MODE mode
,
1664 irnet_socket
* self
= &irnet_server
.s
;
1666 DENTER(IRDA_OCB_TRACE
, "(self=0x%p)\n", self
);
1667 DASSERT(priv
== &irnet_server
, , IRDA_OCB_ERROR
,
1668 "Invalid instance (0x%p) !!!\n", priv
);
1670 DEBUG(IRDA_OCB_INFO
, "Discovered new IrNET/IrLAN node %s...\n",
1673 /* Notify the control channel */
1674 irnet_post_event(NULL
, IRNET_DISCOVER
,
1675 discovery
->saddr
, discovery
->daddr
, discovery
->info
,
1676 u16ho(discovery
->hints
));
1678 DEXIT(IRDA_OCB_TRACE
, "\n");
1681 /*------------------------------------------------------------------*/
1683 * Function irnet_expiry_indication (expiry)
1685 * Got a expiry indication from IrLMP, post an event
1687 * Note : IrLMP take care of matching the hint mask for us, we only
1688 * check if it is a "new" node...
1691 irnet_expiry_indication(discinfo_t
* expiry
,
1692 DISCOVERY_MODE mode
,
1695 irnet_socket
* self
= &irnet_server
.s
;
1697 DENTER(IRDA_OCB_TRACE
, "(self=0x%p)\n", self
);
1698 DASSERT(priv
== &irnet_server
, , IRDA_OCB_ERROR
,
1699 "Invalid instance (0x%p) !!!\n", priv
);
1701 DEBUG(IRDA_OCB_INFO
, "IrNET/IrLAN node %s expired...\n",
1704 /* Notify the control channel */
1705 irnet_post_event(NULL
, IRNET_EXPIRE
,
1706 expiry
->saddr
, expiry
->daddr
, expiry
->info
,
1707 u16ho(expiry
->hints
));
1709 DEXIT(IRDA_OCB_TRACE
, "\n");
1711 #endif /* DISCOVERY_EVENTS */
1714 /*********************** PROC ENTRY CALLBACKS ***********************/
1716 * We create a instance in the /proc filesystem, and here we take care
1720 #ifdef CONFIG_PROC_FS
1722 irnet_proc_show(struct seq_file
*m
, void *v
)
1724 irnet_socket
* self
;
1728 /* Get the IrNET server information... */
1729 seq_printf(m
, "IrNET server - ");
1730 seq_printf(m
, "IrDA state: %s, ",
1731 (irnet_server
.running
? "running" : "dead"));
1732 seq_printf(m
, "stsap_sel: %02x, ", irnet_server
.s
.stsap_sel
);
1733 seq_printf(m
, "dtsap_sel: %02x\n", irnet_server
.s
.dtsap_sel
);
1735 /* Do we need to continue ? */
1736 if(!irnet_server
.running
)
1739 /* Protect access to the instance list */
1740 spin_lock_bh(&irnet_server
.spinlock
);
1742 /* Get the sockets one by one... */
1743 self
= (irnet_socket
*) hashbin_get_first(irnet_server
.list
);
1746 /* Start printing info about the socket. */
1747 seq_printf(m
, "\nIrNET socket %d - ", i
++);
1749 /* First, get the requested configuration */
1750 seq_printf(m
, "Requested IrDA name: \"%s\", ", self
->rname
);
1751 seq_printf(m
, "daddr: %08x, ", self
->rdaddr
);
1752 seq_printf(m
, "saddr: %08x\n", self
->rsaddr
);
1754 /* Second, get all the PPP info */
1755 seq_printf(m
, " PPP state: %s",
1756 (self
->ppp_open
? "registered" : "unregistered"));
1759 seq_printf(m
, ", unit: ppp%d",
1760 ppp_unit_number(&self
->chan
));
1761 seq_printf(m
, ", channel: %d",
1762 ppp_channel_index(&self
->chan
));
1763 seq_printf(m
, ", mru: %d",
1765 /* Maybe add self->flags ? Later... */
1768 /* Then, get all the IrDA specific info... */
1770 state
= "connected";
1772 if(self
->tsap
!= NULL
)
1773 state
= "connecting";
1775 if(self
->iriap
!= NULL
)
1776 state
= "searching";
1778 if(self
->ttp_connect
)
1782 seq_printf(m
, "\n IrDA state: %s, ", state
);
1783 seq_printf(m
, "daddr: %08x, ", self
->daddr
);
1784 seq_printf(m
, "stsap_sel: %02x, ", self
->stsap_sel
);
1785 seq_printf(m
, "dtsap_sel: %02x\n", self
->dtsap_sel
);
1787 /* Next socket, please... */
1788 self
= (irnet_socket
*) hashbin_get_next(irnet_server
.list
);
1792 spin_unlock_bh(&irnet_server
.spinlock
);
1797 static int irnet_proc_open(struct inode
*inode
, struct file
*file
)
1799 return single_open(file
, irnet_proc_show
, NULL
);
1802 static const struct file_operations irnet_proc_fops
= {
1803 .owner
= THIS_MODULE
,
1804 .open
= irnet_proc_open
,
1806 .llseek
= seq_lseek
,
1807 .release
= single_release
,
1809 #endif /* PROC_FS */
1812 /********************** CONFIGURATION/CLEANUP **********************/
1814 * Initialisation and teardown of the IrDA part, called at module
1815 * insertion and removal...
1818 /*------------------------------------------------------------------*/
1820 * Prepare the IrNET layer for operation...
1823 irda_irnet_init(void)
1827 DENTER(MODULE_TRACE
, "()\n");
1829 /* Pure paranoia - should be redundant */
1830 memset(&irnet_server
, 0, sizeof(struct irnet_root
));
1832 /* Setup start of irnet instance list */
1833 irnet_server
.list
= hashbin_new(HB_NOLOCK
);
1834 DABORT(irnet_server
.list
== NULL
, -ENOMEM
,
1835 MODULE_ERROR
, "Can't allocate hashbin!\n");
1836 /* Init spinlock for instance list */
1837 spin_lock_init(&irnet_server
.spinlock
);
1839 /* Initialise control channel */
1840 init_waitqueue_head(&irnet_events
.rwait
);
1841 irnet_events
.index
= 0;
1842 /* Init spinlock for event logging */
1843 spin_lock_init(&irnet_events
.spinlock
);
1845 #ifdef CONFIG_PROC_FS
1846 /* Add a /proc file for irnet infos */
1847 proc_create("irnet", 0, proc_irda
, &irnet_proc_fops
);
1848 #endif /* CONFIG_PROC_FS */
1850 /* Setup the IrNET server */
1851 err
= irnet_setup_server();
1854 /* We are no longer functional... */
1855 irnet_server
.running
= 1;
1857 DEXIT(MODULE_TRACE
, "\n");
1861 /*------------------------------------------------------------------*/
1863 * Cleanup at exit...
1866 irda_irnet_cleanup(void)
1868 DENTER(MODULE_TRACE
, "()\n");
1870 /* We are no longer there... */
1871 irnet_server
.running
= 0;
1873 #ifdef CONFIG_PROC_FS
1874 /* Remove our /proc file */
1875 remove_proc_entry("irnet", proc_irda
);
1876 #endif /* CONFIG_PROC_FS */
1878 /* Remove our IrNET server from existence */
1879 irnet_destroy_server();
1881 /* Remove all instances of IrNET socket still present */
1882 hashbin_delete(irnet_server
.list
, (FREE_FUNC
) irda_irnet_destroy
);
1884 DEXIT(MODULE_TRACE
, "\n");