xref: /openbmc/linux/drivers/tty/n_hdlc.c (revision aac5987a)
1 /* generic HDLC line discipline for Linux
2  *
3  * Written by Paul Fulghum paulkf@microgate.com
4  * for Microgate Corporation
5  *
6  * Microgate and SyncLink are registered trademarks of Microgate Corporation
7  *
8  * Adapted from ppp.c, written by Michael Callahan <callahan@maths.ox.ac.uk>,
9  *	Al Longyear <longyear@netcom.com>,
10  *	Paul Mackerras <Paul.Mackerras@cs.anu.edu.au>
11  *
12  * Original release 01/11/99
13  *
14  * This code is released under the GNU General Public License (GPL)
15  *
16  * This module implements the tty line discipline N_HDLC for use with
17  * tty device drivers that support bit-synchronous HDLC communications.
18  *
19  * All HDLC data is frame oriented which means:
20  *
21  * 1. tty write calls represent one complete transmit frame of data
22  *    The device driver should accept the complete frame or none of
23  *    the frame (busy) in the write method. Each write call should have
24  *    a byte count in the range of 2-65535 bytes (2 is min HDLC frame
25  *    with 1 addr byte and 1 ctrl byte). The max byte count of 65535
26  *    should include any crc bytes required. For example, when using
27  *    CCITT CRC32, 4 crc bytes are required, so the maximum size frame
28  *    the application may transmit is limited to 65531 bytes. For CCITT
29  *    CRC16, the maximum application frame size would be 65533.
30  *
31  *
32  * 2. receive callbacks from the device driver represents
33  *    one received frame. The device driver should bypass
34  *    the tty flip buffer and call the line discipline receive
35  *    callback directly to avoid fragmenting or concatenating
36  *    multiple frames into a single receive callback.
37  *
38  *    The HDLC line discipline queues the receive frames in separate
39  *    buffers so complete receive frames can be returned by the
40  *    tty read calls.
41  *
42  * 3. tty read calls returns an entire frame of data or nothing.
43  *
44  * 4. all send and receive data is considered raw. No processing
45  *    or translation is performed by the line discipline, regardless
46  *    of the tty flags
47  *
48  * 5. When line discipline is queried for the amount of receive
49  *    data available (FIOC), 0 is returned if no data available,
50  *    otherwise the count of the next available frame is returned.
51  *    (instead of the sum of all received frame counts).
52  *
53  * These conventions allow the standard tty programming interface
54  * to be used for synchronous HDLC applications when used with
55  * this line discipline (or another line discipline that is frame
56  * oriented such as N_PPP).
57  *
58  * The SyncLink driver (synclink.c) implements both asynchronous
59  * (using standard line discipline N_TTY) and synchronous HDLC
60  * (using N_HDLC) communications, with the latter using the above
61  * conventions.
62  *
63  * This implementation is very basic and does not maintain
64  * any statistics. The main point is to enforce the raw data
65  * and frame orientation of HDLC communications.
66  *
67  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
68  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
69  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
70  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
71  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
72  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
73  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
74  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
75  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
76  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
77  * OF THE POSSIBILITY OF SUCH DAMAGE.
78  */
79 
80 #define HDLC_MAGIC 0x239e
81 
82 #include <linux/module.h>
83 #include <linux/init.h>
84 #include <linux/kernel.h>
85 #include <linux/sched.h>
86 #include <linux/types.h>
87 #include <linux/fcntl.h>
88 #include <linux/interrupt.h>
89 #include <linux/ptrace.h>
90 
91 #undef VERSION
92 #define VERSION(major,minor,patch) (((((major)<<8)+(minor))<<8)+(patch))
93 
94 #include <linux/poll.h>
95 #include <linux/in.h>
96 #include <linux/ioctl.h>
97 #include <linux/slab.h>
98 #include <linux/tty.h>
99 #include <linux/errno.h>
100 #include <linux/string.h>	/* used in new tty drivers */
101 #include <linux/signal.h>	/* used in new tty drivers */
102 #include <linux/if.h>
103 #include <linux/bitops.h>
104 
105 #include <asm/termios.h>
106 #include <linux/uaccess.h>
107 
108 /*
109  * Buffers for individual HDLC frames
110  */
111 #define MAX_HDLC_FRAME_SIZE 65535
112 #define DEFAULT_RX_BUF_COUNT 10
113 #define MAX_RX_BUF_COUNT 60
114 #define DEFAULT_TX_BUF_COUNT 3
115 
116 struct n_hdlc_buf {
117 	struct n_hdlc_buf *link;
118 	int		  count;
119 	char		  buf[1];
120 };
121 
122 #define	N_HDLC_BUF_SIZE	(sizeof(struct n_hdlc_buf) + maxframe)
123 
124 struct n_hdlc_buf_list {
125 	struct n_hdlc_buf *head;
126 	struct n_hdlc_buf *tail;
127 	int		  count;
128 	spinlock_t	  spinlock;
129 };
130 
131 /**
132  * struct n_hdlc - per device instance data structure
133  * @magic - magic value for structure
134  * @flags - miscellaneous control flags
135  * @tty - ptr to TTY structure
136  * @backup_tty - TTY to use if tty gets closed
137  * @tbusy - reentrancy flag for tx wakeup code
138  * @woke_up - FIXME: describe this field
139  * @tbuf - currently transmitting tx buffer
140  * @tx_buf_list - list of pending transmit frame buffers
141  * @rx_buf_list - list of received frame buffers
142  * @tx_free_buf_list - list unused transmit frame buffers
143  * @rx_free_buf_list - list unused received frame buffers
144  */
145 struct n_hdlc {
146 	int			magic;
147 	__u32			flags;
148 	struct tty_struct	*tty;
149 	struct tty_struct	*backup_tty;
150 	int			tbusy;
151 	int			woke_up;
152 	struct n_hdlc_buf	*tbuf;
153 	struct n_hdlc_buf_list	tx_buf_list;
154 	struct n_hdlc_buf_list	rx_buf_list;
155 	struct n_hdlc_buf_list	tx_free_buf_list;
156 	struct n_hdlc_buf_list	rx_free_buf_list;
157 };
158 
159 /*
160  * HDLC buffer list manipulation functions
161  */
162 static void n_hdlc_buf_put(struct n_hdlc_buf_list *list,
163 			   struct n_hdlc_buf *buf);
164 static struct n_hdlc_buf *n_hdlc_buf_get(struct n_hdlc_buf_list *list);
165 
166 /* Local functions */
167 
168 static struct n_hdlc *n_hdlc_alloc (void);
169 
170 /* debug level can be set by insmod for debugging purposes */
171 #define DEBUG_LEVEL_INFO	1
172 static int debuglevel;
173 
174 /* max frame size for memory allocations */
175 static int maxframe = 4096;
176 
177 /* TTY callbacks */
178 
179 static ssize_t n_hdlc_tty_read(struct tty_struct *tty, struct file *file,
180 			   __u8 __user *buf, size_t nr);
181 static ssize_t n_hdlc_tty_write(struct tty_struct *tty, struct file *file,
182 			    const unsigned char *buf, size_t nr);
183 static int n_hdlc_tty_ioctl(struct tty_struct *tty, struct file *file,
184 			    unsigned int cmd, unsigned long arg);
185 static unsigned int n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp,
186 				    poll_table *wait);
187 static int n_hdlc_tty_open(struct tty_struct *tty);
188 static void n_hdlc_tty_close(struct tty_struct *tty);
189 static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *cp,
190 			       char *fp, int count);
191 static void n_hdlc_tty_wakeup(struct tty_struct *tty);
192 
193 #define bset(p,b)	((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
194 
195 #define tty2n_hdlc(tty)	((struct n_hdlc *) ((tty)->disc_data))
196 #define n_hdlc2tty(n_hdlc)	((n_hdlc)->tty)
197 
198 static void flush_rx_queue(struct tty_struct *tty)
199 {
200 	struct n_hdlc *n_hdlc = tty2n_hdlc(tty);
201 	struct n_hdlc_buf *buf;
202 
203 	while ((buf = n_hdlc_buf_get(&n_hdlc->rx_buf_list)))
204 		n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, buf);
205 }
206 
207 static void flush_tx_queue(struct tty_struct *tty)
208 {
209 	struct n_hdlc *n_hdlc = tty2n_hdlc(tty);
210 	struct n_hdlc_buf *buf;
211 	unsigned long flags;
212 
213 	while ((buf = n_hdlc_buf_get(&n_hdlc->tx_buf_list)))
214 		n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, buf);
215  	spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags);
216 	if (n_hdlc->tbuf) {
217 		n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, n_hdlc->tbuf);
218 		n_hdlc->tbuf = NULL;
219 	}
220 	spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);
221 }
222 
223 static struct tty_ldisc_ops n_hdlc_ldisc = {
224 	.owner		= THIS_MODULE,
225 	.magic		= TTY_LDISC_MAGIC,
226 	.name		= "hdlc",
227 	.open		= n_hdlc_tty_open,
228 	.close		= n_hdlc_tty_close,
229 	.read		= n_hdlc_tty_read,
230 	.write		= n_hdlc_tty_write,
231 	.ioctl		= n_hdlc_tty_ioctl,
232 	.poll		= n_hdlc_tty_poll,
233 	.receive_buf	= n_hdlc_tty_receive,
234 	.write_wakeup	= n_hdlc_tty_wakeup,
235 	.flush_buffer   = flush_rx_queue,
236 };
237 
238 /**
239  * n_hdlc_release - release an n_hdlc per device line discipline info structure
240  * @n_hdlc - per device line discipline info structure
241  */
242 static void n_hdlc_release(struct n_hdlc *n_hdlc)
243 {
244 	struct tty_struct *tty = n_hdlc2tty (n_hdlc);
245 	struct n_hdlc_buf *buf;
246 
247 	if (debuglevel >= DEBUG_LEVEL_INFO)
248 		printk("%s(%d)n_hdlc_release() called\n",__FILE__,__LINE__);
249 
250 	/* Ensure that the n_hdlcd process is not hanging on select()/poll() */
251 	wake_up_interruptible (&tty->read_wait);
252 	wake_up_interruptible (&tty->write_wait);
253 
254 	if (tty->disc_data == n_hdlc)
255 		tty->disc_data = NULL;	/* Break the tty->n_hdlc link */
256 
257 	/* Release transmit and receive buffers */
258 	for(;;) {
259 		buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list);
260 		if (buf) {
261 			kfree(buf);
262 		} else
263 			break;
264 	}
265 	for(;;) {
266 		buf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list);
267 		if (buf) {
268 			kfree(buf);
269 		} else
270 			break;
271 	}
272 	for(;;) {
273 		buf = n_hdlc_buf_get(&n_hdlc->rx_buf_list);
274 		if (buf) {
275 			kfree(buf);
276 		} else
277 			break;
278 	}
279 	for(;;) {
280 		buf = n_hdlc_buf_get(&n_hdlc->tx_buf_list);
281 		if (buf) {
282 			kfree(buf);
283 		} else
284 			break;
285 	}
286 	kfree(n_hdlc->tbuf);
287 	kfree(n_hdlc);
288 
289 }	/* end of n_hdlc_release() */
290 
291 /**
292  * n_hdlc_tty_close - line discipline close
293  * @tty - pointer to tty info structure
294  *
295  * Called when the line discipline is changed to something
296  * else, the tty is closed, or the tty detects a hangup.
297  */
298 static void n_hdlc_tty_close(struct tty_struct *tty)
299 {
300 	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
301 
302 	if (debuglevel >= DEBUG_LEVEL_INFO)
303 		printk("%s(%d)n_hdlc_tty_close() called\n",__FILE__,__LINE__);
304 
305 	if (n_hdlc != NULL) {
306 		if (n_hdlc->magic != HDLC_MAGIC) {
307 			printk (KERN_WARNING"n_hdlc: trying to close unopened tty!\n");
308 			return;
309 		}
310 #if defined(TTY_NO_WRITE_SPLIT)
311 		clear_bit(TTY_NO_WRITE_SPLIT,&tty->flags);
312 #endif
313 		tty->disc_data = NULL;
314 		if (tty == n_hdlc->backup_tty)
315 			n_hdlc->backup_tty = NULL;
316 		if (tty != n_hdlc->tty)
317 			return;
318 		if (n_hdlc->backup_tty) {
319 			n_hdlc->tty = n_hdlc->backup_tty;
320 		} else {
321 			n_hdlc_release (n_hdlc);
322 		}
323 	}
324 
325 	if (debuglevel >= DEBUG_LEVEL_INFO)
326 		printk("%s(%d)n_hdlc_tty_close() success\n",__FILE__,__LINE__);
327 
328 }	/* end of n_hdlc_tty_close() */
329 
330 /**
331  * n_hdlc_tty_open - called when line discipline changed to n_hdlc
332  * @tty - pointer to tty info structure
333  *
334  * Returns 0 if success, otherwise error code
335  */
336 static int n_hdlc_tty_open (struct tty_struct *tty)
337 {
338 	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
339 
340 	if (debuglevel >= DEBUG_LEVEL_INFO)
341 		printk("%s(%d)n_hdlc_tty_open() called (device=%s)\n",
342 		__FILE__,__LINE__,
343 		tty->name);
344 
345 	/* There should not be an existing table for this slot. */
346 	if (n_hdlc) {
347 		printk (KERN_ERR"n_hdlc_tty_open:tty already associated!\n" );
348 		return -EEXIST;
349 	}
350 
351 	n_hdlc = n_hdlc_alloc();
352 	if (!n_hdlc) {
353 		printk (KERN_ERR "n_hdlc_alloc failed\n");
354 		return -ENFILE;
355 	}
356 
357 	tty->disc_data = n_hdlc;
358 	n_hdlc->tty    = tty;
359 	tty->receive_room = 65536;
360 
361 #if defined(TTY_NO_WRITE_SPLIT)
362 	/* change tty_io write() to not split large writes into 8K chunks */
363 	set_bit(TTY_NO_WRITE_SPLIT,&tty->flags);
364 #endif
365 
366 	/* flush receive data from driver */
367 	tty_driver_flush_buffer(tty);
368 
369 	if (debuglevel >= DEBUG_LEVEL_INFO)
370 		printk("%s(%d)n_hdlc_tty_open() success\n",__FILE__,__LINE__);
371 
372 	return 0;
373 
374 }	/* end of n_tty_hdlc_open() */
375 
376 /**
377  * n_hdlc_send_frames - send frames on pending send buffer list
378  * @n_hdlc - pointer to ldisc instance data
379  * @tty - pointer to tty instance data
380  *
381  * Send frames on pending send buffer list until the driver does not accept a
382  * frame (busy) this function is called after adding a frame to the send buffer
383  * list and by the tty wakeup callback.
384  */
385 static void n_hdlc_send_frames(struct n_hdlc *n_hdlc, struct tty_struct *tty)
386 {
387 	register int actual;
388 	unsigned long flags;
389 	struct n_hdlc_buf *tbuf;
390 
391 	if (debuglevel >= DEBUG_LEVEL_INFO)
392 		printk("%s(%d)n_hdlc_send_frames() called\n",__FILE__,__LINE__);
393  check_again:
394 
395  	spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags);
396 	if (n_hdlc->tbusy) {
397 		n_hdlc->woke_up = 1;
398  		spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);
399 		return;
400 	}
401 	n_hdlc->tbusy = 1;
402 	n_hdlc->woke_up = 0;
403 	spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);
404 
405 	/* get current transmit buffer or get new transmit */
406 	/* buffer from list of pending transmit buffers */
407 
408 	tbuf = n_hdlc->tbuf;
409 	if (!tbuf)
410 		tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list);
411 
412 	while (tbuf) {
413 		if (debuglevel >= DEBUG_LEVEL_INFO)
414 			printk("%s(%d)sending frame %p, count=%d\n",
415 				__FILE__,__LINE__,tbuf,tbuf->count);
416 
417 		/* Send the next block of data to device */
418 		set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
419 		actual = tty->ops->write(tty, tbuf->buf, tbuf->count);
420 
421 		/* rollback was possible and has been done */
422 		if (actual == -ERESTARTSYS) {
423 			n_hdlc->tbuf = tbuf;
424 			break;
425 		}
426 		/* if transmit error, throw frame away by */
427 		/* pretending it was accepted by driver */
428 		if (actual < 0)
429 			actual = tbuf->count;
430 
431 		if (actual == tbuf->count) {
432 			if (debuglevel >= DEBUG_LEVEL_INFO)
433 				printk("%s(%d)frame %p completed\n",
434 					__FILE__,__LINE__,tbuf);
435 
436 			/* free current transmit buffer */
437 			n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, tbuf);
438 
439 			/* this tx buffer is done */
440 			n_hdlc->tbuf = NULL;
441 
442 			/* wait up sleeping writers */
443 			wake_up_interruptible(&tty->write_wait);
444 
445 			/* get next pending transmit buffer */
446 			tbuf = n_hdlc_buf_get(&n_hdlc->tx_buf_list);
447 		} else {
448 			if (debuglevel >= DEBUG_LEVEL_INFO)
449 				printk("%s(%d)frame %p pending\n",
450 					__FILE__,__LINE__,tbuf);
451 
452 			/* buffer not accepted by driver */
453 			/* set this buffer as pending buffer */
454 			n_hdlc->tbuf = tbuf;
455 			break;
456 		}
457 	}
458 
459 	if (!tbuf)
460 		clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
461 
462 	/* Clear the re-entry flag */
463 	spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags);
464 	n_hdlc->tbusy = 0;
465 	spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);
466 
467         if (n_hdlc->woke_up)
468 	  goto check_again;
469 
470 	if (debuglevel >= DEBUG_LEVEL_INFO)
471 		printk("%s(%d)n_hdlc_send_frames() exit\n",__FILE__,__LINE__);
472 
473 }	/* end of n_hdlc_send_frames() */
474 
475 /**
476  * n_hdlc_tty_wakeup - Callback for transmit wakeup
477  * @tty	- pointer to associated tty instance data
478  *
479  * Called when low level device driver can accept more send data.
480  */
481 static void n_hdlc_tty_wakeup(struct tty_struct *tty)
482 {
483 	struct n_hdlc *n_hdlc = tty2n_hdlc(tty);
484 
485 	if (debuglevel >= DEBUG_LEVEL_INFO)
486 		printk("%s(%d)n_hdlc_tty_wakeup() called\n",__FILE__,__LINE__);
487 
488 	if (!n_hdlc)
489 		return;
490 
491 	if (tty != n_hdlc->tty) {
492 		clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
493 		return;
494 	}
495 
496 	n_hdlc_send_frames (n_hdlc, tty);
497 
498 }	/* end of n_hdlc_tty_wakeup() */
499 
500 /**
501  * n_hdlc_tty_receive - Called by tty driver when receive data is available
502  * @tty	- pointer to tty instance data
503  * @data - pointer to received data
504  * @flags - pointer to flags for data
505  * @count - count of received data in bytes
506  *
507  * Called by tty low level driver when receive data is available. Data is
508  * interpreted as one HDLC frame.
509  */
510 static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *data,
511 			       char *flags, int count)
512 {
513 	register struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
514 	register struct n_hdlc_buf *buf;
515 
516 	if (debuglevel >= DEBUG_LEVEL_INFO)
517 		printk("%s(%d)n_hdlc_tty_receive() called count=%d\n",
518 			__FILE__,__LINE__, count);
519 
520 	/* This can happen if stuff comes in on the backup tty */
521 	if (!n_hdlc || tty != n_hdlc->tty)
522 		return;
523 
524 	/* verify line is using HDLC discipline */
525 	if (n_hdlc->magic != HDLC_MAGIC) {
526 		printk("%s(%d) line not using HDLC discipline\n",
527 			__FILE__,__LINE__);
528 		return;
529 	}
530 
531 	if ( count>maxframe ) {
532 		if (debuglevel >= DEBUG_LEVEL_INFO)
533 			printk("%s(%d) rx count>maxframesize, data discarded\n",
534 			       __FILE__,__LINE__);
535 		return;
536 	}
537 
538 	/* get a free HDLC buffer */
539 	buf = n_hdlc_buf_get(&n_hdlc->rx_free_buf_list);
540 	if (!buf) {
541 		/* no buffers in free list, attempt to allocate another rx buffer */
542 		/* unless the maximum count has been reached */
543 		if (n_hdlc->rx_buf_list.count < MAX_RX_BUF_COUNT)
544 			buf = kmalloc(N_HDLC_BUF_SIZE, GFP_ATOMIC);
545 	}
546 
547 	if (!buf) {
548 		if (debuglevel >= DEBUG_LEVEL_INFO)
549 			printk("%s(%d) no more rx buffers, data discarded\n",
550 			       __FILE__,__LINE__);
551 		return;
552 	}
553 
554 	/* copy received data to HDLC buffer */
555 	memcpy(buf->buf,data,count);
556 	buf->count=count;
557 
558 	/* add HDLC buffer to list of received frames */
559 	n_hdlc_buf_put(&n_hdlc->rx_buf_list, buf);
560 
561 	/* wake up any blocked reads and perform async signalling */
562 	wake_up_interruptible (&tty->read_wait);
563 	if (n_hdlc->tty->fasync != NULL)
564 		kill_fasync (&n_hdlc->tty->fasync, SIGIO, POLL_IN);
565 
566 }	/* end of n_hdlc_tty_receive() */
567 
568 /**
569  * n_hdlc_tty_read - Called to retrieve one frame of data (if available)
570  * @tty - pointer to tty instance data
571  * @file - pointer to open file object
572  * @buf - pointer to returned data buffer
573  * @nr - size of returned data buffer
574  *
575  * Returns the number of bytes returned or error code.
576  */
577 static ssize_t n_hdlc_tty_read(struct tty_struct *tty, struct file *file,
578 			   __u8 __user *buf, size_t nr)
579 {
580 	struct n_hdlc *n_hdlc = tty2n_hdlc(tty);
581 	int ret = 0;
582 	struct n_hdlc_buf *rbuf;
583 	DECLARE_WAITQUEUE(wait, current);
584 
585 	if (debuglevel >= DEBUG_LEVEL_INFO)
586 		printk("%s(%d)n_hdlc_tty_read() called\n",__FILE__,__LINE__);
587 
588 	/* Validate the pointers */
589 	if (!n_hdlc)
590 		return -EIO;
591 
592 	/* verify user access to buffer */
593 	if (!access_ok(VERIFY_WRITE, buf, nr)) {
594 		printk(KERN_WARNING "%s(%d) n_hdlc_tty_read() can't verify user "
595 		"buffer\n", __FILE__, __LINE__);
596 		return -EFAULT;
597 	}
598 
599 	add_wait_queue(&tty->read_wait, &wait);
600 
601 	for (;;) {
602 		if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
603 			ret = -EIO;
604 			break;
605 		}
606 		if (tty_hung_up_p(file))
607 			break;
608 
609 		set_current_state(TASK_INTERRUPTIBLE);
610 
611 		rbuf = n_hdlc_buf_get(&n_hdlc->rx_buf_list);
612 		if (rbuf) {
613 			if (rbuf->count > nr) {
614 				/* too large for caller's buffer */
615 				ret = -EOVERFLOW;
616 			} else {
617 				if (copy_to_user(buf, rbuf->buf, rbuf->count))
618 					ret = -EFAULT;
619 				else
620 					ret = rbuf->count;
621 			}
622 
623 			if (n_hdlc->rx_free_buf_list.count >
624 			    DEFAULT_RX_BUF_COUNT)
625 				kfree(rbuf);
626 			else
627 				n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, rbuf);
628 			break;
629 		}
630 
631 		/* no data */
632 		if (file->f_flags & O_NONBLOCK) {
633 			ret = -EAGAIN;
634 			break;
635 		}
636 
637 		schedule();
638 
639 		if (signal_pending(current)) {
640 			ret = -EINTR;
641 			break;
642 		}
643 	}
644 
645 	remove_wait_queue(&tty->read_wait, &wait);
646 	__set_current_state(TASK_RUNNING);
647 
648 	return ret;
649 
650 }	/* end of n_hdlc_tty_read() */
651 
652 /**
653  * n_hdlc_tty_write - write a single frame of data to device
654  * @tty	- pointer to associated tty device instance data
655  * @file - pointer to file object data
656  * @data - pointer to transmit data (one frame)
657  * @count - size of transmit frame in bytes
658  *
659  * Returns the number of bytes written (or error code).
660  */
661 static ssize_t n_hdlc_tty_write(struct tty_struct *tty, struct file *file,
662 			    const unsigned char *data, size_t count)
663 {
664 	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
665 	int error = 0;
666 	DECLARE_WAITQUEUE(wait, current);
667 	struct n_hdlc_buf *tbuf;
668 
669 	if (debuglevel >= DEBUG_LEVEL_INFO)
670 		printk("%s(%d)n_hdlc_tty_write() called count=%zd\n",
671 			__FILE__,__LINE__,count);
672 
673 	/* Verify pointers */
674 	if (!n_hdlc)
675 		return -EIO;
676 
677 	if (n_hdlc->magic != HDLC_MAGIC)
678 		return -EIO;
679 
680 	/* verify frame size */
681 	if (count > maxframe ) {
682 		if (debuglevel & DEBUG_LEVEL_INFO)
683 			printk (KERN_WARNING
684 				"n_hdlc_tty_write: truncating user packet "
685 				"from %lu to %d\n", (unsigned long) count,
686 				maxframe );
687 		count = maxframe;
688 	}
689 
690 	add_wait_queue(&tty->write_wait, &wait);
691 
692 	for (;;) {
693 		set_current_state(TASK_INTERRUPTIBLE);
694 
695 		tbuf = n_hdlc_buf_get(&n_hdlc->tx_free_buf_list);
696 		if (tbuf)
697 			break;
698 
699 		if (file->f_flags & O_NONBLOCK) {
700 			error = -EAGAIN;
701 			break;
702 		}
703 		schedule();
704 
705 		n_hdlc = tty2n_hdlc (tty);
706 		if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC ||
707 		    tty != n_hdlc->tty) {
708 			printk("n_hdlc_tty_write: %p invalid after wait!\n", n_hdlc);
709 			error = -EIO;
710 			break;
711 		}
712 
713 		if (signal_pending(current)) {
714 			error = -EINTR;
715 			break;
716 		}
717 	}
718 
719 	__set_current_state(TASK_RUNNING);
720 	remove_wait_queue(&tty->write_wait, &wait);
721 
722 	if (!error) {
723 		/* Retrieve the user's buffer */
724 		memcpy(tbuf->buf, data, count);
725 
726 		/* Send the data */
727 		tbuf->count = error = count;
728 		n_hdlc_buf_put(&n_hdlc->tx_buf_list,tbuf);
729 		n_hdlc_send_frames(n_hdlc,tty);
730 	}
731 
732 	return error;
733 
734 }	/* end of n_hdlc_tty_write() */
735 
736 /**
737  * n_hdlc_tty_ioctl - process IOCTL system call for the tty device.
738  * @tty - pointer to tty instance data
739  * @file - pointer to open file object for device
740  * @cmd - IOCTL command code
741  * @arg - argument for IOCTL call (cmd dependent)
742  *
743  * Returns command dependent result.
744  */
745 static int n_hdlc_tty_ioctl(struct tty_struct *tty, struct file *file,
746 			    unsigned int cmd, unsigned long arg)
747 {
748 	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
749 	int error = 0;
750 	int count;
751 	unsigned long flags;
752 
753 	if (debuglevel >= DEBUG_LEVEL_INFO)
754 		printk("%s(%d)n_hdlc_tty_ioctl() called %d\n",
755 			__FILE__,__LINE__,cmd);
756 
757 	/* Verify the status of the device */
758 	if (!n_hdlc || n_hdlc->magic != HDLC_MAGIC)
759 		return -EBADF;
760 
761 	switch (cmd) {
762 	case FIONREAD:
763 		/* report count of read data available */
764 		/* in next available frame (if any) */
765 		spin_lock_irqsave(&n_hdlc->rx_buf_list.spinlock,flags);
766 		if (n_hdlc->rx_buf_list.head)
767 			count = n_hdlc->rx_buf_list.head->count;
768 		else
769 			count = 0;
770 		spin_unlock_irqrestore(&n_hdlc->rx_buf_list.spinlock,flags);
771 		error = put_user(count, (int __user *)arg);
772 		break;
773 
774 	case TIOCOUTQ:
775 		/* get the pending tx byte count in the driver */
776 		count = tty_chars_in_buffer(tty);
777 		/* add size of next output frame in queue */
778 		spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock,flags);
779 		if (n_hdlc->tx_buf_list.head)
780 			count += n_hdlc->tx_buf_list.head->count;
781 		spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock,flags);
782 		error = put_user(count, (int __user *)arg);
783 		break;
784 
785 	case TCFLSH:
786 		switch (arg) {
787 		case TCIOFLUSH:
788 		case TCOFLUSH:
789 			flush_tx_queue(tty);
790 		}
791 		/* fall through to default */
792 
793 	default:
794 		error = n_tty_ioctl_helper(tty, file, cmd, arg);
795 		break;
796 	}
797 	return error;
798 
799 }	/* end of n_hdlc_tty_ioctl() */
800 
801 /**
802  * n_hdlc_tty_poll - TTY callback for poll system call
803  * @tty - pointer to tty instance data
804  * @filp - pointer to open file object for device
805  * @poll_table - wait queue for operations
806  *
807  * Determine which operations (read/write) will not block and return info
808  * to caller.
809  * Returns a bit mask containing info on which ops will not block.
810  */
811 static unsigned int n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp,
812 				    poll_table *wait)
813 {
814 	struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
815 	unsigned int mask = 0;
816 
817 	if (debuglevel >= DEBUG_LEVEL_INFO)
818 		printk("%s(%d)n_hdlc_tty_poll() called\n",__FILE__,__LINE__);
819 
820 	if (n_hdlc && n_hdlc->magic == HDLC_MAGIC && tty == n_hdlc->tty) {
821 		/* queue current process into any wait queue that */
822 		/* may awaken in the future (read and write) */
823 
824 		poll_wait(filp, &tty->read_wait, wait);
825 		poll_wait(filp, &tty->write_wait, wait);
826 
827 		/* set bits for operations that won't block */
828 		if (n_hdlc->rx_buf_list.head)
829 			mask |= POLLIN | POLLRDNORM;	/* readable */
830 		if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
831 			mask |= POLLHUP;
832 		if (tty_hung_up_p(filp))
833 			mask |= POLLHUP;
834 		if (!tty_is_writelocked(tty) &&
835 				n_hdlc->tx_free_buf_list.head)
836 			mask |= POLLOUT | POLLWRNORM;	/* writable */
837 	}
838 	return mask;
839 }	/* end of n_hdlc_tty_poll() */
840 
841 /**
842  * n_hdlc_alloc - allocate an n_hdlc instance data structure
843  *
844  * Returns a pointer to newly created structure if success, otherwise %NULL
845  */
846 static struct n_hdlc *n_hdlc_alloc(void)
847 {
848 	struct n_hdlc_buf *buf;
849 	int i;
850 	struct n_hdlc *n_hdlc = kzalloc(sizeof(*n_hdlc), GFP_KERNEL);
851 
852 	if (!n_hdlc)
853 		return NULL;
854 
855 	spin_lock_init(&n_hdlc->rx_free_buf_list.spinlock);
856 	spin_lock_init(&n_hdlc->tx_free_buf_list.spinlock);
857 	spin_lock_init(&n_hdlc->rx_buf_list.spinlock);
858 	spin_lock_init(&n_hdlc->tx_buf_list.spinlock);
859 
860 	/* allocate free rx buffer list */
861 	for(i=0;i<DEFAULT_RX_BUF_COUNT;i++) {
862 		buf = kmalloc(N_HDLC_BUF_SIZE, GFP_KERNEL);
863 		if (buf)
864 			n_hdlc_buf_put(&n_hdlc->rx_free_buf_list,buf);
865 		else if (debuglevel >= DEBUG_LEVEL_INFO)
866 			printk("%s(%d)n_hdlc_alloc(), kalloc() failed for rx buffer %d\n",__FILE__,__LINE__, i);
867 	}
868 
869 	/* allocate free tx buffer list */
870 	for(i=0;i<DEFAULT_TX_BUF_COUNT;i++) {
871 		buf = kmalloc(N_HDLC_BUF_SIZE, GFP_KERNEL);
872 		if (buf)
873 			n_hdlc_buf_put(&n_hdlc->tx_free_buf_list,buf);
874 		else if (debuglevel >= DEBUG_LEVEL_INFO)
875 			printk("%s(%d)n_hdlc_alloc(), kalloc() failed for tx buffer %d\n",__FILE__,__LINE__, i);
876 	}
877 
878 	/* Initialize the control block */
879 	n_hdlc->magic  = HDLC_MAGIC;
880 	n_hdlc->flags  = 0;
881 
882 	return n_hdlc;
883 
884 }	/* end of n_hdlc_alloc() */
885 
886 /**
887  * n_hdlc_buf_put - add specified HDLC buffer to tail of specified list
888  * @list - pointer to buffer list
889  * @buf	- pointer to buffer
890  */
891 static void n_hdlc_buf_put(struct n_hdlc_buf_list *list,
892 			   struct n_hdlc_buf *buf)
893 {
894 	unsigned long flags;
895 	spin_lock_irqsave(&list->spinlock,flags);
896 
897 	buf->link=NULL;
898 	if (list->tail)
899 		list->tail->link = buf;
900 	else
901 		list->head = buf;
902 	list->tail = buf;
903 	(list->count)++;
904 
905 	spin_unlock_irqrestore(&list->spinlock,flags);
906 
907 }	/* end of n_hdlc_buf_put() */
908 
909 /**
910  * n_hdlc_buf_get - remove and return an HDLC buffer from list
911  * @list - pointer to HDLC buffer list
912  *
913  * Remove and return an HDLC buffer from the head of the specified HDLC buffer
914  * list.
915  * Returns a pointer to HDLC buffer if available, otherwise %NULL.
916  */
917 static struct n_hdlc_buf* n_hdlc_buf_get(struct n_hdlc_buf_list *list)
918 {
919 	unsigned long flags;
920 	struct n_hdlc_buf *buf;
921 	spin_lock_irqsave(&list->spinlock,flags);
922 
923 	buf = list->head;
924 	if (buf) {
925 		list->head = buf->link;
926 		(list->count)--;
927 	}
928 	if (!list->head)
929 		list->tail = NULL;
930 
931 	spin_unlock_irqrestore(&list->spinlock,flags);
932 	return buf;
933 
934 }	/* end of n_hdlc_buf_get() */
935 
936 static char hdlc_banner[] __initdata =
937 	KERN_INFO "HDLC line discipline maxframe=%u\n";
938 static char hdlc_register_ok[] __initdata =
939 	KERN_INFO "N_HDLC line discipline registered.\n";
940 static char hdlc_register_fail[] __initdata =
941 	KERN_ERR "error registering line discipline: %d\n";
942 
943 static int __init n_hdlc_init(void)
944 {
945 	int status;
946 
947 	/* range check maxframe arg */
948 	if (maxframe < 4096)
949 		maxframe = 4096;
950 	else if (maxframe > 65535)
951 		maxframe = 65535;
952 
953 	printk(hdlc_banner, maxframe);
954 
955 	status = tty_register_ldisc(N_HDLC, &n_hdlc_ldisc);
956 	if (!status)
957 		printk(hdlc_register_ok);
958 	else
959 		printk(hdlc_register_fail, status);
960 
961 	return status;
962 
963 }	/* end of init_module() */
964 
965 static char hdlc_unregister_ok[] __exitdata =
966 	KERN_INFO "N_HDLC: line discipline unregistered\n";
967 static char hdlc_unregister_fail[] __exitdata =
968 	KERN_ERR "N_HDLC: can't unregister line discipline (err = %d)\n";
969 
970 static void __exit n_hdlc_exit(void)
971 {
972 	/* Release tty registration of line discipline */
973 	int status = tty_unregister_ldisc(N_HDLC);
974 
975 	if (status)
976 		printk(hdlc_unregister_fail, status);
977 	else
978 		printk(hdlc_unregister_ok);
979 }
980 
981 module_init(n_hdlc_init);
982 module_exit(n_hdlc_exit);
983 
984 MODULE_LICENSE("GPL");
985 MODULE_AUTHOR("Paul Fulghum paulkf@microgate.com");
986 module_param(debuglevel, int, 0);
987 module_param(maxframe, int, 0);
988 MODULE_ALIAS_LDISC(N_HDLC);
989