2 * IrNET protocol module : Synchronous PPP over an IrDA socket.
4 * Jean II - HPL `00 - <jt@hpl.hp.com>
6 * This file implement the PPP interface and /dev/irnet character device.
7 * The PPP interface hook to the ppp_generic module, handle all our
8 * relationship to the PPP code in the kernel (and by extension to pppd),
9 * and exchange PPP frames with this module (send/receive).
10 * The /dev/irnet device is used primarily for 2 functions :
11 * 1) as a stub for pppd (the ppp daemon), so that we can appropriately
12 * generate PPP sessions (we pretend we are a tty).
13 * 2) as a control channel (write commands, read events)
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/smp_lock.h>
19 #include "irnet_ppp.h" /* Private header */
20 /* Please put other headers in irnet.h - Thanks */
22 /* Generic PPP callbacks (to call us) */
23 static const struct ppp_channel_ops irnet_ppp_ops
= {
24 .start_xmit
= ppp_irnet_send
,
25 .ioctl
= ppp_irnet_ioctl
28 /************************* CONTROL CHANNEL *************************/
30 * When a pppd instance is not active on /dev/irnet, it acts as a control
32 * Writing allow to set up the IrDA destination of the IrNET channel,
33 * and any application may be read events happening in IrNET...
36 /*------------------------------------------------------------------*/
38 * Write is used to send a command to configure a IrNET channel
39 * before it is open by pppd. The syntax is : "command argument"
40 * Currently there is only two defined commands :
41 * o name : set the requested IrDA nickname of the IrNET peer.
42 * o addr : set the requested IrDA address of the IrNET peer.
43 * Note : the code is crude, but effective...
46 irnet_ctrl_write(irnet_socket
* ap
,
47 const char __user
*buf
,
50 char command
[IRNET_MAX_COMMAND
];
51 char * start
; /* Current command being processed */
52 char * next
; /* Next command to process */
53 int length
; /* Length of current command */
55 DENTER(CTRL_TRACE
, "(ap=0x%p, count=%Zd)\n", ap
, count
);
57 /* Check for overflow... */
58 DABORT(count
>= IRNET_MAX_COMMAND
, -ENOMEM
,
59 CTRL_ERROR
, "Too much data !!!\n");
61 /* Get the data in the driver */
62 if(copy_from_user(command
, buf
, count
))
64 DERROR(CTRL_ERROR
, "Invalid user space pointer.\n");
68 /* Safe terminate the string */
69 command
[count
] = '\0';
70 DEBUG(CTRL_INFO
, "Command line received is ``%s'' (%Zd).\n",
73 /* Check every commands in the command line */
77 /* Look at the next command */
80 /* Scrap whitespaces before the command */
81 start
= skip_spaces(start
);
83 /* ',' is our command separator */
84 next
= strchr(start
, ',');
87 *next
= '\0'; /* Terminate command */
88 length
= next
- start
; /* Length */
89 next
++; /* Skip the '\0' */
92 length
= strlen(start
);
94 DEBUG(CTRL_INFO
, "Found command ``%s'' (%d).\n", start
, length
);
96 /* Check if we recognised one of the known command
97 * We can't use "switch" with strings, so hack with "continue" */
99 /* First command : name -> Requested IrDA nickname */
100 if(!strncmp(start
, "name", 4))
102 /* Copy the name only if is included and not "any" */
103 if((length
> 5) && (strcmp(start
+ 5, "any")))
105 /* Strip out trailing whitespaces */
106 while(isspace(start
[length
- 1]))
109 /* Copy the name for later reuse */
110 memcpy(ap
->rname
, start
+ 5, length
- 5);
111 ap
->rname
[length
- 5] = '\0';
115 DEBUG(CTRL_INFO
, "Got rname = ``%s''\n", ap
->rname
);
117 /* Restart the loop */
121 /* Second command : addr, daddr -> Requested IrDA destination address
122 * Also process : saddr -> Requested IrDA source address */
123 if((!strncmp(start
, "addr", 4)) ||
124 (!strncmp(start
, "daddr", 5)) ||
125 (!strncmp(start
, "saddr", 5)))
127 __u32 addr
= DEV_ADDR_ANY
;
129 /* Copy the address only if is included and not "any" */
130 if((length
> 5) && (strcmp(start
+ 5, "any")))
132 char * begp
= start
+ 5;
135 /* Scrap whitespaces before the command */
136 begp
= skip_spaces(begp
);
138 /* Convert argument to a number (last arg is the base) */
139 addr
= simple_strtoul(begp
, &endp
, 16);
140 /* Has it worked ? (endp should be start + length) */
141 DABORT(endp
<= (start
+ 5), -EINVAL
,
142 CTRL_ERROR
, "Invalid address.\n");
144 /* Which type of address ? */
149 DEBUG(CTRL_INFO
, "Got rsaddr = %08x\n", ap
->rsaddr
);
155 DEBUG(CTRL_INFO
, "Got rdaddr = %08x\n", ap
->rdaddr
);
158 /* Restart the loop */
162 /* Other possible command : connect N (number of retries) */
164 /* No command matched -> Failed... */
165 DABORT(1, -EINVAL
, CTRL_ERROR
, "Not a recognised IrNET command.\n");
168 /* Success : we have parsed all commands successfully */
172 #ifdef INITIAL_DISCOVERY
173 /*------------------------------------------------------------------*/
175 * Function irnet_get_discovery_log (self)
177 * Query the content on the discovery log if not done
179 * This function query the current content of the discovery log
180 * at the startup of the event channel and save it in the internal struct.
183 irnet_get_discovery_log(irnet_socket
* ap
)
185 __u16 mask
= irlmp_service_to_hint(S_LAN
);
187 /* Ask IrLMP for the current discovery log */
188 ap
->discoveries
= irlmp_get_discoveries(&ap
->disco_number
, mask
,
189 DISCOVERY_DEFAULT_SLOTS
);
191 /* Check if the we got some results */
192 if(ap
->discoveries
== NULL
)
193 ap
->disco_number
= -1;
195 DEBUG(CTRL_INFO
, "Got the log (0x%p), size is %d\n",
196 ap
->discoveries
, ap
->disco_number
);
199 /*------------------------------------------------------------------*/
201 * Function irnet_read_discovery_log (self, event)
203 * Read the content on the discovery log
205 * This function dump the current content of the discovery log
206 * at the startup of the event channel.
207 * Return 1 if wrote an event on the control channel...
209 * State of the ap->disco_XXX variables :
210 * Socket creation : discoveries = NULL ; disco_index = 0 ; disco_number = 0
211 * While reading : discoveries = ptr ; disco_index = X ; disco_number = Y
212 * After reading : discoveries = NULL ; disco_index = Y ; disco_number = -1
215 irnet_read_discovery_log(irnet_socket
* ap
,
220 DENTER(CTRL_TRACE
, "(ap=0x%p, event=0x%p)\n",
223 /* Test if we have some work to do or we have already finished */
224 if(ap
->disco_number
== -1)
226 DEBUG(CTRL_INFO
, "Already done\n");
230 /* Test if it's the first time and therefore we need to get the log */
231 if(ap
->discoveries
== NULL
)
232 irnet_get_discovery_log(ap
);
234 /* Check if we have more item to dump */
235 if(ap
->disco_index
< ap
->disco_number
)
238 sprintf(event
, "Found %08x (%s) behind %08x {hints %02X-%02X}\n",
239 ap
->discoveries
[ap
->disco_index
].daddr
,
240 ap
->discoveries
[ap
->disco_index
].info
,
241 ap
->discoveries
[ap
->disco_index
].saddr
,
242 ap
->discoveries
[ap
->disco_index
].hints
[0],
243 ap
->discoveries
[ap
->disco_index
].hints
[1]);
244 DEBUG(CTRL_INFO
, "Writing discovery %d : %s\n",
245 ap
->disco_index
, ap
->discoveries
[ap
->disco_index
].info
);
247 /* We have an event */
253 /* Check if we have done the last item */
254 if(ap
->disco_index
>= ap
->disco_number
)
256 /* No more items : remove the log and signal termination */
257 DEBUG(CTRL_INFO
, "Cleaning up log (0x%p)\n",
259 if(ap
->discoveries
!= NULL
)
261 /* Cleanup our copy of the discovery log */
262 kfree(ap
->discoveries
);
263 ap
->discoveries
= NULL
;
265 ap
->disco_number
= -1;
270 #endif /* INITIAL_DISCOVERY */
272 /*------------------------------------------------------------------*/
274 * Read is used to get IrNET events
276 static inline ssize_t
277 irnet_ctrl_read(irnet_socket
* ap
,
282 DECLARE_WAITQUEUE(wait
, current
);
283 char event
[64]; /* Max event is 61 char */
286 DENTER(CTRL_TRACE
, "(ap=0x%p, count=%Zd)\n", ap
, count
);
288 /* Check if we can write an event out in one go */
289 DABORT(count
< sizeof(event
), -EOVERFLOW
, CTRL_ERROR
, "Buffer to small.\n");
291 #ifdef INITIAL_DISCOVERY
292 /* Check if we have read the log */
293 if(irnet_read_discovery_log(ap
, event
))
295 /* We have an event !!! Copy it to the user */
296 if(copy_to_user(buf
, event
, strlen(event
)))
298 DERROR(CTRL_ERROR
, "Invalid user space pointer.\n");
302 DEXIT(CTRL_TRACE
, "\n");
303 return strlen(event
);
305 #endif /* INITIAL_DISCOVERY */
307 /* Put ourselves on the wait queue to be woken up */
308 add_wait_queue(&irnet_events
.rwait
, &wait
);
309 current
->state
= TASK_INTERRUPTIBLE
;
312 /* If there is unread events */
314 if(ap
->event_index
!= irnet_events
.index
)
317 if(file
->f_flags
& O_NONBLOCK
)
320 if(signal_pending(current
))
322 /* Yield and wait to be woken up */
325 current
->state
= TASK_RUNNING
;
326 remove_wait_queue(&irnet_events
.rwait
, &wait
);
328 /* Did we got it ? */
331 /* No, return the error code */
332 DEXIT(CTRL_TRACE
, " - ret %Zd\n", ret
);
336 /* Which event is it ? */
337 switch(irnet_events
.log
[ap
->event_index
].event
)
340 sprintf(event
, "Discovered %08x (%s) behind %08x {hints %02X-%02X}\n",
341 irnet_events
.log
[ap
->event_index
].daddr
,
342 irnet_events
.log
[ap
->event_index
].name
,
343 irnet_events
.log
[ap
->event_index
].saddr
,
344 irnet_events
.log
[ap
->event_index
].hints
.byte
[0],
345 irnet_events
.log
[ap
->event_index
].hints
.byte
[1]);
348 sprintf(event
, "Expired %08x (%s) behind %08x {hints %02X-%02X}\n",
349 irnet_events
.log
[ap
->event_index
].daddr
,
350 irnet_events
.log
[ap
->event_index
].name
,
351 irnet_events
.log
[ap
->event_index
].saddr
,
352 irnet_events
.log
[ap
->event_index
].hints
.byte
[0],
353 irnet_events
.log
[ap
->event_index
].hints
.byte
[1]);
355 case IRNET_CONNECT_TO
:
356 sprintf(event
, "Connected to %08x (%s) on ppp%d\n",
357 irnet_events
.log
[ap
->event_index
].daddr
,
358 irnet_events
.log
[ap
->event_index
].name
,
359 irnet_events
.log
[ap
->event_index
].unit
);
361 case IRNET_CONNECT_FROM
:
362 sprintf(event
, "Connection from %08x (%s) on ppp%d\n",
363 irnet_events
.log
[ap
->event_index
].daddr
,
364 irnet_events
.log
[ap
->event_index
].name
,
365 irnet_events
.log
[ap
->event_index
].unit
);
367 case IRNET_REQUEST_FROM
:
368 sprintf(event
, "Request from %08x (%s) behind %08x\n",
369 irnet_events
.log
[ap
->event_index
].daddr
,
370 irnet_events
.log
[ap
->event_index
].name
,
371 irnet_events
.log
[ap
->event_index
].saddr
);
373 case IRNET_NOANSWER_FROM
:
374 sprintf(event
, "No-answer from %08x (%s) on ppp%d\n",
375 irnet_events
.log
[ap
->event_index
].daddr
,
376 irnet_events
.log
[ap
->event_index
].name
,
377 irnet_events
.log
[ap
->event_index
].unit
);
379 case IRNET_BLOCKED_LINK
:
380 sprintf(event
, "Blocked link with %08x (%s) on ppp%d\n",
381 irnet_events
.log
[ap
->event_index
].daddr
,
382 irnet_events
.log
[ap
->event_index
].name
,
383 irnet_events
.log
[ap
->event_index
].unit
);
385 case IRNET_DISCONNECT_FROM
:
386 sprintf(event
, "Disconnection from %08x (%s) on ppp%d\n",
387 irnet_events
.log
[ap
->event_index
].daddr
,
388 irnet_events
.log
[ap
->event_index
].name
,
389 irnet_events
.log
[ap
->event_index
].unit
);
391 case IRNET_DISCONNECT_TO
:
392 sprintf(event
, "Disconnected to %08x (%s)\n",
393 irnet_events
.log
[ap
->event_index
].daddr
,
394 irnet_events
.log
[ap
->event_index
].name
);
397 sprintf(event
, "Bug\n");
399 /* Increment our event index */
400 ap
->event_index
= (ap
->event_index
+ 1) % IRNET_MAX_EVENTS
;
402 DEBUG(CTRL_INFO
, "Event is :%s", event
);
404 /* Copy it to the user */
405 if(copy_to_user(buf
, event
, strlen(event
)))
407 DERROR(CTRL_ERROR
, "Invalid user space pointer.\n");
411 DEXIT(CTRL_TRACE
, "\n");
412 return strlen(event
);
415 /*------------------------------------------------------------------*/
417 * Poll : called when someone do a select on /dev/irnet.
418 * Just check if there are new events...
420 static inline unsigned int
421 irnet_ctrl_poll(irnet_socket
* ap
,
427 DENTER(CTRL_TRACE
, "(ap=0x%p)\n", ap
);
429 poll_wait(file
, &irnet_events
.rwait
, wait
);
430 mask
= POLLOUT
| POLLWRNORM
;
431 /* If there is unread events */
432 if(ap
->event_index
!= irnet_events
.index
)
433 mask
|= POLLIN
| POLLRDNORM
;
434 #ifdef INITIAL_DISCOVERY
435 if(ap
->disco_number
!= -1)
437 /* Test if it's the first time and therefore we need to get the log */
438 if(ap
->discoveries
== NULL
)
439 irnet_get_discovery_log(ap
);
441 if(ap
->disco_number
!= -1)
442 mask
|= POLLIN
| POLLRDNORM
;
444 #endif /* INITIAL_DISCOVERY */
446 DEXIT(CTRL_TRACE
, " - mask=0x%X\n", mask
);
451 /*********************** FILESYSTEM CALLBACKS ***********************/
453 * Implement the usual open, read, write functions that will be called
454 * by the file system when some action is performed on /dev/irnet.
455 * Most of those actions will in fact be performed by "pppd" or
456 * the control channel, we just act as a redirector...
459 /*------------------------------------------------------------------*/
461 * Open : when somebody open /dev/irnet
462 * We basically create a new instance of irnet and initialise it.
465 dev_irnet_open(struct inode
* inode
,
468 struct irnet_socket
* ap
;
471 DENTER(FS_TRACE
, "(file=0x%p)\n", file
);
473 #ifdef SECURE_DEVIRNET
474 /* This could (should?) be enforced by the permissions on /dev/irnet. */
475 if(!capable(CAP_NET_ADMIN
))
477 #endif /* SECURE_DEVIRNET */
479 /* Allocate a private structure for this IrNET instance */
480 ap
= kzalloc(sizeof(*ap
), GFP_KERNEL
);
481 DABORT(ap
== NULL
, -ENOMEM
, FS_ERROR
, "Can't allocate struct irnet...\n");
483 /* initialize the irnet structure */
486 /* PPP channel setup */
488 ap
->chan
.private = ap
;
489 ap
->chan
.ops
= &irnet_ppp_ops
;
490 ap
->chan
.mtu
= (2048 - TTP_MAX_HEADER
- 2 - PPP_HDRLEN
);
491 ap
->chan
.hdrlen
= 2 + TTP_MAX_HEADER
; /* for A/C + Max IrDA hdr */
493 ap
->mru
= (2048 - TTP_MAX_HEADER
- 2 - PPP_HDRLEN
);
495 ap
->xaccm
[3] = 0x60000000U
;
498 /* Setup the IrDA part... */
499 err
= irda_irnet_create(ap
);
502 DERROR(FS_ERROR
, "Can't setup IrDA link...\n");
508 /* For the control channel */
509 ap
->event_index
= irnet_events
.index
; /* Cancel all past events */
511 mutex_init(&ap
->lock
);
513 /* Put our stuff where we will be able to find it later */
514 file
->private_data
= ap
;
516 DEXIT(FS_TRACE
, " - ap=0x%p\n", ap
);
522 /*------------------------------------------------------------------*/
524 * Close : when somebody close /dev/irnet
525 * Destroy the instance of /dev/irnet
528 dev_irnet_close(struct inode
* inode
,
531 irnet_socket
* ap
= file
->private_data
;
533 DENTER(FS_TRACE
, "(file=0x%p, ap=0x%p)\n",
535 DABORT(ap
== NULL
, 0, FS_ERROR
, "ap is NULL !!!\n");
537 /* Detach ourselves */
538 file
->private_data
= NULL
;
540 /* Close IrDA stuff */
541 irda_irnet_destroy(ap
);
543 /* Disconnect from the generic PPP layer if not already done */
546 DERROR(FS_ERROR
, "Channel still registered - deregistering !\n");
548 ppp_unregister_channel(&ap
->chan
);
553 DEXIT(FS_TRACE
, "\n");
557 /*------------------------------------------------------------------*/
559 * Write does nothing.
560 * (we receive packet from ppp_generic through ppp_irnet_send())
563 dev_irnet_write(struct file
* file
,
564 const char __user
*buf
,
568 irnet_socket
* ap
= file
->private_data
;
570 DPASS(FS_TRACE
, "(file=0x%p, ap=0x%p, count=%Zd)\n",
572 DABORT(ap
== NULL
, -ENXIO
, FS_ERROR
, "ap is NULL !!!\n");
574 /* If we are connected to ppp_generic, let it handle the job */
578 return irnet_ctrl_write(ap
, buf
, count
);
581 /*------------------------------------------------------------------*/
583 * Read doesn't do much either.
584 * (pppd poll us, but ultimately reads through /dev/ppp)
587 dev_irnet_read(struct file
* file
,
592 irnet_socket
* ap
= file
->private_data
;
594 DPASS(FS_TRACE
, "(file=0x%p, ap=0x%p, count=%Zd)\n",
596 DABORT(ap
== NULL
, -ENXIO
, FS_ERROR
, "ap is NULL !!!\n");
598 /* If we are connected to ppp_generic, let it handle the job */
602 return irnet_ctrl_read(ap
, file
, buf
, count
);
605 /*------------------------------------------------------------------*/
607 * Poll : called when someone do a select on /dev/irnet
610 dev_irnet_poll(struct file
* file
,
613 irnet_socket
* ap
= file
->private_data
;
616 DENTER(FS_TRACE
, "(file=0x%p, ap=0x%p)\n",
619 mask
= POLLOUT
| POLLWRNORM
;
620 DABORT(ap
== NULL
, mask
, FS_ERROR
, "ap is NULL !!!\n");
622 /* If we are connected to ppp_generic, let it handle the job */
624 mask
|= irnet_ctrl_poll(ap
, file
, wait
);
626 DEXIT(FS_TRACE
, " - mask=0x%X\n", mask
);
630 /*------------------------------------------------------------------*/
632 * IOCtl : Called when someone does some ioctls on /dev/irnet
633 * This is the way pppd configure us and control us while the PPP
634 * instance is active.
642 irnet_socket
* ap
= file
->private_data
;
645 void __user
*argp
= (void __user
*)arg
;
647 DENTER(FS_TRACE
, "(file=0x%p, ap=0x%p, cmd=0x%X)\n",
650 /* Basic checks... */
651 DASSERT(ap
!= NULL
, -ENXIO
, PPP_ERROR
, "ap is NULL...\n");
652 #ifdef SECURE_DEVIRNET
653 if(!capable(CAP_NET_ADMIN
))
655 #endif /* SECURE_DEVIRNET */
660 /* Set discipline (should be N_SYNC_PPP or N_TTY) */
662 if(get_user(val
, (int __user
*)argp
))
664 if((val
== N_SYNC_PPP
) || (val
== N_PPP
))
666 DEBUG(FS_INFO
, "Entering PPP discipline.\n");
667 /* PPP channel setup (ap->chan in configured in dev_irnet_open())*/
668 if (mutex_lock_interruptible(&ap
->lock
))
671 err
= ppp_register_channel(&ap
->chan
);
674 /* Our ppp side is active */
677 DEBUG(FS_INFO
, "Trying to establish a connection.\n");
678 /* Setup the IrDA link now - may fail... */
679 irda_irnet_connect(ap
);
682 DERROR(FS_ERROR
, "Can't setup PPP channel...\n");
684 mutex_unlock(&ap
->lock
);
688 /* In theory, should be N_TTY */
689 DEBUG(FS_INFO
, "Exiting PPP discipline.\n");
690 /* Disconnect from the generic PPP layer */
691 if (mutex_lock_interruptible(&ap
->lock
))
697 ppp_unregister_channel(&ap
->chan
);
700 DERROR(FS_ERROR
, "Channel not registered !\n");
703 mutex_unlock(&ap
->lock
);
707 /* Query PPP channel and unit number */
709 if (mutex_lock_interruptible(&ap
->lock
))
712 if(ap
->ppp_open
&& !put_user(ppp_channel_index(&ap
->chan
),
716 mutex_unlock(&ap
->lock
);
719 if (mutex_lock_interruptible(&ap
->lock
))
722 if(ap
->ppp_open
&& !put_user(ppp_unit_number(&ap
->chan
),
726 mutex_unlock(&ap
->lock
);
729 /* All these ioctls can be passed both directly and from ppp_generic,
730 * so we just deal with them in one place...
734 case PPPIOCGASYNCMAP
:
735 case PPPIOCSASYNCMAP
:
736 case PPPIOCGRASYNCMAP
:
737 case PPPIOCSRASYNCMAP
:
738 case PPPIOCGXASYNCMAP
:
739 case PPPIOCSXASYNCMAP
:
742 DEBUG(FS_INFO
, "Standard PPP ioctl.\n");
743 if(!capable(CAP_NET_ADMIN
))
746 if (mutex_lock_interruptible(&ap
->lock
))
749 err
= ppp_irnet_ioctl(&ap
->chan
, cmd
, arg
);
751 mutex_unlock(&ap
->lock
);
755 /* TTY IOCTLs : Pretend that we are a tty, to keep pppd happy */
758 DEBUG(FS_INFO
, "Get termios.\n");
759 if (mutex_lock_interruptible(&ap
->lock
))
763 if(!kernel_termios_to_user_termios((struct termios __user
*)argp
, &ap
->termios
))
766 if(kernel_termios_to_user_termios_1((struct termios __user
*)argp
, &ap
->termios
))
770 mutex_unlock(&ap
->lock
);
774 DEBUG(FS_INFO
, "Set termios.\n");
775 if (mutex_lock_interruptible(&ap
->lock
))
779 if(!user_termios_to_kernel_termios(&ap
->termios
, (struct termios __user
*)argp
))
782 if(!user_termios_to_kernel_termios_1(&ap
->termios
, (struct termios __user
*)argp
))
786 mutex_unlock(&ap
->lock
);
792 /* Set exclusive/non-exclusive mode */
795 DEBUG(FS_INFO
, "TTY compatibility.\n");
800 DEBUG(FS_INFO
, "TCGETA\n");
804 DEBUG(FS_INFO
, "TCFLSH\n");
805 /* Note : this will flush buffers in PPP, so it *must* be done
806 * We should also worry that we don't accept junk here and that
807 * we get rid of our own buffers */
809 if (mutex_lock_interruptible(&ap
->lock
))
811 ppp_output_wakeup(&ap
->chan
);
812 mutex_unlock(&ap
->lock
);
813 #endif /* FLUSH_TO_PPP */
818 DEBUG(FS_INFO
, "FIONREAD\n");
820 if(put_user(val
, (int __user
*)argp
))
826 DERROR(FS_ERROR
, "Unsupported ioctl (0x%X)\n", cmd
);
830 DEXIT(FS_TRACE
, " - err = 0x%X\n", err
);
834 /************************** PPP CALLBACKS **************************/
836 * This are the functions that the generic PPP driver in the kernel
837 * will call to communicate to us.
840 /*------------------------------------------------------------------*/
842 * Prepare the ppp frame for transmission over the IrDA socket.
843 * We make sure that the header space is enough, and we change ppp header
844 * according to flags passed by pppd.
845 * This is not a callback, but just a helper function used in ppp_irnet_send()
847 static inline struct sk_buff
*
848 irnet_prepare_skb(irnet_socket
* ap
,
849 struct sk_buff
* skb
)
851 unsigned char * data
;
852 int proto
; /* PPP protocol */
853 int islcp
; /* Protocol == LCP */
854 int needaddr
; /* Need PPP address */
856 DENTER(PPP_TRACE
, "(ap=0x%p, skb=0x%p)\n",
859 /* Extract PPP protocol from the frame */
861 proto
= (data
[0] << 8) + data
[1];
863 /* LCP packets with codes between 1 (configure-request)
864 * and 7 (code-reject) must be sent as though no options
865 * have been negotiated. */
866 islcp
= (proto
== PPP_LCP
) && (1 <= data
[2]) && (data
[2] <= 7);
868 /* compress protocol field if option enabled */
869 if((data
[0] == 0) && (ap
->flags
& SC_COMP_PROT
) && (!islcp
))
872 /* Check if we need address/control fields */
873 needaddr
= 2*((ap
->flags
& SC_COMP_AC
) == 0 || islcp
);
875 /* Is the skb headroom large enough to contain all IrDA-headers? */
876 if((skb_headroom(skb
) < (ap
->max_header_size
+ needaddr
)) ||
879 struct sk_buff
* new_skb
;
881 DEBUG(PPP_INFO
, "Reallocating skb\n");
883 /* Create a new skb */
884 new_skb
= skb_realloc_headroom(skb
, ap
->max_header_size
+ needaddr
);
886 /* We have to free the original skb anyway */
889 /* Did the realloc succeed ? */
890 DABORT(new_skb
== NULL
, NULL
, PPP_ERROR
, "Could not realloc skb\n");
892 /* Use the new skb instead */
896 /* prepend address/control fields if necessary */
900 skb
->data
[0] = PPP_ALLSTATIONS
;
901 skb
->data
[1] = PPP_UI
;
904 DEXIT(PPP_TRACE
, "\n");
909 /*------------------------------------------------------------------*/
911 * Send a packet to the peer over the IrTTP connection.
912 * Returns 1 iff the packet was accepted.
913 * Returns 0 iff packet was not consumed.
914 * If the packet was not accepted, we will call ppp_output_wakeup
915 * at some later time to reactivate flow control in ppp_generic.
918 ppp_irnet_send(struct ppp_channel
* chan
,
919 struct sk_buff
* skb
)
921 irnet_socket
* self
= (struct irnet_socket
*) chan
->private;
924 DENTER(PPP_TRACE
, "(channel=0x%p, ap/self=0x%p)\n",
927 /* Check if things are somewhat valid... */
928 DASSERT(self
!= NULL
, 0, PPP_ERROR
, "Self is NULL !!!\n");
930 /* Check if we are connected */
931 if(!(test_bit(0, &self
->ttp_open
)))
933 #ifdef CONNECT_IN_SEND
934 /* Let's try to connect one more time... */
935 /* Note : we won't be connected after this call, but we should be
936 * ready for next packet... */
937 /* If we are already connecting, this will fail */
938 irda_irnet_connect(self
);
939 #endif /* CONNECT_IN_SEND */
941 DEBUG(PPP_INFO
, "IrTTP not ready ! (%ld-%ld)\n",
942 self
->ttp_open
, self
->ttp_connect
);
944 /* Note : we can either drop the packet or block the packet.
946 * Blocking the packet allow us a better connection time,
947 * because by calling ppp_output_wakeup() we can have
948 * ppp_generic resending the LCP request immediately to us,
949 * rather than waiting for one of pppd periodic transmission of
952 * On the other hand, if we block all packet, all those periodic
953 * transmissions of pppd accumulate in ppp_generic, creating a
954 * backlog of LCP request. When we eventually connect later on,
955 * we have to transmit all this backlog before we can connect
956 * proper (if we don't timeout before).
958 * The current strategy is as follow :
959 * While we are attempting to connect, we block packets to get
960 * a better connection time.
961 * If we fail to connect, we drain the queue and start dropping packets
963 #ifdef BLOCK_WHEN_CONNECT
964 /* If we are attempting to connect */
965 if(test_bit(0, &self
->ttp_connect
))
967 /* Blocking packet, ppp_generic will retry later */
970 #endif /* BLOCK_WHEN_CONNECT */
972 /* Dropping packet, pppd will retry later */
977 /* Check if the queue can accept any packet, otherwise block */
978 if(self
->tx_flow
!= FLOW_START
)
979 DRETURN(0, PPP_INFO
, "IrTTP queue full (%d skbs)...\n",
980 skb_queue_len(&self
->tsap
->tx_queue
));
982 /* Prepare ppp frame for transmission */
983 skb
= irnet_prepare_skb(self
, skb
);
984 DABORT(skb
== NULL
, 1, PPP_ERROR
, "Prepare skb for Tx failed.\n");
986 /* Send the packet to IrTTP */
987 ret
= irttp_data_request(self
->tsap
, skb
);
991 * > IrTTPs tx queue is full, so we just have to
992 * > drop the frame! You might think that we should
993 * > just return -1 and don't deallocate the frame,
994 * > but that is dangerous since it's possible that
995 * > we have replaced the original skb with a new
996 * > one with larger headroom, and that would really
997 * > confuse do_dev_queue_xmit() in dev.c! I have
999 * Correction : we verify the flow control above (self->tx_flow),
1000 * so we come here only if IrTTP doesn't like the packet (empty,
1001 * too large, IrTTP not connected). In those rare cases, it's ok
1002 * to drop it, we don't want to see it here again...
1005 DERROR(PPP_ERROR
, "IrTTP doesn't like this packet !!! (0x%X)\n", ret
);
1006 /* irttp_data_request already free the packet */
1009 DEXIT(PPP_TRACE
, "\n");
1010 return 1; /* Packet has been consumed */
1013 /*------------------------------------------------------------------*/
1015 * Take care of the ioctls that ppp_generic doesn't want to deal with...
1016 * Note : we are also called from dev_irnet_ioctl().
1019 ppp_irnet_ioctl(struct ppp_channel
* chan
,
1023 irnet_socket
* ap
= (struct irnet_socket
*) chan
->private;
1027 void __user
*argp
= (void __user
*)arg
;
1029 DENTER(PPP_TRACE
, "(channel=0x%p, ap=0x%p, cmd=0x%X)\n",
1032 /* Basic checks... */
1033 DASSERT(ap
!= NULL
, -ENXIO
, PPP_ERROR
, "ap is NULL...\n");
1040 val
= ap
->flags
| ap
->rbits
;
1041 if(put_user(val
, (int __user
*) argp
))
1046 if(get_user(val
, (int __user
*) argp
))
1048 ap
->flags
= val
& ~SC_RCV_BITS
;
1049 ap
->rbits
= val
& SC_RCV_BITS
;
1053 /* Async map stuff - all dummy to please pppd */
1054 case PPPIOCGASYNCMAP
:
1055 if(put_user(ap
->xaccm
[0], (u32 __user
*) argp
))
1059 case PPPIOCSASYNCMAP
:
1060 if(get_user(ap
->xaccm
[0], (u32 __user
*) argp
))
1064 case PPPIOCGRASYNCMAP
:
1065 if(put_user(ap
->raccm
, (u32 __user
*) argp
))
1069 case PPPIOCSRASYNCMAP
:
1070 if(get_user(ap
->raccm
, (u32 __user
*) argp
))
1074 case PPPIOCGXASYNCMAP
:
1075 if(copy_to_user(argp
, ap
->xaccm
, sizeof(ap
->xaccm
)))
1079 case PPPIOCSXASYNCMAP
:
1080 if(copy_from_user(accm
, argp
, sizeof(accm
)))
1082 accm
[2] &= ~0x40000000U
; /* can't escape 0x5e */
1083 accm
[3] |= 0x60000000U
; /* must escape 0x7d, 0x7e */
1084 memcpy(ap
->xaccm
, accm
, sizeof(ap
->xaccm
));
1088 /* Max PPP frame size */
1090 if(put_user(ap
->mru
, (int __user
*) argp
))
1095 if(get_user(val
, (int __user
*) argp
))
1104 DEBUG(PPP_INFO
, "Unsupported ioctl (0x%X)\n", cmd
);
1108 DEXIT(PPP_TRACE
, " - err = 0x%X\n", err
);
1112 /************************** INITIALISATION **************************/
1114 * Module initialisation and all that jazz...
1117 /*------------------------------------------------------------------*/
1119 * Hook our device callbacks in the filesystem, to connect our code
1122 static inline int __init
1123 ppp_irnet_init(void)
1127 DENTER(MODULE_TRACE
, "()\n");
1129 /* Allocate ourselves as a minor in the misc range */
1130 err
= misc_register(&irnet_misc_device
);
1132 DEXIT(MODULE_TRACE
, "\n");
1136 /*------------------------------------------------------------------*/
1138 * Cleanup at exit...
1140 static inline void __exit
1141 ppp_irnet_cleanup(void)
1143 DENTER(MODULE_TRACE
, "()\n");
1145 /* De-allocate /dev/irnet minor in misc range */
1146 misc_deregister(&irnet_misc_device
);
1148 DEXIT(MODULE_TRACE
, "\n");
1151 /*------------------------------------------------------------------*/
1153 * Module main entry point
1160 /* Initialise both parts... */
1161 err
= irda_irnet_init();
1163 err
= ppp_irnet_init();
1167 /*------------------------------------------------------------------*/
1174 irda_irnet_cleanup();
1175 ppp_irnet_cleanup();
1178 /*------------------------------------------------------------------*/
1182 module_init(irnet_init
);
1183 module_exit(irnet_cleanup
);
1184 MODULE_AUTHOR("Jean Tourrilhes <jt@hpl.hp.com>");
1185 MODULE_DESCRIPTION("IrNET : Synchronous PPP over IrDA");
1186 MODULE_LICENSE("GPL");
1187 MODULE_ALIAS_CHARDEV(10, 187);