Kernel

Kernel Git Source Tree

Root/drivers/tty/amiserial.c

1	/*
2	* Serial driver for the amiga builtin port.
3	*
4	* This code was created by taking serial.c version 4.30 from kernel
5	* release 2.3.22, replacing all hardware related stuff with the
6	* corresponding amiga hardware actions, and removing all irrelevant
7	* code. As a consequence, it uses many of the constants and names
8	* associated with the registers and bits of 16550 compatible UARTS -
9	* but only to keep track of status, etc in the state variables. It
10	* was done this was to make it easier to keep the code in line with
11	* (non hardware specific) changes to serial.c.
12	*
13	* The port is registered with the tty driver as minor device 64, and
14	* therefore other ports should should only use 65 upwards.
15	*
16	* Richard Lucock 28/12/99
17	*
18	* Copyright (C) 1991, 1992 Linus Torvalds
19	* Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997,
20	* 1998, 1999 Theodore Ts'o
21	*
22	*/
23
24	/*
25	* Serial driver configuration section. Here are the various options:
26	*
27	* SERIAL_PARANOIA_CHECK
28	* Check the magic number for the async_structure where
29	* ever possible.
30	*/
31
32	#include <linux/delay.h>
33
34	#undef SERIAL_PARANOIA_CHECK
35	#define SERIAL_DO_RESTART
36
37	/* Set of debugging defines */
38
39	#undef SERIAL_DEBUG_INTR
40	#undef SERIAL_DEBUG_OPEN
41	#undef SERIAL_DEBUG_FLOW
42	#undef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
43
44	/* Sanity checks */
45
46	#if defined(MODULE) && defined(SERIAL_DEBUG_MCOUNT)
47	#define DBG_CNT(s) printk("(%s): [%x] refc=%d, serc=%d, ttyc=%d -> %s\n", \
48	tty->name, (info->tport.flags), serial_driver->refcount,info->count,tty->count,s)
49	#else
50	#define DBG_CNT(s)
51	#endif
52
53	/*
54	* End of serial driver configuration section.
55	*/
56
57	#include <linux/module.h>
58
59	#include <linux/types.h>
60	#include <linux/serial.h>
61	#include <linux/serial_reg.h>
62	static char *serial_version = "4.30";
63
64	#include <linux/errno.h>
65	#include <linux/signal.h>
66	#include <linux/sched.h>
67	#include <linux/kernel.h>
68	#include <linux/timer.h>
69	#include <linux/interrupt.h>
70	#include <linux/tty.h>
71	#include <linux/tty_flip.h>
72	#include <linux/circ_buf.h>
73	#include <linux/console.h>
74	#include <linux/major.h>
75	#include <linux/string.h>
76	#include <linux/fcntl.h>
77	#include <linux/ptrace.h>
78	#include <linux/ioport.h>
79	#include <linux/mm.h>
80	#include <linux/seq_file.h>
81	#include <linux/slab.h>
82	#include <linux/init.h>
83	#include <linux/bitops.h>
84	#include <linux/platform_device.h>
85
86	#include <asm/setup.h>
87
88
89	#include <asm/irq.h>
90
91	#include <asm/amigahw.h>
92	#include <asm/amigaints.h>
93
94	struct serial_state {
95	struct tty_port tport;
96	struct circ_buf xmit;
97	struct async_icount icount;
98
99	unsigned long port;
100	int baud_base;
101	int xmit_fifo_size;
102	int custom_divisor;
103	int read_status_mask;
104	int ignore_status_mask;
105	int timeout;
106	int quot;
107	int IER; /* Interrupt Enable Register */
108	int MCR; /* Modem control register */
109	int x_char; /* xon/xoff character */
110	};
111
112	#define custom amiga_custom
113	static char *serial_name = "Amiga-builtin serial driver";
114
115	static struct tty_driver *serial_driver;
116
117	/* number of characters left in xmit buffer before we ask for more */
118	#define WAKEUP_CHARS 256
119
120	static unsigned char current_ctl_bits;
121
122	static void change_speed(struct tty_struct tty, struct serial_state info,
123	struct ktermios *old);
124	static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
125
126
127	static struct serial_state rs_table[1];
128
129	#define NR_PORTS ARRAY_SIZE(rs_table)
130
131	#include <asm/uaccess.h>
132
133	#define serial_isroot() (capable(CAP_SYS_ADMIN))
134
135
136	static inline int serial_paranoia_check(struct serial_state *info,
137	char name, const char routine)
138	{
139	#ifdef SERIAL_PARANOIA_CHECK
140	static const char *badmagic =
141	"Warning: bad magic number for serial struct (%s) in %s\n";
142	static const char *badinfo =
143	"Warning: null async_struct for (%s) in %s\n";
144
145	if (!info) {
146	printk(badinfo, name, routine);
147	return 1;
148	}
149	if (info->magic != SERIAL_MAGIC) {
150	printk(badmagic, name, routine);
151	return 1;
152	}
153	#endif
154	return 0;
155	}
156
157	/* some serial hardware definitions */
158	#define SDR_OVRUN (1<<15)
159	#define SDR_RBF (1<<14)
160	#define SDR_TBE (1<<13)
161	#define SDR_TSRE (1<<12)
162
163	#define SERPER_PARENB (1<<15)
164
165	#define AC_SETCLR (1<<15)
166	#define AC_UARTBRK (1<<11)
167
168	#define SER_DTR (1<<7)
169	#define SER_RTS (1<<6)
170	#define SER_DCD (1<<5)
171	#define SER_CTS (1<<4)
172	#define SER_DSR (1<<3)
173
174	static __inline__ void rtsdtr_ctrl(int bits)
175	{
176	ciab.pra = ((bits & (SER_RTS \| SER_DTR)) ^ (SER_RTS \| SER_DTR)) \| (ciab.pra & ~(SER_RTS \| SER_DTR));
177	}
178
179	/*
180	* ------------------------------------------------------------
181	* rs_stop() and rs_start()
182	*
183	* This routines are called before setting or resetting tty->stopped.
184	* They enable or disable transmitter interrupts, as necessary.
185	* ------------------------------------------------------------
186	*/
187	static void rs_stop(struct tty_struct *tty)
188	{
189	struct serial_state *info = tty->driver_data;
190	unsigned long flags;
191
192	if (serial_paranoia_check(info, tty->name, "rs_stop"))
193	return;
194
195	local_irq_save(flags);
196	if (info->IER & UART_IER_THRI) {
197	info->IER &= ~UART_IER_THRI;
198	/* disable Tx interrupt and remove any pending interrupts */
199	custom.intena = IF_TBE;
200	mb();
201	custom.intreq = IF_TBE;
202	mb();
203	}
204	local_irq_restore(flags);
205	}
206
207	static void rs_start(struct tty_struct *tty)
208	{
209	struct serial_state *info = tty->driver_data;
210	unsigned long flags;
211
212	if (serial_paranoia_check(info, tty->name, "rs_start"))
213	return;
214
215	local_irq_save(flags);
216	if (info->xmit.head != info->xmit.tail
217	&& info->xmit.buf
218	&& !(info->IER & UART_IER_THRI)) {
219	info->IER \|= UART_IER_THRI;
220	custom.intena = IF_SETCLR \| IF_TBE;
221	mb();
222	/* set a pending Tx Interrupt, transmitter should restart now */
223	custom.intreq = IF_SETCLR \| IF_TBE;
224	mb();
225	}
226	local_irq_restore(flags);
227	}
228
229	/*
230	* ----------------------------------------------------------------------
231	*
232	* Here starts the interrupt handling routines. All of the following
233	* subroutines are declared as inline and are folded into
234	* rs_interrupt(). They were separated out for readability's sake.
235	*
236	* Note: rs_interrupt() is a "fast" interrupt, which means that it
237	* runs with interrupts turned off. People who may want to modify
238	* rs_interrupt() should try to keep the interrupt handler as fast as
239	* possible. After you are done making modifications, it is not a bad
240	* idea to do:
241	*
242	* gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
243	*
244	* and look at the resulting assemble code in serial.s.
245	*
246	* - Ted Ts'o (tytso@mit.edu), 7-Mar-93
247	* -----------------------------------------------------------------------
248	*/
249
250	static void receive_chars(struct serial_state *info)
251	{
252	int status;
253	int serdatr;
254	struct tty_struct *tty = info->tport.tty;
255	unsigned char ch, flag;
256	struct async_icount *icount;
257	int oe = 0;
258
259	icount = &info->icount;
260
261	status = UART_LSR_DR; /* We obviously have a character! */
262	serdatr = custom.serdatr;
263	mb();
264	custom.intreq = IF_RBF;
265	mb();
266
267	if((serdatr & 0x1ff) == 0)
268	status \|= UART_LSR_BI;
269	if(serdatr & SDR_OVRUN)
270	status \|= UART_LSR_OE;
271
272	ch = serdatr & 0xff;
273	icount->rx++;
274
275	#ifdef SERIAL_DEBUG_INTR
276	printk("DR%02x:%02x...", ch, status);
277	#endif
278	flag = TTY_NORMAL;
279
280	/*
281	* We don't handle parity or frame errors - but I have left
282	* the code in, since I'm not sure that the errors can't be
283	* detected.
284	*/
285
286	if (status & (UART_LSR_BI \| UART_LSR_PE \|
287	UART_LSR_FE \| UART_LSR_OE)) {
288	/*
289	* For statistics only
290	*/
291	if (status & UART_LSR_BI) {
292	status &= ~(UART_LSR_FE \| UART_LSR_PE);
293	icount->brk++;
294	} else if (status & UART_LSR_PE)
295	icount->parity++;
296	else if (status & UART_LSR_FE)
297	icount->frame++;
298	if (status & UART_LSR_OE)
299	icount->overrun++;
300
301	/*
302	* Now check to see if character should be
303	* ignored, and mask off conditions which
304	* should be ignored.
305	*/
306	if (status & info->ignore_status_mask)
307	goto out;
308
309	status &= info->read_status_mask;
310
311	if (status & (UART_LSR_BI)) {
312	#ifdef SERIAL_DEBUG_INTR
313	printk("handling break....");
314	#endif
315	flag = TTY_BREAK;
316	if (info->tport.flags & ASYNC_SAK)
317	do_SAK(tty);
318	} else if (status & UART_LSR_PE)
319	flag = TTY_PARITY;
320	else if (status & UART_LSR_FE)
321	flag = TTY_FRAME;
322	if (status & UART_LSR_OE) {
323	/*
324	* Overrun is special, since it's
325	* reported immediately, and doesn't
326	* affect the current character
327	*/
328	oe = 1;
329	}
330	}
331	tty_insert_flip_char(tty, ch, flag);
332	if (oe == 1)
333	tty_insert_flip_char(tty, 0, TTY_OVERRUN);
334	tty_flip_buffer_push(tty);
335	out:
336	return;
337	}
338
339	static void transmit_chars(struct serial_state *info)
340	{
341	custom.intreq = IF_TBE;
342	mb();
343	if (info->x_char) {
344	custom.serdat = info->x_char \| 0x100;
345	mb();
346	info->icount.tx++;
347	info->x_char = 0;
348	return;
349	}
350	if (info->xmit.head == info->xmit.tail
351	\|\| info->tport.tty->stopped
352	\|\| info->tport.tty->hw_stopped) {
353	info->IER &= ~UART_IER_THRI;
354	custom.intena = IF_TBE;
355	mb();
356	return;
357	}
358
359	custom.serdat = info->xmit.buf[info->xmit.tail++] \| 0x100;
360	mb();
361	info->xmit.tail = info->xmit.tail & (SERIAL_XMIT_SIZE-1);
362	info->icount.tx++;
363
364	if (CIRC_CNT(info->xmit.head,
365	info->xmit.tail,
366	SERIAL_XMIT_SIZE) < WAKEUP_CHARS)
367	tty_wakeup(info->tport.tty);
368
369	#ifdef SERIAL_DEBUG_INTR
370	printk("THRE...");
371	#endif
372	if (info->xmit.head == info->xmit.tail) {
373	custom.intena = IF_TBE;
374	mb();
375	info->IER &= ~UART_IER_THRI;
376	}
377	}
378
379	static void check_modem_status(struct serial_state *info)
380	{
381	struct tty_port *port = &info->tport;
382	unsigned char status = ciab.pra & (SER_DCD \| SER_CTS \| SER_DSR);
383	unsigned char dstatus;
384	struct async_icount *icount;
385
386	/* Determine bits that have changed */
387	dstatus = status ^ current_ctl_bits;
388	current_ctl_bits = status;
389
390	if (dstatus) {
391	icount = &info->icount;
392	/* update input line counters */
393	if (dstatus & SER_DSR)
394	icount->dsr++;
395	if (dstatus & SER_DCD) {
396	icount->dcd++;
397	#ifdef CONFIG_HARD_PPS
398	if ((port->flags & ASYNC_HARDPPS_CD) &&
399	!(status & SER_DCD))
400	hardpps();
401	#endif
402	}
403	if (dstatus & SER_CTS)
404	icount->cts++;
405	wake_up_interruptible(&port->delta_msr_wait);
406	}
407
408	if ((port->flags & ASYNC_CHECK_CD) && (dstatus & SER_DCD)) {
409	#if (defined(SERIAL_DEBUG_OPEN) \|\| defined(SERIAL_DEBUG_INTR))
410	printk("ttyS%d CD now %s...", info->line,
411	(!(status & SER_DCD)) ? "on" : "off");
412	#endif
413	if (!(status & SER_DCD))
414	wake_up_interruptible(&port->open_wait);
415	else {
416	#ifdef SERIAL_DEBUG_OPEN
417	printk("doing serial hangup...");
418	#endif
419	if (port->tty)
420	tty_hangup(port->tty);
421	}
422	}
423	if (port->flags & ASYNC_CTS_FLOW) {
424	if (port->tty->hw_stopped) {
425	if (!(status & SER_CTS)) {
426	#if (defined(SERIAL_DEBUG_INTR) \|\| defined(SERIAL_DEBUG_FLOW))
427	printk("CTS tx start...");
428	#endif
429	port->tty->hw_stopped = 0;
430	info->IER \|= UART_IER_THRI;
431	custom.intena = IF_SETCLR \| IF_TBE;
432	mb();
433	/* set a pending Tx Interrupt, transmitter should restart now */
434	custom.intreq = IF_SETCLR \| IF_TBE;
435	mb();
436	tty_wakeup(port->tty);
437	return;
438	}
439	} else {
440	if ((status & SER_CTS)) {
441	#if (defined(SERIAL_DEBUG_INTR) \|\| defined(SERIAL_DEBUG_FLOW))
442	printk("CTS tx stop...");
443	#endif
444	port->tty->hw_stopped = 1;
445	info->IER &= ~UART_IER_THRI;
446	/* disable Tx interrupt and remove any pending interrupts */
447	custom.intena = IF_TBE;
448	mb();
449	custom.intreq = IF_TBE;
450	mb();
451	}
452	}
453	}
454	}
455
456	static irqreturn_t ser_vbl_int( int irq, void *data)
457	{
458	/* vbl is just a periodic interrupt we tie into to update modem status */
459	struct serial_state *info = data;
460	/*
461	* TBD - is it better to unregister from this interrupt or to
462	* ignore it if MSI is clear ?
463	*/
464	if(info->IER & UART_IER_MSI)
465	check_modem_status(info);
466	return IRQ_HANDLED;
467	}
468
469	static irqreturn_t ser_rx_int(int irq, void *dev_id)
470	{
471	struct serial_state *info = dev_id;
472
473	#ifdef SERIAL_DEBUG_INTR
474	printk("ser_rx_int...");
475	#endif
476
477	if (!info->tport.tty)
478	return IRQ_NONE;
479
480	receive_chars(info);
481	#ifdef SERIAL_DEBUG_INTR
482	printk("end.\n");
483	#endif
484	return IRQ_HANDLED;
485	}
486
487	static irqreturn_t ser_tx_int(int irq, void *dev_id)
488	{
489	struct serial_state *info = dev_id;
490
491	if (custom.serdatr & SDR_TBE) {
492	#ifdef SERIAL_DEBUG_INTR
493	printk("ser_tx_int...");
494	#endif
495
496	if (!info->tport.tty)
497	return IRQ_NONE;
498
499	transmit_chars(info);
500	#ifdef SERIAL_DEBUG_INTR
501	printk("end.\n");
502	#endif
503	}
504	return IRQ_HANDLED;
505	}
506
507	/*
508	* -------------------------------------------------------------------
509	* Here ends the serial interrupt routines.
510	* -------------------------------------------------------------------
511	*/
512
513	/*
514	* ---------------------------------------------------------------
515	* Low level utility subroutines for the serial driver: routines to
516	* figure out the appropriate timeout for an interrupt chain, routines
517	* to initialize and startup a serial port, and routines to shutdown a
518	* serial port. Useful stuff like that.
519	* ---------------------------------------------------------------
520	*/
521
522	static int startup(struct tty_struct tty, struct serial_state info)
523	{
524	struct tty_port *port = &info->tport;
525	unsigned long flags;
526	int retval=0;
527	unsigned long page;
528
529	page = get_zeroed_page(GFP_KERNEL);
530	if (!page)
531	return -ENOMEM;
532
533	local_irq_save(flags);
534
535	if (port->flags & ASYNC_INITIALIZED) {
536	free_page(page);
537	goto errout;
538	}
539
540	if (info->xmit.buf)
541	free_page(page);
542	else
543	info->xmit.buf = (unsigned char *) page;
544
545	#ifdef SERIAL_DEBUG_OPEN
546	printk("starting up ttys%d ...", info->line);
547	#endif
548
549	/* Clear anything in the input buffer */
550
551	custom.intreq = IF_RBF;
552	mb();
553
554	retval = request_irq(IRQ_AMIGA_VERTB, ser_vbl_int, 0, "serial status", info);
555	if (retval) {
556	if (serial_isroot()) {
557	set_bit(TTY_IO_ERROR, &tty->flags);
558	retval = 0;
559	}
560	goto errout;
561	}
562
563	/* enable both Rx and Tx interrupts */
564	custom.intena = IF_SETCLR \| IF_RBF \| IF_TBE;
565	mb();
566	info->IER = UART_IER_MSI;
567
568	/* remember current state of the DCD and CTS bits */
569	current_ctl_bits = ciab.pra & (SER_DCD \| SER_CTS \| SER_DSR);
570
571	info->MCR = 0;
572	if (C_BAUD(tty))
573	info->MCR = SER_DTR \| SER_RTS;
574	rtsdtr_ctrl(info->MCR);
575
576	clear_bit(TTY_IO_ERROR, &tty->flags);
577	info->xmit.head = info->xmit.tail = 0;
578
579	/*
580	* Set up the tty->alt_speed kludge
581	*/
582	if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
583	tty->alt_speed = 57600;
584	if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
585	tty->alt_speed = 115200;
586	if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
587	tty->alt_speed = 230400;
588	if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
589	tty->alt_speed = 460800;
590
591	/*
592	* and set the speed of the serial port
593	*/
594	change_speed(tty, info, NULL);
595
596	port->flags \|= ASYNC_INITIALIZED;
597	local_irq_restore(flags);
598	return 0;
599
600	errout:
601	local_irq_restore(flags);
602	return retval;
603	}
604
605	/*
606	* This routine will shutdown a serial port; interrupts are disabled, and
607	* DTR is dropped if the hangup on close termio flag is on.
608	*/
609	static void shutdown(struct tty_struct tty, struct serial_state info)
610	{
611	unsigned long flags;
612	struct serial_state *state;
613
614	if (!(info->tport.flags & ASYNC_INITIALIZED))
615	return;
616
617	state = info;
618
619	#ifdef SERIAL_DEBUG_OPEN
620	printk("Shutting down serial port %d ....\n", info->line);
621	#endif
622
623	local_irq_save(flags); /* Disable interrupts */
624
625	/*
626	* clear delta_msr_wait queue to avoid mem leaks: we may free the irq
627	* here so the queue might never be waken up
628	*/
629	wake_up_interruptible(&info->tport.delta_msr_wait);
630
631	/*
632	* Free the IRQ, if necessary
633	*/
634	free_irq(IRQ_AMIGA_VERTB, info);
635
636	if (info->xmit.buf) {
637	free_page((unsigned long) info->xmit.buf);
638	info->xmit.buf = NULL;
639	}
640
641	info->IER = 0;
642	custom.intena = IF_RBF \| IF_TBE;
643	mb();
644
645	/* disable break condition */
646	custom.adkcon = AC_UARTBRK;
647	mb();
648
649	if (tty->termios->c_cflag & HUPCL)
650	info->MCR &= ~(SER_DTR\|SER_RTS);
651	rtsdtr_ctrl(info->MCR);
652
653	set_bit(TTY_IO_ERROR, &tty->flags);
654
655	info->tport.flags &= ~ASYNC_INITIALIZED;
656	local_irq_restore(flags);
657	}
658
659
660	/*
661	* This routine is called to set the UART divisor registers to match
662	* the specified baud rate for a serial port.
663	*/
664	static void change_speed(struct tty_struct tty, struct serial_state info,
665	struct ktermios *old_termios)
666	{
667	struct tty_port *port = &info->tport;
668	int quot = 0, baud_base, baud;
669	unsigned cflag, cval = 0;
670	int bits;
671	unsigned long flags;
672
673	cflag = tty->termios->c_cflag;
674
675	/* Byte size is always 8 bits plus parity bit if requested */
676
677	cval = 3; bits = 10;
678	if (cflag & CSTOPB) {
679	cval \|= 0x04;
680	bits++;
681	}
682	if (cflag & PARENB) {
683	cval \|= UART_LCR_PARITY;
684	bits++;
685	}
686	if (!(cflag & PARODD))
687	cval \|= UART_LCR_EPAR;
688	#ifdef CMSPAR
689	if (cflag & CMSPAR)
690	cval \|= UART_LCR_SPAR;
691	#endif
692
693	/* Determine divisor based on baud rate */
694	baud = tty_get_baud_rate(tty);
695	if (!baud)
696	baud = 9600; /* B0 transition handled in rs_set_termios */
697	baud_base = info->baud_base;
698	if (baud == 38400 && (port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
699	quot = info->custom_divisor;
700	else {
701	if (baud == 134)
702	/* Special case since 134 is really 134.5 */
703	quot = (2*baud_base / 269);
704	else if (baud)
705	quot = baud_base / baud;
706	}
707	/* If the quotient is zero refuse the change */
708	if (!quot && old_termios) {
709	/* FIXME: Will need updating for new tty in the end */
710	tty->termios->c_cflag &= ~CBAUD;
711	tty->termios->c_cflag \|= (old_termios->c_cflag & CBAUD);
712	baud = tty_get_baud_rate(tty);
713	if (!baud)
714	baud = 9600;
715	if (baud == 38400 &&
716	(port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
717	quot = info->custom_divisor;
718	else {
719	if (baud == 134)
720	/* Special case since 134 is really 134.5 */
721	quot = (2*baud_base / 269);
722	else if (baud)
723	quot = baud_base / baud;
724	}
725	}
726	/* As a last resort, if the quotient is zero, default to 9600 bps */
727	if (!quot)
728	quot = baud_base / 9600;
729	info->quot = quot;
730	info->timeout = ((info->xmit_fifo_sizeHZbits*quot) / baud_base);
731	info->timeout += HZ/50; /* Add .02 seconds of slop */
732
733	/* CTS flow control flag and modem status interrupts */
734	info->IER &= ~UART_IER_MSI;
735	if (port->flags & ASYNC_HARDPPS_CD)
736	info->IER \|= UART_IER_MSI;
737	if (cflag & CRTSCTS) {
738	port->flags \|= ASYNC_CTS_FLOW;
739	info->IER \|= UART_IER_MSI;
740	} else
741	port->flags &= ~ASYNC_CTS_FLOW;
742	if (cflag & CLOCAL)
743	port->flags &= ~ASYNC_CHECK_CD;
744	else {
745	port->flags \|= ASYNC_CHECK_CD;
746	info->IER \|= UART_IER_MSI;
747	}
748	/* TBD:
749	* Does clearing IER_MSI imply that we should disable the VBL interrupt ?
750	*/
751
752	/*
753	* Set up parity check flag
754	*/
755
756	info->read_status_mask = UART_LSR_OE \| UART_LSR_DR;
757	if (I_INPCK(tty))
758	info->read_status_mask \|= UART_LSR_FE \| UART_LSR_PE;
759	if (I_BRKINT(tty) \|\| I_PARMRK(tty))
760	info->read_status_mask \|= UART_LSR_BI;
761
762	/*
763	* Characters to ignore
764	*/
765	info->ignore_status_mask = 0;
766	if (I_IGNPAR(tty))
767	info->ignore_status_mask \|= UART_LSR_PE \| UART_LSR_FE;
768	if (I_IGNBRK(tty)) {
769	info->ignore_status_mask \|= UART_LSR_BI;
770	/*
771	* If we're ignore parity and break indicators, ignore
772	* overruns too. (For real raw support).
773	*/
774	if (I_IGNPAR(tty))
775	info->ignore_status_mask \|= UART_LSR_OE;
776	}
777	/*
778	* !!! ignore all characters if CREAD is not set
779	*/
780	if ((cflag & CREAD) == 0)
781	info->ignore_status_mask \|= UART_LSR_DR;
782	local_irq_save(flags);
783
784	{
785	short serper;
786
787	/* Set up the baud rate */
788	serper = quot - 1;
789
790	/* Enable or disable parity bit */
791
792	if(cval & UART_LCR_PARITY)
793	serper \|= (SERPER_PARENB);
794
795	custom.serper = serper;
796	mb();
797	}
798
799	local_irq_restore(flags);
800	}
801
802	static int rs_put_char(struct tty_struct *tty, unsigned char ch)
803	{
804	struct serial_state *info;
805	unsigned long flags;
806
807	info = tty->driver_data;
808
809	if (serial_paranoia_check(info, tty->name, "rs_put_char"))
810	return 0;
811
812	if (!info->xmit.buf)
813	return 0;
814
815	local_irq_save(flags);
816	if (CIRC_SPACE(info->xmit.head,
817	info->xmit.tail,
818	SERIAL_XMIT_SIZE) == 0) {
819	local_irq_restore(flags);
820	return 0;
821	}
822
823	info->xmit.buf[info->xmit.head++] = ch;
824	info->xmit.head &= SERIAL_XMIT_SIZE-1;
825	local_irq_restore(flags);
826	return 1;
827	}
828
829	static void rs_flush_chars(struct tty_struct *tty)
830	{
831	struct serial_state *info = tty->driver_data;
832	unsigned long flags;
833
834	if (serial_paranoia_check(info, tty->name, "rs_flush_chars"))
835	return;
836
837	if (info->xmit.head == info->xmit.tail
838	\|\| tty->stopped
839	\|\| tty->hw_stopped
840	\|\| !info->xmit.buf)
841	return;
842
843	local_irq_save(flags);
844	info->IER \|= UART_IER_THRI;
845	custom.intena = IF_SETCLR \| IF_TBE;
846	mb();
847	/* set a pending Tx Interrupt, transmitter should restart now */
848	custom.intreq = IF_SETCLR \| IF_TBE;
849	mb();
850	local_irq_restore(flags);
851	}
852
853	static int rs_write(struct tty_struct * tty, const unsigned char *buf, int count)
854	{
855	int c, ret = 0;
856	struct serial_state *info = tty->driver_data;
857	unsigned long flags;
858
859	if (serial_paranoia_check(info, tty->name, "rs_write"))
860	return 0;
861
862	if (!info->xmit.buf)
863	return 0;
864
865	local_irq_save(flags);
866	while (1) {
867	c = CIRC_SPACE_TO_END(info->xmit.head,
868	info->xmit.tail,
869	SERIAL_XMIT_SIZE);
870	if (count < c)
871	c = count;
872	if (c <= 0) {
873	break;
874	}
875	memcpy(info->xmit.buf + info->xmit.head, buf, c);
876	info->xmit.head = ((info->xmit.head + c) &
877	(SERIAL_XMIT_SIZE-1));
878	buf += c;
879	count -= c;
880	ret += c;
881	}
882	local_irq_restore(flags);
883
884	if (info->xmit.head != info->xmit.tail
885	&& !tty->stopped
886	&& !tty->hw_stopped
887	&& !(info->IER & UART_IER_THRI)) {
888	info->IER \|= UART_IER_THRI;
889	local_irq_disable();
890	custom.intena = IF_SETCLR \| IF_TBE;
891	mb();
892	/* set a pending Tx Interrupt, transmitter should restart now */
893	custom.intreq = IF_SETCLR \| IF_TBE;
894	mb();
895	local_irq_restore(flags);
896	}
897	return ret;
898	}
899
900	static int rs_write_room(struct tty_struct *tty)
901	{
902	struct serial_state *info = tty->driver_data;
903
904	if (serial_paranoia_check(info, tty->name, "rs_write_room"))
905	return 0;
906	return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
907	}
908
909	static int rs_chars_in_buffer(struct tty_struct *tty)
910	{
911	struct serial_state *info = tty->driver_data;
912
913	if (serial_paranoia_check(info, tty->name, "rs_chars_in_buffer"))
914	return 0;
915	return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
916	}
917
918	static void rs_flush_buffer(struct tty_struct *tty)
919	{
920	struct serial_state *info = tty->driver_data;
921	unsigned long flags;
922
923	if (serial_paranoia_check(info, tty->name, "rs_flush_buffer"))
924	return;
925	local_irq_save(flags);
926	info->xmit.head = info->xmit.tail = 0;
927	local_irq_restore(flags);
928	tty_wakeup(tty);
929	}
930
931	/*
932	* This function is used to send a high-priority XON/XOFF character to
933	* the device
934	*/
935	static void rs_send_xchar(struct tty_struct *tty, char ch)
936	{
937	struct serial_state *info = tty->driver_data;
938	unsigned long flags;
939
940	if (serial_paranoia_check(info, tty->name, "rs_send_char"))
941	return;
942
943	info->x_char = ch;
944	if (ch) {
945	/* Make sure transmit interrupts are on */
946
947	/* Check this ! */
948	local_irq_save(flags);
949	if(!(custom.intenar & IF_TBE)) {
950	custom.intena = IF_SETCLR \| IF_TBE;
951	mb();
952	/* set a pending Tx Interrupt, transmitter should restart now */
953	custom.intreq = IF_SETCLR \| IF_TBE;
954	mb();
955	}
956	local_irq_restore(flags);
957
958	info->IER \|= UART_IER_THRI;
959	}
960	}
961
962	/*
963	* ------------------------------------------------------------
964	* rs_throttle()
965	*
966	* This routine is called by the upper-layer tty layer to signal that
967	* incoming characters should be throttled.
968	* ------------------------------------------------------------
969	*/
970	static void rs_throttle(struct tty_struct * tty)
971	{
972	struct serial_state *info = tty->driver_data;
973	unsigned long flags;
974	#ifdef SERIAL_DEBUG_THROTTLE
975	char buf[64];
976
977	printk("throttle %s: %d....\n", tty_name(tty, buf),
978	tty->ldisc.chars_in_buffer(tty));
979	#endif
980
981	if (serial_paranoia_check(info, tty->name, "rs_throttle"))
982	return;
983
984	if (I_IXOFF(tty))
985	rs_send_xchar(tty, STOP_CHAR(tty));
986
987	if (tty->termios->c_cflag & CRTSCTS)
988	info->MCR &= ~SER_RTS;
989
990	local_irq_save(flags);
991	rtsdtr_ctrl(info->MCR);
992	local_irq_restore(flags);
993	}
994
995	static void rs_unthrottle(struct tty_struct * tty)
996	{
997	struct serial_state *info = tty->driver_data;
998	unsigned long flags;
999	#ifdef SERIAL_DEBUG_THROTTLE
1000	char buf[64];
1001
1002	printk("unthrottle %s: %d....\n", tty_name(tty, buf),
1003	tty->ldisc.chars_in_buffer(tty));
1004	#endif
1005
1006	if (serial_paranoia_check(info, tty->name, "rs_unthrottle"))
1007	return;
1008
1009	if (I_IXOFF(tty)) {
1010	if (info->x_char)
1011	info->x_char = 0;
1012	else
1013	rs_send_xchar(tty, START_CHAR(tty));
1014	}
1015	if (tty->termios->c_cflag & CRTSCTS)
1016	info->MCR \|= SER_RTS;
1017	local_irq_save(flags);
1018	rtsdtr_ctrl(info->MCR);
1019	local_irq_restore(flags);
1020	}
1021
1022	/*
1023	* ------------------------------------------------------------
1024	* rs_ioctl() and friends
1025	* ------------------------------------------------------------
1026	*/
1027
1028	static int get_serial_info(struct tty_struct tty, struct serial_state state,
1029	struct serial_struct __user * retinfo)
1030	{
1031	struct serial_struct tmp;
1032
1033	if (!retinfo)
1034	return -EFAULT;
1035	memset(&tmp, 0, sizeof(tmp));
1036	tty_lock();
1037	tmp.line = tty->index;
1038	tmp.port = state->port;
1039	tmp.flags = state->tport.flags;
1040	tmp.xmit_fifo_size = state->xmit_fifo_size;
1041	tmp.baud_base = state->baud_base;
1042	tmp.close_delay = state->tport.close_delay;
1043	tmp.closing_wait = state->tport.closing_wait;
1044	tmp.custom_divisor = state->custom_divisor;
1045	tty_unlock();
1046	if (copy_to_user(retinfo,&tmp,sizeof(*retinfo)))
1047	return -EFAULT;
1048	return 0;
1049	}
1050
1051	static int set_serial_info(struct tty_struct tty, struct serial_state state,
1052	struct serial_struct __user * new_info)
1053	{
1054	struct tty_port *port = &state->tport;
1055	struct serial_struct new_serial;
1056	bool change_spd;
1057	int retval = 0;
1058
1059	if (copy_from_user(&new_serial,new_info,sizeof(new_serial)))
1060	return -EFAULT;
1061
1062	tty_lock();
1063	change_spd = ((new_serial.flags ^ port->flags) & ASYNC_SPD_MASK) \|\|
1064	new_serial.custom_divisor != state->custom_divisor;
1065	if (new_serial.irq \|\| new_serial.port != state->port \|\|
1066	new_serial.xmit_fifo_size != state->xmit_fifo_size) {
1067	tty_unlock();
1068	return -EINVAL;
1069	}
1070
1071	if (!serial_isroot()) {
1072	if ((new_serial.baud_base != state->baud_base) \|\|
1073	(new_serial.close_delay != port->close_delay) \|\|
1074	(new_serial.xmit_fifo_size != state->xmit_fifo_size) \|\|
1075	((new_serial.flags & ~ASYNC_USR_MASK) !=
1076	(port->flags & ~ASYNC_USR_MASK))) {
1077	tty_unlock();
1078	return -EPERM;
1079	}
1080	port->flags = ((port->flags & ~ASYNC_USR_MASK) \|
1081	(new_serial.flags & ASYNC_USR_MASK));
1082	state->custom_divisor = new_serial.custom_divisor;
1083	goto check_and_exit;
1084	}
1085
1086	if (new_serial.baud_base < 9600) {
1087	tty_unlock();
1088	return -EINVAL;
1089	}
1090
1091	/*
1092	* OK, past this point, all the error checking has been done.
1093	* At this point, we start making changes.....
1094	*/
1095
1096	state->baud_base = new_serial.baud_base;
1097	port->flags = ((port->flags & ~ASYNC_FLAGS) \|
1098	(new_serial.flags & ASYNC_FLAGS));
1099	state->custom_divisor = new_serial.custom_divisor;
1100	port->close_delay = new_serial.close_delay * HZ/100;
1101	port->closing_wait = new_serial.closing_wait * HZ/100;
1102	tty->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
1103
1104	check_and_exit:
1105	if (port->flags & ASYNC_INITIALIZED) {
1106	if (change_spd) {
1107	if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1108	tty->alt_speed = 57600;
1109	if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1110	tty->alt_speed = 115200;
1111	if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
1112	tty->alt_speed = 230400;
1113	if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
1114	tty->alt_speed = 460800;
1115	change_speed(tty, state, NULL);
1116	}
1117	} else
1118	retval = startup(tty, state);
1119	tty_unlock();
1120	return retval;
1121	}
1122
1123
1124	/*
1125	* get_lsr_info - get line status register info
1126	*
1127	* Purpose: Let user call ioctl() to get info when the UART physically
1128	* is emptied. On bus types like RS485, the transmitter must
1129	* release the bus after transmitting. This must be done when
1130	* the transmit shift register is empty, not be done when the
1131	* transmit holding register is empty. This functionality
1132	* allows an RS485 driver to be written in user space.
1133	*/
1134	static int get_lsr_info(struct serial_state info, unsigned int __user value)
1135	{
1136	unsigned char status;
1137	unsigned int result;
1138	unsigned long flags;
1139
1140	local_irq_save(flags);
1141	status = custom.serdatr;
1142	mb();
1143	local_irq_restore(flags);
1144	result = ((status & SDR_TSRE) ? TIOCSER_TEMT : 0);
1145	if (copy_to_user(value, &result, sizeof(int)))
1146	return -EFAULT;
1147	return 0;
1148	}
1149
1150
1151	static int rs_tiocmget(struct tty_struct *tty)
1152	{
1153	struct serial_state *info = tty->driver_data;
1154	unsigned char control, status;
1155	unsigned long flags;
1156
1157	if (serial_paranoia_check(info, tty->name, "rs_ioctl"))
1158	return -ENODEV;
1159	if (tty->flags & (1 << TTY_IO_ERROR))
1160	return -EIO;
1161
1162	control = info->MCR;
1163	local_irq_save(flags);
1164	status = ciab.pra;
1165	local_irq_restore(flags);
1166	return ((control & SER_RTS) ? TIOCM_RTS : 0)
1167	\| ((control & SER_DTR) ? TIOCM_DTR : 0)
1168	\| (!(status & SER_DCD) ? TIOCM_CAR : 0)
1169	\| (!(status & SER_DSR) ? TIOCM_DSR : 0)
1170	\| (!(status & SER_CTS) ? TIOCM_CTS : 0);
1171	}
1172
1173	static int rs_tiocmset(struct tty_struct *tty, unsigned int set,
1174	unsigned int clear)
1175	{
1176	struct serial_state *info = tty->driver_data;
1177	unsigned long flags;
1178
1179	if (serial_paranoia_check(info, tty->name, "rs_ioctl"))
1180	return -ENODEV;
1181	if (tty->flags & (1 << TTY_IO_ERROR))
1182	return -EIO;
1183
1184	local_irq_save(flags);
1185	if (set & TIOCM_RTS)
1186	info->MCR \|= SER_RTS;
1187	if (set & TIOCM_DTR)
1188	info->MCR \|= SER_DTR;
1189	if (clear & TIOCM_RTS)
1190	info->MCR &= ~SER_RTS;
1191	if (clear & TIOCM_DTR)
1192	info->MCR &= ~SER_DTR;
1193	rtsdtr_ctrl(info->MCR);
1194	local_irq_restore(flags);
1195	return 0;
1196	}
1197
1198	/*
1199	* rs_break() --- routine which turns the break handling on or off
1200	*/
1201	static int rs_break(struct tty_struct *tty, int break_state)
1202	{
1203	struct serial_state *info = tty->driver_data;
1204	unsigned long flags;
1205
1206	if (serial_paranoia_check(info, tty->name, "rs_break"))
1207	return -EINVAL;
1208
1209	local_irq_save(flags);
1210	if (break_state == -1)
1211	custom.adkcon = AC_SETCLR \| AC_UARTBRK;
1212	else
1213	custom.adkcon = AC_UARTBRK;
1214	mb();
1215	local_irq_restore(flags);
1216	return 0;
1217	}
1218
1219	/*
1220	* Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1221	* Return: write counters to the user passed counter struct
1222	* NB: both 1->0 and 0->1 transitions are counted except for
1223	* RI where only 0->1 is counted.
1224	*/
1225	static int rs_get_icount(struct tty_struct *tty,
1226	struct serial_icounter_struct *icount)
1227	{
1228	struct serial_state *info = tty->driver_data;
1229	struct async_icount cnow;
1230	unsigned long flags;
1231
1232	local_irq_save(flags);
1233	cnow = info->icount;
1234	local_irq_restore(flags);
1235	icount->cts = cnow.cts;
1236	icount->dsr = cnow.dsr;
1237	icount->rng = cnow.rng;
1238	icount->dcd = cnow.dcd;
1239	icount->rx = cnow.rx;
1240	icount->tx = cnow.tx;
1241	icount->frame = cnow.frame;
1242	icount->overrun = cnow.overrun;
1243	icount->parity = cnow.parity;
1244	icount->brk = cnow.brk;
1245	icount->buf_overrun = cnow.buf_overrun;
1246
1247	return 0;
1248	}
1249
1250	static int rs_ioctl(struct tty_struct *tty,
1251	unsigned int cmd, unsigned long arg)
1252	{
1253	struct serial_state *info = tty->driver_data;
1254	struct async_icount cprev, cnow; /* kernel counter temps */
1255	void __user argp = (void __user )arg;
1256	unsigned long flags;
1257
1258	if (serial_paranoia_check(info, tty->name, "rs_ioctl"))
1259	return -ENODEV;
1260
1261	if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
1262	(cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
1263	(cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
1264	if (tty->flags & (1 << TTY_IO_ERROR))
1265	return -EIO;
1266	}
1267
1268	switch (cmd) {
1269	case TIOCGSERIAL:
1270	return get_serial_info(tty, info, argp);
1271	case TIOCSSERIAL:
1272	return set_serial_info(tty, info, argp);
1273	case TIOCSERCONFIG:
1274	return 0;
1275
1276	case TIOCSERGETLSR: /* Get line status register */
1277	return get_lsr_info(info, argp);
1278
1279	case TIOCSERGSTRUCT:
1280	if (copy_to_user(argp,
1281	info, sizeof(struct serial_state)))
1282	return -EFAULT;
1283	return 0;
1284
1285	/*
1286	* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1287	* - mask passed in arg for lines of interest
1288	* (use \|'ed TIOCM_RNG/DSR/CD/CTS for masking)
1289	* Caller should use TIOCGICOUNT to see which one it was
1290	*/
1291	case TIOCMIWAIT:
1292	local_irq_save(flags);
1293	/* note the counters on entry */
1294	cprev = info->icount;
1295	local_irq_restore(flags);
1296	while (1) {
1297	interruptible_sleep_on(&info->tport.delta_msr_wait);
1298	/* see if a signal did it */
1299	if (signal_pending(current))
1300	return -ERESTARTSYS;
1301	local_irq_save(flags);
1302	cnow = info->icount; /* atomic copy */
1303	local_irq_restore(flags);
1304	if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
1305	cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
1306	return -EIO; /* no change => error */
1307	if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) \|\|
1308	((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) \|\|
1309	((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) \|\|
1310	((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
1311	return 0;
1312	}
1313	cprev = cnow;
1314	}
1315	/* NOTREACHED */
1316
1317	case TIOCSERGWILD:
1318	case TIOCSERSWILD:
1319	/* "setserial -W" is called in Debian boot */
1320	printk ("TIOCSER?WILD ioctl obsolete, ignored.\n");
1321	return 0;
1322
1323	default:
1324	return -ENOIOCTLCMD;
1325	}
1326	return 0;
1327	}
1328
1329	static void rs_set_termios(struct tty_struct tty, struct ktermios old_termios)
1330	{
1331	struct serial_state *info = tty->driver_data;
1332	unsigned long flags;
1333	unsigned int cflag = tty->termios->c_cflag;
1334
1335	change_speed(tty, info, old_termios);
1336
1337	/* Handle transition to B0 status */
1338	if ((old_termios->c_cflag & CBAUD) &&
1339	!(cflag & CBAUD)) {
1340	info->MCR &= ~(SER_DTR\|SER_RTS);
1341	local_irq_save(flags);
1342	rtsdtr_ctrl(info->MCR);
1343	local_irq_restore(flags);
1344	}
1345
1346	/* Handle transition away from B0 status */
1347	if (!(old_termios->c_cflag & CBAUD) &&
1348	(cflag & CBAUD)) {
1349	info->MCR \|= SER_DTR;
1350	if (!(tty->termios->c_cflag & CRTSCTS) \|\|
1351	!test_bit(TTY_THROTTLED, &tty->flags)) {
1352	info->MCR \|= SER_RTS;
1353	}
1354	local_irq_save(flags);
1355	rtsdtr_ctrl(info->MCR);
1356	local_irq_restore(flags);
1357	}
1358
1359	/* Handle turning off CRTSCTS */
1360	if ((old_termios->c_cflag & CRTSCTS) &&
1361	!(tty->termios->c_cflag & CRTSCTS)) {
1362	tty->hw_stopped = 0;
1363	rs_start(tty);
1364	}
1365
1366	#if 0
1367	/*
1368	* No need to wake up processes in open wait, since they
1369	* sample the CLOCAL flag once, and don't recheck it.
1370	* XXX It's not clear whether the current behavior is correct
1371	* or not. Hence, this may change.....
1372	*/
1373	if (!(old_termios->c_cflag & CLOCAL) &&
1374	(tty->termios->c_cflag & CLOCAL))
1375	wake_up_interruptible(&info->open_wait);
1376	#endif
1377	}
1378
1379	/*
1380	* ------------------------------------------------------------
1381	* rs_close()
1382	*
1383	* This routine is called when the serial port gets closed. First, we
1384	* wait for the last remaining data to be sent. Then, we unlink its
1385	* async structure from the interrupt chain if necessary, and we free
1386	* that IRQ if nothing is left in the chain.
1387	* ------------------------------------------------------------
1388	*/
1389	static void rs_close(struct tty_struct tty, struct file filp)
1390	{
1391	struct serial_state *state = tty->driver_data;
1392	struct tty_port *port = &state->tport;
1393
1394	if (serial_paranoia_check(state, tty->name, "rs_close"))
1395	return;
1396
1397	if (tty_port_close_start(port, tty, filp) == 0)
1398	return;
1399
1400	/*
1401	* At this point we stop accepting input. To do this, we
1402	* disable the receive line status interrupts, and tell the
1403	* interrupt driver to stop checking the data ready bit in the
1404	* line status register.
1405	*/
1406	state->read_status_mask &= ~UART_LSR_DR;
1407	if (port->flags & ASYNC_INITIALIZED) {
1408	/* disable receive interrupts */
1409	custom.intena = IF_RBF;
1410	mb();
1411	/* clear any pending receive interrupt */
1412	custom.intreq = IF_RBF;
1413	mb();
1414
1415	/*
1416	* Before we drop DTR, make sure the UART transmitter
1417	* has completely drained; this is especially
1418	* important if there is a transmit FIFO!
1419	*/
1420	rs_wait_until_sent(tty, state->timeout);
1421	}
1422	shutdown(tty, state);
1423	rs_flush_buffer(tty);
1424
1425	tty_ldisc_flush(tty);
1426	port->tty = NULL;
1427
1428	tty_port_close_end(port, tty);
1429	}
1430
1431	/*
1432	* rs_wait_until_sent() --- wait until the transmitter is empty
1433	*/
1434	static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
1435	{
1436	struct serial_state *info = tty->driver_data;
1437	unsigned long orig_jiffies, char_time;
1438	int lsr;
1439
1440	if (serial_paranoia_check(info, tty->name, "rs_wait_until_sent"))
1441	return;
1442
1443	if (info->xmit_fifo_size == 0)
1444	return; /* Just in case.... */
1445
1446	orig_jiffies = jiffies;
1447
1448	/*
1449	* Set the check interval to be 1/5 of the estimated time to
1450	* send a single character, and make it at least 1. The check
1451	* interval should also be less than the timeout.
1452	*
1453	* Note: we have to use pretty tight timings here to satisfy
1454	* the NIST-PCTS.
1455	*/
1456	char_time = (info->timeout - HZ/50) / info->xmit_fifo_size;
1457	char_time = char_time / 5;
1458	if (char_time == 0)
1459	char_time = 1;
1460	if (timeout)
1461	char_time = min_t(unsigned long, char_time, timeout);
1462	/*
1463	* If the transmitter hasn't cleared in twice the approximate
1464	* amount of time to send the entire FIFO, it probably won't
1465	* ever clear. This assumes the UART isn't doing flow
1466	* control, which is currently the case. Hence, if it ever
1467	* takes longer than info->timeout, this is probably due to a
1468	* UART bug of some kind. So, we clamp the timeout parameter at
1469	* 2*info->timeout.
1470	*/
1471	if (!timeout \|\| timeout > 2*info->timeout)
1472	timeout = 2*info->timeout;
1473	#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1474	printk("In rs_wait_until_sent(%d) check=%lu...", timeout, char_time);
1475	printk("jiff=%lu...", jiffies);
1476	#endif
1477	while(!((lsr = custom.serdatr) & SDR_TSRE)) {
1478	#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1479	printk("serdatr = %d (jiff=%lu)...", lsr, jiffies);
1480	#endif
1481	msleep_interruptible(jiffies_to_msecs(char_time));
1482	if (signal_pending(current))
1483	break;
1484	if (timeout && time_after(jiffies, orig_jiffies + timeout))
1485	break;
1486	}
1487	__set_current_state(TASK_RUNNING);
1488
1489	#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1490	printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies);
1491	#endif
1492	}
1493
1494	/*
1495	* rs_hangup() --- called by tty_hangup() when a hangup is signaled.
1496	*/
1497	static void rs_hangup(struct tty_struct *tty)
1498	{
1499	struct serial_state *info = tty->driver_data;
1500
1501	if (serial_paranoia_check(info, tty->name, "rs_hangup"))
1502	return;
1503
1504	rs_flush_buffer(tty);
1505	shutdown(tty, info);
1506	info->tport.count = 0;
1507	info->tport.flags &= ~ASYNC_NORMAL_ACTIVE;
1508	info->tport.tty = NULL;
1509	wake_up_interruptible(&info->tport.open_wait);
1510	}
1511
1512	/*
1513	* This routine is called whenever a serial port is opened. It
1514	* enables interrupts for a serial port, linking in its async structure into
1515	* the IRQ chain. It also performs the serial-specific
1516	* initialization for the tty structure.
1517	*/
1518	static int rs_open(struct tty_struct tty, struct file filp)
1519	{
1520	struct serial_state *info = rs_table + tty->index;
1521	struct tty_port *port = &info->tport;
1522	int retval;
1523
1524	port->count++;
1525	port->tty = tty;
1526	tty->driver_data = info;
1527	tty->port = port;
1528	if (serial_paranoia_check(info, tty->name, "rs_open"))
1529	return -ENODEV;
1530
1531	tty->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
1532
1533	retval = startup(tty, info);
1534	if (retval) {
1535	return retval;
1536	}
1537
1538	return tty_port_block_til_ready(port, tty, filp);
1539	}
1540
1541	/*
1542	* /proc fs routines....
1543	*/
1544
1545	static inline void line_info(struct seq_file *m, int line,
1546	struct serial_state *state)
1547	{
1548	char stat_buf[30], control, status;
1549	unsigned long flags;
1550
1551	seq_printf(m, "%d: uart:amiga_builtin", line);
1552
1553	local_irq_save(flags);
1554	status = ciab.pra;
1555	control = (state->tport.flags & ASYNC_INITIALIZED) ? state->MCR : status;
1556	local_irq_restore(flags);
1557
1558	stat_buf[0] = 0;
1559	stat_buf[1] = 0;
1560	if(!(control & SER_RTS))
1561	strcat(stat_buf, "\|RTS");
1562	if(!(status & SER_CTS))
1563	strcat(stat_buf, "\|CTS");
1564	if(!(control & SER_DTR))
1565	strcat(stat_buf, "\|DTR");
1566	if(!(status & SER_DSR))
1567	strcat(stat_buf, "\|DSR");
1568	if(!(status & SER_DCD))
1569	strcat(stat_buf, "\|CD");
1570
1571	if (state->quot)
1572	seq_printf(m, " baud:%d", state->baud_base / state->quot);
1573
1574	seq_printf(m, " tx:%d rx:%d", state->icount.tx, state->icount.rx);
1575
1576	if (state->icount.frame)
1577	seq_printf(m, " fe:%d", state->icount.frame);
1578
1579	if (state->icount.parity)
1580	seq_printf(m, " pe:%d", state->icount.parity);
1581
1582	if (state->icount.brk)
1583	seq_printf(m, " brk:%d", state->icount.brk);
1584
1585	if (state->icount.overrun)
1586	seq_printf(m, " oe:%d", state->icount.overrun);
1587
1588	/*
1589	* Last thing is the RS-232 status lines
1590	*/
1591	seq_printf(m, " %s\n", stat_buf+1);
1592	}
1593
1594	static int rs_proc_show(struct seq_file m, void v)
1595	{
1596	seq_printf(m, "serinfo:1.0 driver:%s\n", serial_version);
1597	line_info(m, 0, &rs_table[0]);
1598	return 0;
1599	}
1600
1601	static int rs_proc_open(struct inode inode, struct file file)
1602	{
1603	return single_open(file, rs_proc_show, NULL);
1604	}
1605
1606	static const struct file_operations rs_proc_fops = {
1607	.owner = THIS_MODULE,
1608	.open = rs_proc_open,
1609	.read = seq_read,
1610	.llseek = seq_lseek,
1611	.release = single_release,
1612	};
1613
1614	/*
1615	* ---------------------------------------------------------------------
1616	* rs_init() and friends
1617	*
1618	* rs_init() is called at boot-time to initialize the serial driver.
1619	* ---------------------------------------------------------------------
1620	*/
1621
1622	/*
1623	* This routine prints out the appropriate serial driver version
1624	* number, and identifies which options were configured into this
1625	* driver.
1626	*/
1627	static void show_serial_version(void)
1628	{
1629	printk(KERN_INFO "%s version %s\n", serial_name, serial_version);
1630	}
1631
1632
1633	static const struct tty_operations serial_ops = {
1634	.open = rs_open,
1635	.close = rs_close,
1636	.write = rs_write,
1637	.put_char = rs_put_char,
1638	.flush_chars = rs_flush_chars,
1639	.write_room = rs_write_room,
1640	.chars_in_buffer = rs_chars_in_buffer,
1641	.flush_buffer = rs_flush_buffer,
1642	.ioctl = rs_ioctl,
1643	.throttle = rs_throttle,
1644	.unthrottle = rs_unthrottle,
1645	.set_termios = rs_set_termios,
1646	.stop = rs_stop,
1647	.start = rs_start,
1648	.hangup = rs_hangup,
1649	.break_ctl = rs_break,
1650	.send_xchar = rs_send_xchar,
1651	.wait_until_sent = rs_wait_until_sent,
1652	.tiocmget = rs_tiocmget,
1653	.tiocmset = rs_tiocmset,
1654	.get_icount = rs_get_icount,
1655	.proc_fops = &rs_proc_fops,
1656	};
1657
1658	static int amiga_carrier_raised(struct tty_port *port)
1659	{
1660	return !(ciab.pra & SER_DCD);
1661	}
1662
1663	static void amiga_dtr_rts(struct tty_port *port, int raise)
1664	{
1665	struct serial_state *info = container_of(port, struct serial_state,
1666	tport);
1667	unsigned long flags;
1668
1669	if (raise)
1670	info->MCR \|= SER_DTR\|SER_RTS;
1671	else
1672	info->MCR &= ~(SER_DTR\|SER_RTS);
1673
1674	local_irq_save(flags);
1675	rtsdtr_ctrl(info->MCR);
1676	local_irq_restore(flags);
1677	}
1678
1679	static const struct tty_port_operations amiga_port_ops = {
1680	.carrier_raised = amiga_carrier_raised,
1681	.dtr_rts = amiga_dtr_rts,
1682	};
1683
1684	/*
1685	* The serial driver boot-time initialization code!
1686	*/
1687	static int __init amiga_serial_probe(struct platform_device *pdev)
1688	{
1689	unsigned long flags;
1690	struct serial_state * state;
1691	int error;
1692
1693	serial_driver = alloc_tty_driver(NR_PORTS);
1694	if (!serial_driver)
1695	return -ENOMEM;
1696
1697	show_serial_version();
1698
1699	/* Initialize the tty_driver structure */
1700
1701	serial_driver->driver_name = "amiserial";
1702	serial_driver->name = "ttyS";
1703	serial_driver->major = TTY_MAJOR;
1704	serial_driver->minor_start = 64;
1705	serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
1706	serial_driver->subtype = SERIAL_TYPE_NORMAL;
1707	serial_driver->init_termios = tty_std_termios;
1708	serial_driver->init_termios.c_cflag =
1709	B9600 \| CS8 \| CREAD \| HUPCL \| CLOCAL;
1710	serial_driver->flags = TTY_DRIVER_REAL_RAW;
1711	tty_set_operations(serial_driver, &serial_ops);
1712
1713	error = tty_register_driver(serial_driver);
1714	if (error)
1715	goto fail_put_tty_driver;
1716
1717	state = rs_table;
1718	state->port = (int)&custom.serdatr; /* Just to give it a value */
1719	state->custom_divisor = 0;
1720	state->icount.cts = state->icount.dsr =
1721	state->icount.rng = state->icount.dcd = 0;
1722	state->icount.rx = state->icount.tx = 0;
1723	state->icount.frame = state->icount.parity = 0;
1724	state->icount.overrun = state->icount.brk = 0;
1725	tty_port_init(&state->tport);
1726	state->tport.ops = &amiga_port_ops;
1727
1728	printk(KERN_INFO "ttyS0 is the amiga builtin serial port\n");
1729
1730	/* Hardware set up */
1731
1732	state->baud_base = amiga_colorclock;
1733	state->xmit_fifo_size = 1;
1734
1735	/* set ISRs, and then disable the rx interrupts */
1736	error = request_irq(IRQ_AMIGA_TBE, ser_tx_int, 0, "serial TX", state);
1737	if (error)
1738	goto fail_unregister;
1739
1740	error = request_irq(IRQ_AMIGA_RBF, ser_rx_int, 0,
1741	"serial RX", state);
1742	if (error)
1743	goto fail_free_irq;
1744
1745	local_irq_save(flags);
1746
1747	/* turn off Rx and Tx interrupts */
1748	custom.intena = IF_RBF \| IF_TBE;
1749	mb();
1750
1751	/* clear any pending interrupt */
1752	custom.intreq = IF_RBF \| IF_TBE;
1753	mb();
1754
1755	local_irq_restore(flags);
1756
1757	/*
1758	* set the appropriate directions for the modem control flags,
1759	* and clear RTS and DTR
1760	*/
1761	ciab.ddra \|= (SER_DTR \| SER_RTS); /* outputs */
1762	ciab.ddra &= ~(SER_DCD \| SER_CTS \| SER_DSR); /* inputs */
1763
1764	platform_set_drvdata(pdev, state);
1765
1766	return 0;
1767
1768	fail_free_irq:
1769	free_irq(IRQ_AMIGA_TBE, state);
1770	fail_unregister:
1771	tty_unregister_driver(serial_driver);
1772	fail_put_tty_driver:
1773	put_tty_driver(serial_driver);
1774	return error;
1775	}
1776
1777	static int __exit amiga_serial_remove(struct platform_device *pdev)
1778	{
1779	int error;
1780	struct serial_state *state = platform_get_drvdata(pdev);
1781
1782	/* printk("Unloading %s: version %s\n", serial_name, serial_version); */
1783	if ((error = tty_unregister_driver(serial_driver)))
1784	printk("SERIAL: failed to unregister serial driver (%d)\n",
1785	error);
1786	put_tty_driver(serial_driver);
1787
1788	free_irq(IRQ_AMIGA_TBE, state);
1789	free_irq(IRQ_AMIGA_RBF, state);
1790
1791	platform_set_drvdata(pdev, NULL);
1792
1793	return error;
1794	}
1795
1796	static struct platform_driver amiga_serial_driver = {
1797	.remove = __exit_p(amiga_serial_remove),
1798	.driver = {
1799	.name = "amiga-serial",
1800	.owner = THIS_MODULE,
1801	},
1802	};
1803
1804	static int __init amiga_serial_init(void)
1805	{
1806	return platform_driver_probe(&amiga_serial_driver, amiga_serial_probe);
1807	}
1808
1809	module_init(amiga_serial_init);
1810
1811	static void __exit amiga_serial_exit(void)
1812	{
1813	platform_driver_unregister(&amiga_serial_driver);
1814	}
1815
1816	module_exit(amiga_serial_exit);
1817
1818
1819	#if defined(CONFIG_SERIAL_CONSOLE) && !defined(MODULE)
1820
1821	/*
1822	* ------------------------------------------------------------
1823	* Serial console driver
1824	* ------------------------------------------------------------
1825	*/
1826
1827	static void amiga_serial_putc(char c)
1828	{
1829	custom.serdat = (unsigned char)c \| 0x100;
1830	while (!(custom.serdatr & 0x2000))
1831	barrier();
1832	}
1833
1834	/*
1835	* Print a string to the serial port trying not to disturb
1836	* any possible real use of the port...
1837	*
1838	* The console must be locked when we get here.
1839	*/
1840	static void serial_console_write(struct console co, const char s,
1841	unsigned count)
1842	{
1843	unsigned short intena = custom.intenar;
1844
1845	custom.intena = IF_TBE;
1846
1847	while (count--) {
1848	if (*s == '\n')
1849	amiga_serial_putc('\r');
1850	amiga_serial_putc(*s++);
1851	}
1852
1853	custom.intena = IF_SETCLR \| (intena & IF_TBE);
1854	}
1855
1856	static struct tty_driver serial_console_device(struct console c, int *index)
1857	{
1858	*index = 0;
1859	return serial_driver;
1860	}
1861
1862	static struct console sercons = {
1863	.name = "ttyS",
1864	.write = serial_console_write,
1865	.device = serial_console_device,
1866	.flags = CON_PRINTBUFFER,
1867	.index = -1,
1868	};
1869
1870	/*
1871	* Register console.
1872	*/
1873	static int __init amiserial_console_init(void)
1874	{
1875	register_console(&sercons);
1876	return 0;
1877	}
1878	console_initcall(amiserial_console_init);
1879
1880	#endif /* CONFIG_SERIAL_CONSOLE && !MODULE */
1881
1882	MODULE_LICENSE("GPL");
1883	MODULE_ALIAS("platform:amiga-serial");
1884

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/tty/amiserial.c

interactive